一、介绍

GNU C 的一大特色就是__attribute__ 机制。__attribute__可以设置函数属性（Function Attribute ）、变量属性（Variable Attribute ）和类型属性（Type Attribute ）。

__attribute__书写特征是：attribute 前后都有两个下划线，后面紧跟一对括弧，括弧里面是相应的attribute 参数。

__attribute__语法格式为：__attribute__((attribute-list))

关键字__attribute__也可以对结构体（struct ）或共用体（union ）进行属性设置。大致有六个参数值可以被设定，即：aligned, packed, transparent_union, unused, deprecated 和 may_alias 。

在使用__attribute__参数时，你也可以在参数的前后都加上 “” （两个下划线），例如，使用aligned__而不是 aligned ，这样，你就可以在相应的头文件里使用它而不用关心头文件里是否有重名的宏定义。

二、attribute的参数介绍

1、aligned

指定对象的对齐格式（以字节为单位），如：

  1. struct S { 
  2.     short b[3]; 
  3. } __attribute__((aligned (8))); 
  5. typedef int int32_t __attribute__((aligned (8)));

该声明将确保（尽它所能）变量类型为 struct S 或者 int32_t 的变量在分配空间时采用 8 字节对齐方式。

如上所述，你可以手动指定对齐的格式，同样，你也可以使用默认的对齐方式。如果 aligned 后面不紧跟一个指定的数字值，那么编译器将依据你的目标机器情况使用最大最有益的对齐方式。例如：

  1. struct S { 
  2.     short b[3]; 
  3. } __attribute__((aligned));

这里，如果 sizeof(short)的大小为 2byte，那么，S 的大小就为 6 。取一个 2 的次方值，使得该值大于等于 6 ，则该值为 8 ，所以编译器将设置 S 类型的对齐方式为 8 字节。

aligned 属性使被设置的对象占用更多的空间，相反的，使用 packed 可以减小对象占用的空间。

需要注意的是，attribute 属性的效力与你的连接器也有关，如果你的连接器最大只支持 16 字节对齐，那么你此时定义 32 字节对齐也是无济于事的。

2、packed

使用该属性对 struct 或者 union 类型进行定义，设定其类型的每一个变量的内存约束。就是告诉编译器取消结构在编译过程中的优化对齐（使用 1 字节对齐）, 按照实际占用字节数进行对齐，是 GCC 特有的语法。这个功能跟操作系统没关系，跟编译器有关，gcc 编译器不是紧凑模式的，我在 windows 下，用 vc 的编译器也不是紧凑的，用 tc 的编译器就是紧凑的。

下面的例子中，packed_struct 类型的变量数组中的值将会紧紧的靠在一起，但内部的成员变量 s 不会被 “pack” ，如果希望内部的成员变量也被 packed 的话，unpacked-struct 也需要使用 packed 进行相应的约束。

  1. struct unpacked_struct
  2. {
  3.       char c;
  4.       int i;
  5. };
  7. struct packed_struct
  8. {
  9.      char c;
  10.      int  i;
  11.      struct unpacked_struct s;
  12. }__attribute__ ((__packed__));


如：

  1. 在TC下：struct my{ char ch; int a;}      sizeof(int)=2;sizeof(my)=3;（紧凑模式）
  3. 在GCC下：struct my{ char ch; int a;}     sizeof(int)=4;sizeof(my)=8;（非紧凑模式）
  5. 在GCC下：struct my{ char ch; int a;}__attrubte__ ((packed))        sizeof(int)=4;sizeof(my)=5


下面的例子中使用attribute 属性定义了一些结构体及其变量，并给出了输出结果和对结果的分析。代码为：

  1. struct p
  2. {
  3.     int a;
  4.     char b;
  5.     short c;
  7. }__attribute__((aligned(4))) pp;
  9. struct m
  10. {
  11.     char a;
  12.     int b;
  13.     short c;
  14. }__attribute__((aligned(4))) mm;
  16. struct o
  17. {
  18.     int a;
  19.     char b;
  20.     short c;
  21. }oo;
  23. struct x
  24. {
  25.     int a;
  26.     char b;
  27.     struct p px;
  28.     short c;
  29. }__attribute__((aligned(8))) xx;
  31. int main()
  32. {           
  33.     printf("sizeof(int)=%d,sizeof(short)=%d.sizeof(char)=%d\n",sizeof(int)
  34.                                                 ,sizeof(short),sizeof(char));
  35.     printf("pp=%d,mm=%d \n", sizeof(pp),sizeof(mm));
  36.     printf("oo=%d,xx=%d \n", sizeof(oo),sizeof(xx));
  37.     return 0;
  38. }


