GCC___attribute__关键字和字节对齐

时间  2019-12-05 标签 gcc attribute 关键字 字节 对齐

ffmpeg在代码中大量的使用了字节对齐，甚至在有些成员变量中也定义了字节对齐的宏，使得在看代码时，有时很发难。，特整理以下。html

字节对齐： 为何要对齐：就是为了提升CPU的访问速度或把gcc默认的对齐方式修改下使内存地址连续。如gcc默认是4字节对齐的，你定义个指针的时候，但愿16位对齐，则须要设置。 其实为何要对齐，认真的看看CPU、编译器、调试器、运行结果就什么都明白了，只是为了在编写程序的时候，提升一些编写的效率和运行的效率。c++

指针的属性。
 举例：
定义一个变量 ：
unsigned char rxdata_stream[BUFLEN];
让他字节对齐：
#pragma DATA_SECTION(rxdata_stream,   ".user_data_ext")
#pragma DATA_ALIGN( rxdata_stream,   128)
就是让rxdata_stream地址的末尾7位是0（二进制地址），就是128字节对齐。
对齐的目的，通常是为了CACHE读写外存。若是一个CACHE的line是128字节。这样，若是数据128字节对齐，那么取一个128字节的数据，只使用一个CACHE行就够了。

2ffmpeg中的字节对齐举例：
  __attribute__ ((__format__ (__printf__, 2, 3)))   ///解释见下面。
  #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
  DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2]; ///这样是定义一个变量mv_cache三维数组，他的类型是int16_t而且以16字节对齐，


3，对其中的单词的解释：
__attribute__ 是编译器gcc能识别的定义一个"symbol"属性的关键字。如这个symbol是能够是函数，变量，结构成员等，给这个symbol赋值，就用__attribute__。如上面。
再如：　struct stu{
　　 char sex;
　　 int length;
　　 char name[10];
　　}__attribute__ ((aligned (1)));  这样是字节对齐的属性。


再如定义一个数组：
static const uint8_t  __attribute__((aligned(8))) dither[8][8];
  uint64_t __attribute__((aligned(16))) block_align[32];
  
  //下面整理自：http://www.wangchao.net.cn/bbsdetail_149537.html
再好比：
 下面是你定义的一个函数，他后面有一个尾缀：
 int my_printf (void *my_object, const char *my_format, ...) __attribute__ ((format (printf, 2, 3)))
 {
 
 }
my_printf是一个你本身写的函数，好比多是对vsnprintf等函数进行了封装等等。关键字“__attribute__”能够为函数声明赋属性值，其目的是让编译程序能够优化处理。




关键字“__attribute__”的语法：
 能够为函数（Function Attributes），变量（Variable Attributes）和结构成员（Type Attributes）赋属性。具体能够查看gcc手册（http://gcc.gnu.org/onlinedocs/）。
这里用到的是函数属性，其语法为：“__attribute__ ((attribute-list))”，并置于函数声明尾部";"以前。
format (archetype, string-index, first-to-check)的语法：
　 format属性告诉编译器，按照printf, scanf, strftime或strfmon的参数表格式规则对该函数的参数进行检查。
 "archetype"指定是哪一种风格;
 "string-index"指定传入函数的第几个参数是格式化字符串；
 "first-to-check"指定从函数的第几个参数开始按上述规则进行检查。


上 述例子中，函数my_printf对其参数按“printf”的参数格式进行检查，my_printf的第二个参数的格式化字符串，从my_printf的第三个参数开始进行检查,以知足第二个参数的格式。 。
　　 还有，在编译时只用指定了-Wformat选项，才会出现警告信息。（咱们通常都是-Wall的，没问题）
　　 这样，利用这样一个GCC的编译关键字就能在编译时对你指定的函数进行某种规则检查。赶快行动，在你的程序中加入这些，




让编译器来为你作检查吧。（我在程序中加入这些，立刻编译，马上就发现一个long型变量使用%d进行格式化的错误）


