0, cité
En voyant cette définition de macro, en pensant à l'utilisation des sections dans u-boot.lds, je pense que __attribute__ devrait être résumé.
#define ll_entry_declare(_type, _name, _list) \
_type _u_boot_list_2_##_list##_2_##_name __aligne d(4) \
__attribute__((unused, \
section(".u_boot_list_2_"#_list"_2_"#_name)))
1. Format de base
__attribute__ ((attribute-list))
La liste d'attributs peut être une série d'attributs séparés par des virgules.
L'attribut peut définir l'attribut de fonction, l'attribut de variable et l'attribut de type, etc.
2. Attributs de fonction
- non-retour,
- noinline,
- always_inline,
- pur,
- const,
- format,
- format_arg,
- no_instrument_function,
- section,
- constructeur,
- destructeur,
- utilisé,
- inutilisé,
- obsolète,
- faible,
- malloc,
- alias.
3. Attributs variables
- aligné,
- mode,
- nocif commun,
- emballé,
- section,
- transparent_union,
- inutilisé,
- obsolète,
- taille_vectorale,
- faible
4. Attributs de type
- aligné,
- emballé,
- transparent_union,
- inutilisé,
- obsolète
5. Attributs communs 1 ---- section
Habituellement, le compilateur place la cible compilée dans des segments comme data et bss, et a parfois besoin de la placer dans un segment spécifique (voir le fichier lds).
/sections.c
char __bss_start[0] __attribute__((section(".__bss_start")));
。。。
char __image_copy_end[0] __attribute__((section(".__image_copy_end")));
char __rel_dyn_start[0] __attribute__((section(".__rel_dyn_start")));
。。。
char _end[0] __attribute__((section(".__end")));
6. Attributs couramment utilisés 2 ---- faible
Cette définition est principalement utilisée pour les fonctions de la bibliothèque et peut être écrasée dans le code de l'utilisateur. La fonction func avec l'attribut faible est utilisée dans la fonction de bibliothèque, et la fonction avec cet attribut n'est pas utilisée dans le code utilisateur, de sorte que deux fonctions peuvent avoir le même nom, l'une est un symbole faible et l'autre est un symbole fort S'il n'y a pas de corps de fonction de symbole fort, la fonction de symbole faible est utilisée. Lorsqu'il y a un symbole fort, une fonction qui utilise un symbole fort n'est pas définie, une erreur sera signalée. Cela peut être utilisé pour la compatibilité.
__weak void green_led_on(void) {}
7. Attributs communs 2 ---- alignés, emballés
Définissez l'alignement minimum des variables ou des structures, en octets.
Le format est le suivant:
__attribute__ ((aligned (n)))
Il est également possible de laisser le compilateur déterminer le nombre d'octets à aligner. Le
format est le suivant:
__attribute__ ((aligned))
En règle générale, après avoir défini l'attribut aligné, l'espace occupé est plus grand et le compactage consiste à minimiser l'espace occupé par la structure après la variable.
Principe d'alignement:
L'offset char doit être sizeof (char), qui est un multiple de 1, et
short peut être stocké à n'importe quelle adresse. L' offset doit être sizeof (short), qui est un multiple de 2, et ne peut être que de 0, 2 , 4 ... et d'autres adresses qui sont des multiples de 2. Commencez à stocker
int. Le décalage doit être sizeof (int), qui est un multiple de 4. Il ne peut être stocké qu'à des adresses multiples de 4, telles que 0 , 4, 8 ... et ainsi de suite. Le
décalage doit être sizeof (float), qui est un multiple de 4. Le
double peut être stocké à partir d'adresses multiples de 4, telles que 0, 4 , 8, etc. offset doit être sizeof (double), qui est un multiple de 8, et ne peut être stocké qu'à partir d'adresses telles que 0, 8, 16 ...
struct foo
{
char a;
int x[2] __attribute__ ((packed));
};
Le domaine x suivra immédiatement le domaine a. (La taille est différente pour différentes plates-formes)
struct foo0
{
char a[2];
short b;
int x[2];
} ;
struct foo1
{
char a[3];
short b;
int x[2];
}__attribute__ ((aligned(16))) ;
struct foo2
{
char a[3];
short b __attribute__ ((aligned(8)));
int x[2] __attribute__ ((packed));
};
struct foo3
{
char a[3];
short b __attribute__ ((aligned(8)));
int x[2];
};
struct foo4
{
char a[3];
short b ;
};
qDebug()<<sizeof(int);
qDebug()<<sizeof(foo0);
qDebug()<<sizeof(foo1);
qDebug()<<sizeof(foo2);
qDebug()<<sizeof(foo3);
qDebug()<<sizeof(foo4);
4
12
16
24
24
6