0, citado
Al ver esta definición de macro, pensando en el uso de secciones en u-boot.lds, creo que __attribute__ debería resumirse.
#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. Formato básico
__attribute__ ((attribute-list))
La lista de atributos puede ser una serie de atributos separados por comas.
El atributo puede establecer el atributo de función, el atributo de variable y el atributo de tipo, etc.
2. Atributos de función
- sin retorno,
- no en línea
- always_inline,
- puro,
- constante
- formato,
- format_arg,
- no_instrument_function,
- sección,
- constructor,
- incinerador de basuras,
- usado,
- no usado,
- obsoleto,
- débil,
- malloc,
- alias.
3. Atributos variables
- alineado,
- modo,
- no común,
- lleno,
- sección,
- unión_transparente,
- no usado,
- obsoleto,
- vector_size,
- débil
4. Atributos de tipo
- alineado,
- lleno,
- unión_transparente,
- no usado,
- obsoleto
5. Atributos comunes 1 ---- sección
Por lo general, el compilador coloca el objetivo compilado en segmentos como datos y bss y, a veces, necesita colocarlo en un segmento específico (consulte el archivo 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. Atributos de uso común 2 ---- débil
Esta definición se utiliza principalmente para funciones de biblioteca y se puede sobrescribir en el código del usuario. La función func con el atributo débil se usa en la función de la biblioteca, y la función con este atributo no se usa en el código de usuario, por lo que dos funciones pueden tener el mismo nombre, una es un símbolo débil y la otra es un símbolo fuerte Si no hay un cuerpo de función de símbolo fuerte, se usa la función de símbolo débil. Cuando hay un símbolo fuerte, no se define una función que usa un símbolo fuerte, se informará un error. Esto se puede usar por compatibilidad.
__weak void green_led_on(void) {}
7. Atributos comunes 2 ---- alineados, empaquetados
Establezca la alineación mínima para variables o estructuras, en bytes.
El formato es el siguiente:
__attribute__ ((aligned (n)))
También es posible dejar que el compilador determine el número de bytes a alinear. El
formato es el siguiente:
__attribute__ ((aligned))
Generalmente, después de establecer el atributo alineado, el espacio ocupado es más grande y empaquetado es para minimizar el espacio ocupado por la estructura después de la variable.
Principio de alineación:
El desplazamiento de caracteres debe ser sizeof (char), que es un múltiplo de 1, y el valor
corto se puede almacenar en cualquier dirección. El desplazamiento debe ser sizeof (corto), que es un múltiplo de 2, y solo puede ser de 0, 2 , 4 ... y otras direcciones que sean múltiplos de 2. Comience a almacenar
int. El desplazamiento debe ser sizeof (int), que es un múltiplo de 4. Solo se puede almacenar en direcciones que sean múltiplos de 4, como 0 , 4, 8 ... y así sucesivamente. El
desplazamiento debe ser sizeof (flotante), que es un múltiplo de 4. El
doble se puede almacenar desde direcciones que son múltiplos de 4, como 0, 4 , 8, etc. el desplazamiento debe ser sizeof (doble), que es un múltiplo de 8, y solo se puede almacenar desde direcciones como 0, 8, 16 ...
struct foo
{
char a;
int x[2] __attribute__ ((packed));
};
El dominio x seguirá inmediatamente al dominio a. (El tamaño es diferente para diferentes plataformas)
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