　　 引出的一个题外话：若是上述函数my_printf是一个类的成员函数，那么上述声明就应该写成：
　　 int　　 my_printf (void *my_object, const char *my_format, ...)
　　 __attribute__ ((format (printf, 3, 4)));
　　 为何如今是3，4？

　　 由于类成员函数有一个隐含的参数“this”指针做为函数的第一个参数。（C++基础，寒！本身看了半天都没看出来，仍是向ruiheng老大请教才明白）编程


－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－一下是 转自http://blog.csdn.net/21aspnet/article/details/6729724数组

C语言字节对齐

分类： C基础 2011-08-29 16:06  14199人阅读  评论(36)  收藏  举报
 

文章最后本人作了一幅图，一看就明白了，这个问题网上讲的很多，可是都没有把问题说透。数据结构

　　1、概念 
　　 
　　 对齐跟数据在内存中的位置有关。若是一个变量的内存地址正好位于它长度的整数倍，他就被称作天然对齐。好比在32位cpu下，假设一个整型变量的地址为0x00000004，那它就是天然对齐的。
　　 
　　2、为何要字节对齐
　　 
　　 须要字节对齐的根本缘由在于CPU访问数据的效率问题。假设上面整型变量的地址不是天然对齐，好比为0x00000002，则CPU若是取它的值的话须要访问两次内存，第一次取从0x00000002-0x00000003的一个short，第二次取从0x00000004-0x00000005的一个short而后组合获得所要的数据，若是变量在0x00000003地址上的话则要访问三次内存，第一次为char，第二次为short，第三次为char，而后组合获得整型数据。而若是变量在天然对齐位置上，则只要一次就能够取出数据。一些系统对对齐要求很是严格，好比sparc系统，若是取未对齐的数据会发生错误，举个例：
　　 
　　char ch[8];
　　char *p = &ch[1];
　　int i = *(int *)p;
　　 
　　
　　运行时会报segment error，而在x86上就不会出现错误，只是效率降低。
　　
　　3、正确处理字节对齐
　　
　　 对于标准数据类型，它的地址只要是它的长度的整数倍就好了，而非标准数据类型按下面的原则对齐：
　　
　　数组 ：按照基本数据类型对齐，第一个对齐了后面的天然也就对齐了。 
　　联合 ：按其包含的长度最大的数据类型对齐。 
　　结构体： 结构体中每一个数据类型都要对齐。
　　好比有以下一个结构体：
　　
　　struct stu{
　　 char sex;
　　 int length;
　　 char name[10];
　　};
　　struct stu my_stu;
　　 
　　
　　因为在x86下，GCC默认按4字节对齐，它会在sex后面跟name后面分别填充三个和两个字节使length和整个结构体对齐。因而咱们sizeof(my_stu)会获得长度为20，而不是15.
　　
　　4、__attribute__选项
　　
　　咱们能够按照本身设定的对齐大小来编译程序，GNU使用__attribute__选项来设置，好比咱们想让刚才的结构按一字节对齐，咱们能够这样定义结构体
　　
　　struct stu{
　　 char sex;
　　 int length;
　　 char name[10];
　　}__attribute__ ((aligned (1))); 
　　
　　struct stu my_stu;
　　 
　　
　　则sizeof(my_stu)能够获得大小为15。
　　
　　上面的定义等同于
　　
　　struct stu{
　　 char sex;
　　 int length;
　　 char name[10];
　　}__attribute__ ((packed)); 
　　struct stu my_stu;
　　 
　　
　　__attribute__((packed))得变量或者结构体成员使用最小的对齐方式，即对变量是一字节对齐，对域（field）是位对齐.
　　
　　5、何时须要设置对齐
　　
　　 在设计不一样CPU下的通讯协议时，或者编写硬件驱动程序时寄存器的结构这两个地方都须要按一字节对齐。即便看起来原本就天然对齐的也要使其对齐，以避免不一样的编译器生成的代码不同.
架构

 

1、快速理解ide

1. 什么是字节对齐？函数

