精华内容
下载资源
问答
  • 有关于__alignn

    千次阅读 2018-04-03 14:19:16
    转载于:https://www.cnblogs.com/ye-moooooo/p/4601189.html有关于__alignn)__align__align 关键字指示编译器在 n 字节边界上对齐变量。__align 是一个存储类修饰符。它不影响函数的类型。语法__align(n) ...
    转载于:https://www.cnblogs.com/ye-moooooo/p/4601189.html

    __align

    __align 关键字指示编译器在 n 字节边界上对齐变量。

    __align 是一个存储类修饰符。它不影响函数的类型。

    语法

    __align(n)
    

    其中:

    n

    是对齐边界。

    对于局部变量,n 值可为 1、2、4 或 8。

    对于全局变量,n 可以具有最大为 2 的 0x80000000 次幂的任何值。

    __align 关键字紧靠变量名称前面放置。

    用法

    如果声明的变量的常规对齐边界小于 n__align(n) 是非常有用的。八字节对齐方式可以显著提高 VFP 指令的性能。

    可以将 __align 与 extern 和 static 一起使用。

    限制

    由于 __align 是存储类修饰符,因此不能将其用于:

    • 类型,包括 typedef 和结构定义

    • 函数参数。

    只能进行过对齐。也就是说,可以将两个字节的对象按 4 个字节对齐,而不能将 4 个字节的对象按两个字节对齐。

    示例

    __align(8) char buffer[128];  // buffer starts on eight-byte boundary
    
    void foo(void)
    {
        ...
        __align(16) int i; // this alignment value is not permitted for
                           // a local variable
        ...
    }
    
    __align(16) int i; // permitted as a global variable.
    

    -----------------------------------------------------------------------------------------------------------------------------------------------------

    -----------------------------------------------------------------------------------------------------------------------------------------------------

    一.什么是字节对齐,为什么要对齐?
        现代计算机中内存空间都是按照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,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中,符合0x0002%2=0。第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放
    在0x0006、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. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

    八.ARM下的对齐处理

     

    from DUI0067D_ADS1_2_CompLib

    3.13 type qulifiers

    有部分摘自ARM编译器文档对齐部分

    对齐的使用:
    1.__align(num)
       这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
       就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
       这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
       对齐,但是不能让4字节的对象2字节对齐。
       __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
       
    2.__packed 
    __packed是进行一字节对齐
    1.不能对packed的对象进行对齐
    2.所有对象的读写访问都进行非对齐访问
    3.float及包含float的结构联合及未用__packed的对象将不能字节对齐
    4.__packed对局部整形变量无影响
    5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定
    义为packed。
         __packed int* p; //__packed int 则没有意义
    6.对齐或非对齐读写访问带来问题
    __packed struct STRUCT_TEST
    {
    char a;
    int b;
    char c;
    } ;    //定义如下结构此时b的起始地址一定是不对齐的
             //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]
    //将下面变量定义成全局静态不在栈上 
    static char* p;
    static struct STRUCT_TEST a;
    void Main()
    {
    __packed int* q; //此时定义成__packed来修饰当前q指向为非对齐的数据地址下面的访问则可以

    p = (char*)&a;          
    q = (int*)(p+1);      

    *q = 0x87654321; 
    /*   
    得到赋值的汇编指令很清楚
    ldr      r5,0x20001590 ; = #0x12345678
    [0xe1a00005]   mov      r0,r5
    [0xeb0000b0]   bl       __rt_uwrite4 //在此处调用一个写4byte的操作函数 
          
    [0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问
    [0xe1a02420]   mov      r2,r0,lsr #8
    [0xe5c12001]   strb     r2,[r1,#1]
    [0xe1a02820]   mov      r2,r0,lsr #16
    [0xe5c12002]   strb     r2,[r1,#2]
    [0xe1a02c20]   mov      r2,r0,lsr #24
    [0xe5c12003]   strb     r2,[r1,#3]
    [0xe1a0f00e]   mov      pc,r14
    */

    /*
    如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败
    [0xe59f2018]   ldr      r2,0x20001594 ; = #0x87654321
    [0xe5812000]   str      r2,[r1,#0]
    */

    //这样可以很清楚的看到非对齐访问是如何产生错误的
    //以及如何消除非对齐访问带来问题
    //也可以看到非对齐访问和对齐访问的指令差异导致效率问题
    }

    九.ARM下的边界未对齐访问的后果
    from http://blog.csdn.net/alenwelkin/archive/2006/12/19/1448324.aspx


    自行编写了一个程序,定义一个char型数组如下:
    char p[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80};

    分别用long型和short型指针去指向p+3的位置,这个地址在编译后是0x10963,明显是一个对long和short来说都不对齐的地址。
    程序输出结果如下,括号里为内容,前面是地址。
    /mnt $ ./test
    l 0x10963(0x30201040), s 0x10963(0x5040), lt 0x30201040, st 0x5040

    使用arm-linux-objdump工具反汇编可执行文件发现,对于short指针的引用,编译器做了特殊处理以保证其引用的正确性,而long指针没有做。

    unsigned long *l = (p + 3);
        83e0: e59f3084 ldr r3, [pc, #132] ; 846c <.text+0x190>
        83e4: e50b3010 str r3, [fp, #-16]
    unsigned short *s = (p + 3);
        83e8: e59f307c ldr r3, [pc, #124] ; 846c <.text+0x190>
        83ec: e50b3014 str r3, [fp, #-20]
    unsigned long lt = *l;
        83f0: e51b3010 ldr r3, [fp, #-16] //变量l->r3
        83f4: e5933000 ldr r3, [r3] //l内容->r3
        83f8: e50b3018 str r3, [fp, #-24] //r3->lt
    unsigned short st = *s;
        83fc: e51b3014 ldr r3, [fp, #-20] //变量s->r3
        8400: e5d32000 ldrb r2, [r3] //s内容(低位)->r2
        8404: e5d33001 ldrb r3, [r3, #1] //s内容(高位)->r3
        8408: e1823403 orr r3, r2, r3, lsl #8 //r3左移后与r2拼合成short值->r3
        840c: e54b301a strb r3, [fp, #-26] //r3中的short值(低位)->变量st低位
        8410: e1a03443 mov r3, r3, asr #8 //r3右移8位->r3
        8414: e54b3019 strb r3, [fp, #-25] //r3中的short值(高位)->变量st高位

    0x30201040是怎么来的?想了半天也不明白。
    查 阅ARM相关书籍发现,如果协处理器CP15:c1:c0中的1位和22位均为0,则ARM指令ldr的返回值是memory(addr & ~3, 4) ROR ((addr & 3) * 8)。前半句的含义是对4边界向下取整,在本例中就是0x10960,再取其内容就是 0x40302010,后半句在本例中是循环右移24位。合起来看就是0x40302010 ROR 24 = 0x30201040,与本例正好吻合!

    展开全文
  • 关于__alignn) 字节对齐

    千次阅读 2017-07-24 11:40:12
    __align 关键字指示编译器在 n 字节边界上对齐变量。 __align 是一个存储类修饰符。它不影响函数的类型。 语法 __align(n) 其中: n 是对齐边界。 对于局部变量,n 值可为 1、2、4 或 8。 ...

    __align

    __align 关键字指示编译器在 n 字节边界上对齐变量。

    __align 是一个存储类修饰符。它不影响函数的类型。

    语法

    __align(n)
    

    其中:

    n

    是对齐边界。

    对于局部变量,n 值可为 1、2、4 或 8。

    对于全局变量,n 可以具有最大为 2 的 0x80000000 次幂的任何值。

    __align 关键字紧靠变量名称前面放置。

    用法

    如果声明的变量的常规对齐边界小于 n__align(n) 是非常有用的。八字节对齐方式可以显著提高 VFP 指令的性能。

    可以将 __align 与 extern 和 static 一起使用。

    限制

    由于 __align 是存储类修饰符,因此不能将其用于:

    • 类型,包括 typedef 和结构定义

    • 函数参数。

    只能进行过对齐。也就是说,可以将两个字节的对象按 4 个字节对齐,而不能将 4 个字节的对象按两个字节对齐。

    示例

    __align(8) char buffer[128];  // buffer starts on eight-byte boundary
    
    void foo(void)
    {
        ...
        __align(16) int i; // this alignment value is not permitted for
                           // a local variable
        ...
    }
    
    __align(16) int i; // permitted as a global variable.
    

    -----------------------------------------------------------------------------------------------------------------------------------------------------

    -----------------------------------------------------------------------------------------------------------------------------------------------------

    一.什么是字节对齐,为什么要对齐?
        现代计算机中内存空间都是按照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,所以顺序存放在0x0002、0x0003、0x0004、0x0005四个连续 字节中,符合0x0002%2=0。第三个变量c的自身对齐值为2,所以有效对齐值为2,顺序存放
    在0x0006、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. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。

    八.ARM下的对齐处理

     

    from DUI0067D_ADS1_2_CompLib

    3.13 type qulifiers

    有部分摘自ARM编译器文档对齐部分

    对齐的使用:
    1.__align(num)
       这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时
       就要用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
       这个修饰对象的命令最大是8个字节限制,可以让2字节的对象进行4字节
       对齐,但是不能让4字节的对象2字节对齐。
       __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
       
    2.__packed 
    __packed是进行一字节对齐
    1.不能对packed的对象进行对齐
    2.所有对象的读写访问都进行非对齐访问
    3.float及包含float的结构联合及未用__packed的对象将不能字节对齐
    4.__packed对局部整形变量无影响
    5.强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定
    义为packed。
         __packed int* p; //__packed int 则没有意义
    6.对齐或非对齐读写访问带来问题
    __packed struct STRUCT_TEST
    {
    char a;
    int b;
    char c;
    } ;    //定义如下结构此时b的起始地址一定是不对齐的
             //在栈中访问b可能有问题,因为栈上数据肯定是对齐访问[from CL]
    //将下面变量定义成全局静态不在栈上 
    static char* p;
    static struct STRUCT_TEST a;
    void Main()
    {
    __packed int* q; //此时定义成__packed来修饰当前q指向为非对齐的数据地址下面的访问则可以

    p = (char*)&a;          
    q = (int*)(p+1);      

    *q = 0x87654321; 
    /*   
    得到赋值的汇编指令很清楚
    ldr      r5,0x20001590 ; = #0x12345678
    [0xe1a00005]   mov      r0,r5
    [0xeb0000b0]   bl       __rt_uwrite4 //在此处调用一个写4byte的操作函数 
          
    [0xe5c10000]   strb     r0,[r1,#0]   //函数进行4次strb操作然后返回保证了数据正确的访问
    [0xe1a02420]   mov      r2,r0,lsr #8
    [0xe5c12001]   strb     r2,[r1,#1]
    [0xe1a02820]   mov      r2,r0,lsr #16
    [0xe5c12002]   strb     r2,[r1,#2]
    [0xe1a02c20]   mov      r2,r0,lsr #24
    [0xe5c12003]   strb     r2,[r1,#3]
    [0xe1a0f00e]   mov      pc,r14
    */

    /*
    如果q没有加__packed修饰则汇编出来指令是这样直接会导致奇地址处访问失败
    [0xe59f2018]   ldr      r2,0x20001594 ; = #0x87654321
    [0xe5812000]   str      r2,[r1,#0]
    */

    //这样可以很清楚的看到非对齐访问是如何产生错误的
    //以及如何消除非对齐访问带来问题
    //也可以看到非对齐访问和对齐访问的指令差异导致效率问题
    }

    九.ARM下的边界未对齐访问的后果
    from http://blog.csdn.net/alenwelkin/archive/2006/12/19/1448324.aspx


    自行编写了一个程序,定义一个char型数组如下:
    char p[] = {0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80};

    分别用long型和short型指针去指向p+3的位置,这个地址在编译后是0x10963,明显是一个对long和short来说都不对齐的地址。
    程序输出结果如下,括号里为内容,前面是地址。
    /mnt $ ./test
    l 0x10963(0x30201040), s 0x10963(0x5040), lt 0x30201040, st 0x5040

    使用arm-linux-objdump工具反汇编可执行文件发现,对于short指针的引用,编译器做了特殊处理以保证其引用的正确性,而long指针没有做。

    unsigned long *l = (p + 3);
        83e0: e59f3084 ldr r3, [pc, #132] ; 846c <.text+0x190>
        83e4: e50b3010 str r3, [fp, #-16]
    unsigned short *s = (p + 3);
        83e8: e59f307c ldr r3, [pc, #124] ; 846c <.text+0x190>
        83ec: e50b3014 str r3, [fp, #-20]
    unsigned long lt = *l;
        83f0: e51b3010 ldr r3, [fp, #-16] //变量l->r3
        83f4: e5933000 ldr r3, [r3] //l内容->r3
        83f8: e50b3018 str r3, [fp, #-24] //r3->lt
    unsigned short st = *s;
        83fc: e51b3014 ldr r3, [fp, #-20] //变量s->r3
        8400: e5d32000 ldrb r2, [r3] //s内容(低位)->r2
        8404: e5d33001 ldrb r3, [r3, #1] //s内容(高位)->r3
        8408: e1823403 orr r3, r2, r3, lsl #8 //r3左移后与r2拼合成short值->r3
        840c: e54b301a strb r3, [fp, #-26] //r3中的short值(低位)->变量st低位
        8410: e1a03443 mov r3, r3, asr #8 //r3右移8位->r3
        8414: e54b3019 strb r3, [fp, #-25] //r3中的short值(高位)->变量st高位

    0x30201040是怎么来的?想了半天也不明白。
    查 阅ARM相关书籍发现,如果协处理器CP15:c1:c0中的1位和22位均为0,则ARM指令ldr的返回值是memory(addr & ~3, 4) ROR ((addr & 3) * 8)。前半句的含义是对4边界向下取整,在本例中就是0x10960,再取其内容就是 0x40302010,后半句在本例中是循环右移24位。合起来看就是0x40302010 ROR 24 = 0x30201040,与本例正好吻合!

    展开全文
  • 关于arm汇编中的align

    2020-08-14 06:03:06
    经常会看到arm-linux汇编中有如下的指令: ...它的含义就是使得下面的代码按一定规则对齐,.align n 指令的对齐值有两种方案,n 或 2^n ,各种平台最初的汇编器一般都不是gas,采取方案1或2的都很多。
  • __align 关键字指示编译器在 n 字节边界上对齐变量。 __align 是一个存储类修饰符。它不影响函数的类型。 语法 __align( n ) 其中: n 是对齐边界。 对于局部变量,n 值可为 1、2、4 或 8。 对于全局变量,n 可以...

    https://blog.csdn.net/qq_33658067/article/details/77192069

    __align

    __align 关键字指示编译器在 n 字节边界上对齐变量。

    __align 是一个存储类修饰符。它不影响函数的类型。

    语法
    __align(
    n
    )

    其中:

    n
    是对齐边界。

    对于局部变量,n 值可为 1、2、4 或 8。

    对于全局变量,n 可以具有最大为 2 的 0x80000000 次幂的任何值。

    __align 关键字紧靠变量名称前面放置。

    用法
    如果声明的变量的常规对齐边界小于 n,__align(n) 是非常有用的。八字节对齐方式可以显著提高 VFP 指令的性能。

    可以将 __align 与 extern 和 static 一起使用。

    限制
    由于 __align 是存储类修饰符,因此不能将其用于:

    类型,包括 typedef 和结构定义

    函数参数。

    只能进行过对齐。也就是说,可以将两个字节的对象按 4 个字节对齐,而不能将 4 个字节的对象按两个字节对齐。

    示例
    __align(8) char buffer[128]; // buffer starts on eight-byte boundary
    void foo(void)
    {

    __align(16) int i; // this alignment value is not permitted for
    // a local variable

    }

    __align(16) int i; // permitted as a global variable.

    展开全文
  • C++数据对齐#pragma和__declspec(align(n)).pdf
  • //位操作将n上调至align的倍数,align为2的倍数static size_t ROUND_UP(size_t bytes,unsigned int align){return ((bytes+align-1) & ~(align-1));}
    //位操作将n上调至align的倍数,align为2的倍数static size_t ROUND_UP(size_t bytes,unsigned int align){return ((bytes+align-1) & ~(align-1));}
    

     
    
    
    展开全文
  • align的对齐方式

    千次阅读 2016-08-09 01:18:34
    经常会看到arm-linux汇编中有如下的指令: .align n 它的含义就是使得下面的代码按一定规则对齐。....align n 指令的对齐值有两种方案:n 或 2^n 。 各种平台最初的汇编器一般都不是gas,采取方案1或2的
  • __align :关键字指示编译器在 n 字节边界上对齐变量。是一个存储类修饰符。它不影响函数的类型。 __align(n)由于 __align 是存储类修饰符,因此不能将其用于:  类型,包括 typedef 和结构定义函数参数。  ...
  • .align 5之类的知识

    2018-02-07 13:45:24
    from:....align n 指令的对齐值有两种方案:n 或 2^n 。各种平台最初的汇编器一般都不是gas,采取方案1或2的都很多,gas的目标是取代原来的汇编器,必...
  • ARM下的对齐处理 ...1.__align(num) 这个用于修改最高级别对象的字节边界。在汇编中使用LDRD或者STRD时 就要用到此命令__align(8)进行修饰限制,来保证数据对象是相应对齐。 这个修饰对象的命令最
  • C++数据对齐#pragma和__declspec(align(n))

    千次阅读 2015-10-22 10:26:52
    如果一个类型按n字节对齐,那么该类型的变量起始地址必须是n的倍数。比如int按四字节对齐,那么int类型的变量起始地址一定是4的倍数,比如0x0012ff60,0x0012ff48等。   数据自身的对齐 数据自身的对齐...
  • RoIAlign源码解析

    千次阅读 2018-02-01 20:31:31
    RoIAlign源码及示意图 /* * 参数解释 * bottom_data 需要做RoIAlign的feature map * spatial_scale feature map放缩的尺寸 vgg是1/16 * channels height width feature map的通道高和宽不用多说 * pooled_height ...
  • #pragma pack(4) ..._attribute_((packed))和_attribute_((aligned(n)))   armcc一般是专门针对arm芯片开发时用的编译器,语法除了遵守标准C语法外,还支持arm体系下特有的语法规则。gcc应用...
  • vscode markdown align失效

    2019-12-27 12:05:15
    想要在vscode下的markdown文件中插入多行对齐的公式,但是尝试 alignalign* 都不可行。 $$ \begin{align} f(x) & = (m+n)^2 \\ & = m^2+2mn+n^2 \\ \end{align} $$ 显示: \begin{align} f(x) & = ...
  • 这个“对齐”的位置,就是指可以被一个数整除的地址,这个数叫做“对齐参数”,一般是1,2,4,8,16……具体这个参数的选取就要用到#pragma pack( n )和__declspec( align(#) 中的n,#以及数据本身所占字节的大小,比如...
  • 有效对齐N,就是表示“对齐在N上”,也就是说该数据的”存放起始地址%N=0”.而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放,...
  • ALIGN MACRO understanding

    2014-03-31 20:47:02
    /*  Detect n-bytes alignment.  Old 8 bytes alignment macro:  #define _CI_ALIGN(val) ((val+7)&~7) ...struct _ci_align_test {char n[1]; double d;}; #define _CI_NBYTES_ALIGNMENT ((size_t) &(((struct _
  • ROIAlign源码详细解析

    千次阅读 2019-12-25 23:10:43
    ROI Align 是在Mask-RCNN这篇论文里提出的一种区域特征聚集方式, 很好地解决了ROI Pooling操作中两次量化造成的区域不匹配(mis-...插值定义:函数 y=f(x)在区间[a, b]上(n+1)个互异点xi(i=0,1,2...n)上的函数值y...
  • <br />内存对齐 #pragma pack(n) __declspec(align(#)) 2008年11月13日 星期四 16:10 看一下这两个指令是如何影响变量在内存的存储的。 1、pack pragma   pack pragma设置了struct...
  • __align用法

    2009-12-10 14:14:00
    __align__align 关键字指示编译器在 n 字节边界上对齐变量。__align 是一个存储类修饰符。它不影响函数的类型。语法__align(n)其中:n 是对齐边界。对于局部变量,n 值可为 1、2、4 或 8。对于全局变量,n 可以具有...
  • __align 关键字指示编译器在 n 字节边界上对齐变量。 __align 是一个存储类修饰符。它不影响函数的类型。 语法 __align(n) 其中: n 是对齐边界。 对于局部变量,n 值可为 1、2、4 或 8。 对于全局变量,n 可以具有...
  • LINUX对齐Align原理

    千次阅读 2019-02-18 14:16:40
    #define __DATA_ALIGN(end, align) (((unsigned int)end+align-1)&amp;(~(align-1))) #define __MSG_ALIGNED(end) __DATA_ALIGN(end, 0x10) 光看字面意思,可以知道是字节align大小对齐的作用。原理上是怎么一...
  • 2、ROIAlign 上面RoI Pooling从原图ROI映射到卷积区域,即原图ROI与特征图ROI之间的映射,使用了stride间隔的取整,使得特征图ROI再映射回原图ROI的时候有stride的误差。尤其经过最大值池化后的...
  • __align的用法

    千次阅读 2009-03-31 22:10:00
    __align:__align 关键字指示编译器在 n 字节边界上对齐变量。__align 是一个存储类修饰符。 它不影响函数的类型。语法__align(n)其中:n是对齐边界。对于局部变量,n 可以具有值 1、2、4 或 8。对于全局变量,n ...
  • __align 关键字指示编译器在 n 字节边界上对齐变量。 __align 是一个存储类修饰符。它不影响函数的类型。 语法 __align(n) 其中: n是对齐边界。 对于局部变量,n 值可为 1、2、4 或 8。 对于全局变量,n ...
  • 地址对齐宏ALIGN

    千次阅读 2011-09-28 23:51:26
    写出C语言的地址对齐宏ALIGN(Ptr, Bytes),其中Ptr是要对齐的地址,Bytes是要对齐的字节数(2的N次方),比如说:ALIGN(13,16)=16 #define ngx_align(d, a) (((d) + (a - 1)) & ~(a -
  • 用英文写,写了也等写火星文。 现在的一些处理器,需要你的数据的内存地址必须是对齐(align)的,即使不是必须,如果你对齐的话,运行的速度也会得到提升。虽然对齐会产生的额外内存空间,但相对于这个速度

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 149,963
精华内容 59,985
关键字:

ALIGN(n)