输出结果：
sizeof(int)=4, sizeof(short)=2.sizeof(char)=1
pp=8, mm=12
oo=8, xx=24

分析：都是字节对齐的原理，可以去看这儿：字节对齐
__packed关键字作用类似，例如：

  1. typedef __packed struck test_s
  2. {
  3. ...
  4. }test_t;

3、at

绝对定位，可以把变量或函数绝对定位到 Flash 中，或者定位到 RAM。

1)、定位到 flash 中，一般用于固化的信息，如出厂设置的参数，上位机配置的参数，ID 卡的 ID 号，flash 标记等等

  1. const u16 gFlashDefValue[512] __attribute__((at(0x0800F000))) = {0x1111,0x1111,0x1111,0x0111,0x0111,0x0111};//定位在flash中,其他flash补充为00
  2. const u16 gflashdata__attribute__((at(0x0800F000))) = 0xFFFF;

2)、定位到 RAM 中，一般用于数据量比较大的缓存，如串口的接收缓存，再就是某个位置的特定变量

  1. u8 USART2_RX_BUF[USART2_REC_LEN] __attribute__ ((at(0X20001000)));//接收缓冲,最大USART_REC_LEN个字节,起始地址为0X20001000.

注意：
1)、绝对定位不能在函数中定义，局部变量是定义在栈区的，栈区由 MDK 自动分配、释放，不能定义为绝对地址，只能放在函数外定义。
2)、定义的长度不能超过栈或 Flash 的大小，否则，造成栈、Flash 溢出。

4、section

提到 section，就得说 RO RI ZI 了，在 ARM 编译器编译之后，代码被划分为不同的段，RO Section(ReadOnly) 中存放代码段和常量，RW Section(ReadWrite) 中存放可读写静态变量和全局变量，ZI Section(ZeroInit) 是存放在 RW 段中初始化为 0 的变量。

于是本文的大体意思就清晰了，attribute((section(“section_name”)))，其作用是将作用的函数或数据放入指定名为”section_name” 对应的段中。

1)、编译时为变量指定段：

  1. __attribute__((section("name")))
  2. RealView Compilation Tools for µVision Compiler Reference Guide Version 4.0 
  4. Home > Compiler-specific Features > Variable attributes > __attribute__((section("name"))) 
  6. 4.5.6. __attribute__((section("name")))
  7. Normally, the ARM compiler places the objects it generates in sections like data and bss. However, you might require additional data sections or you might want a variable to appear in a special section, for example, to map to special hardware. The section attribute specifies that a variable must be placed in a particular data section. If you use the section attribute, read-only variables are placed in RO data sections, read-write variables are placed in RW data sections unless you use the zero_init attribute. In this case, the variable is placed in a ZI section.
  9. Note
  10. This variable attribute is a GNU compiler extension supported by the ARM compiler.
  12. Example
  13. /* in RO section */
  14. const int descriptor[3] __attribute__ ((section ("descr"))) = { 1,2,3 };
  15. /* in RW section */
  16. long long rw[10] __attribute__ ((section ("RW")));
  17. /* in ZI section *
  18. long long altstack[10] __attribute__ ((section ("STACK"), zero_init));/

2)、编译时为函数指定段

  1. __attribute__((section("name")))
  2. RealView Compilation Tools for µVision Compiler Reference Guide Version 4.0 
  4. Home > Compiler-specific Features > Function attributes > __attribute__((section("name"))) 
  6. 4.3.13. __attribute__((section("name")))
  7. The section function attribute enables you to place code in different sections of the image.
  9. Note
  10. This function attribute is a GNU compiler extension that is supported by the ARM compiler.
  12. Example
  13. In the following example, Function_Attributes_section_0 is placed into the RO section new_section rather than .text.
  15. void Function_Attributes_section_0 (void) __attribute__ ((section ("new_section")));
  16. void Function_Attributes_section_0 (void)
  17. {
  18.     static int aStatic =0;
  19.     aStatic++;
  20. }
  21. In the following example, section function attribute overrides the #pragma arm section setting.
  23. #pragma arm section code="foo"
  24.   int f2()
  25.   {
  26.       return 1;
  27.   }                                  // into the 'foo' area
  29.   __attribute__ ((section ("bar"))) int f3()
  30.   {
  31.       return 1;
  32.   }                                  // into the 'bar' area
  34.   int f4()
  35.   {
  36.       return 1;
  37.   }                                  // into the 'foo' area
  38. #pragma arm section

5、多个属性，组合使用

  1. u8 FileAddr[100] __attribute__ ((section ("FILE_RAM"), zero_init,aligned(4)));

转载自：C语言attribute的使用