在C语言中，结构是一种复合数据类型，其构成元素既能够是基本数据类型（如int、long、float等）的变量，也能够是一些复合数据类型（如数组、结构、联合等）的数据单元。在结构中，编译器为结构的每一个成员按其天然边界（alignment）分配空间。各个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。post

为了使CPU可以对变量进行快速的访问,变量的起始地址应该具备某些特性,即所谓的”对齐”. 好比4字节的int型,其起始地址应该位于4字节的边界上,即起始地址可以被4整除.优化

2. 字节对齐有什么做用？

字节对齐的做用不只是便于cpu快速访问，同时合理的利用字节对齐能够有效地节省存储空间。

对于32位机来讲，4字节对齐可以使cpu访问速度提升，好比说一个long类型的变量，若是跨越了4字节边界存储，那么cpu要读取两次，这样效率就低了。可是在32位机中使用1字节或者2字节对齐，反而会使变量访问速度下降。因此这要考虑处理器类型，另外还得考虑编译器的类型。在vc中默认是4字节对齐的，GNU gcc 也是默认4字节对齐。

3. 更改C编译器的缺省字节对齐方式

在缺省状况下，C编译器为每个变量或是数据单元按其天然对界条件分配空间。通常地，能够经过下面的方法来改变缺省的对界条件：
· 使用伪指令#pragma pack (n)，C编译器将按照n个字节对齐。
· 使用伪指令#pragma pack ()，取消自定义字节对齐方式。

另外，还有以下的一种方式：
· __attribute((aligned (n)))，让所做用的结构成员对齐在n字节天然边界上。若是结构中有成员的长度大于n，则按照最大成员的长度来对齐。
· __attribute__ ((packed))，取消结构在编译过程当中的优化对齐，按照实际占用字节数进行对齐。

4. 举例说明

例1

struct test
{
char x1;
short x2;
float x3;
char x4;
};

因为编译器默认状况下会对这个struct做天然边界（有人说“天然对界”我以为边界更顺口）对齐，结构的第一个成员x1，其偏移地址为0，占据了第1个字节。第二个成员x2为short类型，其起始地址必须2字节对界，所以，编译器在x2和x1之间填充了一个空字节。结构的第三个成员x3和第四个成员x4刚好落在其天然边界地址上，在它们前面不须要额外的填充字节。在test结构中，成员x3要求4字节对界，是该结构全部成员中要求的最大边界单元，于是test结构的天然对界条件为4字节，编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

例2

#pragma pack(1) //让编译器对这个结构做1字节对齐
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1字节对齐，恢复为默认4字节对齐

这时候sizeof(struct test)的值为8。

例3

#define GNUC_PACKED __attribute__((packed))
struct PACKED test
{
char x1;
short x2;
float x3;
char x4;
}GNUC_PACKED;

这时候sizeof(struct test)的值仍为8。

2、深刻理解

什么是字节对齐,为何要对齐?
TragicJun 发表于 2006-9-18 9:41:00 现代计算机中内存空间都是按照byte划分的，从理论上讲彷佛对任何类型的变量的访问能够从任何地址开始，但实际状况是在访问特定类型变量的时候常常在特定的内存地址访问，这就须要各类类型数据按照必定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐。
      对齐的做用和缘由：各个硬件平台对存储空间的处理上有很大的不一样。一些平台对某些特定类型的数据只能从某些特定地址开始存取。好比有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其余平台可能没有这种状况，可是最多见的是若是不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。好比有些平台每次读都是从偶地址开始，若是一个int型（假设为32位系统）若是存放在偶地址开始的地方，那么一个读周期就能够读出这32bit，而若是存放在奇地址开始的地方，就须要2个读周期，并对两次读出的结果的高低字节进行拼凑才能获得该32bit数据。显然在读取效率上降低不少。
二.字节对齐对程序的影响:

        先让咱们看几个例子吧(32bit,x86环境,gcc编译器):
设结构体以下定义：
struct A
{
        int a;
        char b;
        short c;
};
struct B
{
        char b;
        int a;
        short c;
};
如今已知32位机器上各类数据类型的长度以下:
char:1(有符号无符号同)   
short:2(有符号无符号同)   
int:4(有符号无符号同)   
long:4(有符号无符号同)   
float:4        double:8
那么上面两个结构大小如何呢?
结果是:
sizeof(strcut A)值为8
sizeof(struct B)的值倒是12

结构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一个,B也同样;按理说A,B大小应该都是7字节。
之因此出现上面的结果是由于编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果,那么咱们是否是能够改变编译器的这种默认对齐设置呢,固然能够.例如:
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct C)值是8。
修改对齐值为1：
#pragma pack (1) /*指定按1字节对齐*/
struct D
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
sizeof(struct D)值为7。
后面咱们再讲解#pragma pack()的做用.

三.编译器是按照什么样的原则进行对齐的?

        先让咱们看四个重要的基本概念：


1.数据类型自身的对齐值：
      对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，单位字节。
2.结构体或者类的自身对齐值：其成员中自身对齐值最大的那个值。
3.指定对齐值：#pragma pack (value)时的指定对齐值value。
4.数据成员、结构体和类的有效对齐值：自身对齐值和指定对齐值中小的那个值。
有了这些值，咱们就能够很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值N是最终用来决定数据存放地址方式的值，最重要。有效对齐N，就是表示“对齐在N上”，也就是说该数据的"存放起始地址%N=0".而数据结构中的数据变量都是按定义的前后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放，结构体自己也要根据自身的有效对齐值圆整(就是结构体成员变量占用总长度须要是对结构体有效对齐值的整数倍，结合下面例子理解)。这样就不能理解上面的几个例子的值了。
例子分析：
分析例子B；
struct B
{
        char b;
        int a;
        short c;
};
假设B从地址空间0x0000开始排放。该例子中没有定义指定对齐值，在笔者环境下，该值默认为4。第一个成员变量b的自身对齐值是1，比指定或者默认指定对齐值4小，因此其有效对齐值为1，因此其存放地址0x0000符合0x0000%1=0.第二个成员变量a，其自身对齐值为4，因此有效对齐值也为4，因此只能存放在起始地址为0x0004到0x0007这四个连续的字节空间中，复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自身对齐值为2，因此有效对齐值也是2，能够存放在0x0008到0x0009这两个字节空间中，符合0x0008%2=0。因此从0x0000到0x0009存放的都是B内容。再看数据结构B的自身对齐值为其变量中最大对齐值(这里是b）因此就是4，因此结构体的有效对齐值也是4。根据结构体圆整的要求，0x0009到0x0000=10字节，（10＋2）％4＝0。因此0x0000A到0x000B也为结构体B所占用。故B从0x0000到0x000B共有12个字节,sizeof(struct B)=12;其实若是就这一个就来讲它已将知足字节对齐了,由于它的起始地址是0,所以确定是对齐的,之因此在后面补充2个字节,是由于编译器为了实现结构数组的存取效率,试想若是咱们定义了一个结构B的数组,那么第一个结构起始地址是0没有问题,可是第二个结构呢?按照数组的定义,数组中全部元素都是紧挨着的,若是咱们不把结构的大小补充为4的整数倍,那么下一个结构的起始地址将是0x0000A,这显然不能知足结构的地址对齐了,所以咱们要把结构补充成有效对齐大小的整数倍.其实诸如:对于char型数据，其自身对齐值为1，对于short型为2，对于int,float,double类型，其自身对齐值为4，这些已有类型的自身对齐值也是基于数组考虑的,只是由于这些类型的长度已知了,因此他们的自身对齐值也就已知了.
同理,分析上面例子C：
#pragma pack (2) /*指定按2字节对齐*/
struct C
{
        char b;
        int a;
        short c;
};
#pragma pack () /*取消指定对齐，恢复缺省对齐*/
第一个变量b的自身对齐值为1，指定对齐值为2，因此，其有效对齐值为1，假设C从0x0000开始，那么b存放在0x0000，符合0x0000%1=0;第二个变量，自身对齐值为4，指定对齐值为2，因此有效对齐值为2，因此顺序存放在0x000二、0x000三、0x000四、0x0005四个连续字节中，符合0x0002%2=0。第三个变量c的自身对齐值为2，因此有效对齐值为2，顺序存放
在0x000六、0x0007中，符合0x0006%2=0。因此从0x0000到0x00007共八字节存放的是C的变量。又C的自身对齐值为4，因此C的有效对齐值为2。又8%2=0,C只占用0x0000到0x0007的八个字节。因此sizeof(struct C)=8.

四.如何修改编译器的默认对齐值?

1.在VC IDE中，能够这样修改：[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改，默认是8字节。
2.在编码时，能够这样动态修改：#pragma pack .注意:是pragma而不是progma.

五.针对字节对齐,咱们在编程中如何考虑?
        若是在编程的时候要考虑节约空间的话,那么咱们只须要假定结构的首地址是0,而后各个变量按照上面的原则进行排列便可,基本的原则就是把结构中的变量按照类型大小从小到大声明,尽可能减小中间的填补空间.还有一种就是为了以空间换取时间的效率,咱们显示的进行填补空间进行对齐,好比:有一种使用空间换时间作法是显式的插入reserved成员：
             struct A{
               char a;
               char reserved[3];//使用空间换时间
               int b;
}

reserved成员对咱们的程序没有什么意义,它只是起到填补空间以达到字节对齐的目的,固然即便不加这个成员一般编译器也会给咱们自动填补对齐,咱们本身加上它只是起到显式的提醒做用.

六.字节对齐可能带来的隐患:

        代码中关于对齐的隐患，不少是隐式的。好比在强制类型转换的时候。例如：
unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

p=&i;
*p=0x00;
p1=(unsigned short *)(p+1);
*p1=0x0000;
最后两句代码，从奇数边界去访问unsignedshort型变量，显然不符合对齐的规定。
在x86上，相似的操做只会影响效率，可是在MIPS或者sparc上，可能就是一个error,由于它们要求必须字节对齐.

七.如何查找与字节对齐方面的问题:

若是出现对齐或者赋值问题首先查看
1. 编译器的big little端设置
2. 看这种体系自己是否支持非对齐访问
3. 若是支持看设置了对齐与否,若是没有则看访问时须要加某些特殊的修饰来标志其特殊访问操做

举例：

[cpp]  view plain copy
  1. #include <stdio.h>  
  2. main()  
  3. {  
  4. struct A {  
  5.     int a;  
  6.     char b;  
  7.     short c;  
  8. };  
  9.   
  10. struct B {  
  11.     char b;  
  12.     int a;  
  13.     short c;  
  14. };  
  15.   
  16. #pragma pack (2) /*指定按2字节对齐*/  
  17. struct C {  
  18.     char b;  
  19.     int a;  
  20.     short c;  
  21. };  
  22. #pragma pack () /*取消指定对齐，恢复缺省对齐*/  
  23.   
  24.   
  25.   
  26. #pragma pack (1) /*指定按1字节对齐*/  
  27. struct D {  
  28.     char b;  
  29.     int a;  
  30.     short c;  
  31. };  
  32. #pragma pack ()/*取消指定对齐，恢复缺省对齐*/  
  33.   
  34. int s1=sizeof(struct A);  
  35. int s2=sizeof(struct B);  
  36. int s3=sizeof(struct C);  
  37. int s4=sizeof(struct D);  
  38. printf("%d\n",s1);  
  39. printf("%d\n",s2);  
  40. printf("%d\n",s3);  
  41. printf("%d\n",s4);  
  42. }  


输出：

8

12

8

7

 

修改代码：

struct A {
   // int a;
    char b;
    short c;
};

struct B {
    char b;
   // int a;
    short c;
};

输出：

4

4

输出都是4，说明以前的int影响对齐！

看图就明白了

联系我们 沪ICP备13005482号-10