ARM程序由于字节对齐引起的问题深入分析

 首先说说，什么叫对齐。如果一个数据是从偶地址开始的连续存储，那么它就是半字对齐，否则就是非半字对齐；半字对齐的特征是bit0=0,其他位为任意值。字对齐的特征是bit1=0,bit0=1,其他位为任意值。如果一个数据是以能被4 整除的地址开始的连续存储，那么它就是字对齐，否则就是非字对齐。举例说明四字节对齐： 对内存进行操作时，被访问的地址必须为4的倍数。如果分配到的地址的地址不是4的倍数时，CPU实际访问的地址还是按照字对齐的方式来操作。也就是自动屏蔽bit1和bit0.

用ADS的ARM C Complier下Optimization Level可能引起问题，其中的一个问题就是字节对齐的问题。下面讲讲问题的现象及实质。

当时问题的现象是：程序使用一公共变量Buf创建队列，如果ADS编译优化选项采用Minium则软件工作正常；源码不变，如果采用ALL优化，则不正常，数据紊乱且无法工作。为了发现问题，我们分别用Minium和ALL编译，在反汇编条件下单步跟踪程序，观察CPU寄存器和内存变量的变化情况。发现在Minium模式下，编译器把队列内存块Uart0TxBuf分配到的地址是0x400015cc,这个地址是一个4字节对齐的地址，而在ALL模式下，编译器把Buf分配的地址是0x400015c2，这个地址是一个非4字节对齐的地址。正是由于这个非4字节对齐的地址导致了问题的发生。
问题发生在QueueCreate(void *Buf, uint32 SizeOfBuf, uint8 (* ReadEmpty)(), uint8 (* WriteFull)())这个函数里，问题是如何发生的，

在了解问题发生的机理前，先了解QueueCreate这个函数的工作原理。QueueCreate工作原理是，首先把buf指向的内存初始化为DataQueue格式的结构体。 DataQueue的结构体格式如下：
typedef struct {
QUEUE_DATA_TYPE *Out; /* 指向数据输出位置 */
QUEUE_DATA_TYPE *In; /* 指向数据输入位置 */
QUEUE_DATA_TYPE *End; /* 指向Buf的结束位置 */
uint16 NData; /* 队列中数据个数 */
uint16 MaxData; /* 队列中允许存储的数据个数 */

uint8 (* ReadEmpty)(); /* 读空处理函数 */
uint8 (* WriteFull)(); /* 写满处理函数 */
QUEUE_DATA_TYPE *Buf; /* 存储数据的空间 */
} DataQueue;
从结构体可以看出，结构体字节类型在内存分配为： 4字节指针变量（*Out）、4字节指针变量（*In）、4字节指针变量（*End）、2字节变量NData、2字节变量MaxData、4字节函数指针变量ReadEmpty（）、4字节函数指针变量（WriteFull（））
观察结构体起始地址放在非对齐时会出现什么情况。

起始地址为0x400015c2时的由编译器分配得到的地址 实际操作地址
*Out 0x400015c2~0x400015c5 0x40015c0~0x400015c3
*In 0x400014c6~0x400015c9 x400014c4~0x400015c7
*End 0x400015ca~0x400015cd 0x400015c8~0x400015cb
从表中可以看出，实际操作的地址按照4字节对齐格式得到。例如，当执行*Out进行操作时，自动屏蔽bit1和bit0,因此实际发生变化的是0x40015c0~0x400015c3，而不是0x400015c2~0x400015c5，由于实际操作地址和编译器分配地址互相覆盖，当对*In操作时，会导致*Out一起变化，对*End操作时，*In也跟着变化。正是由于非对齐的原因导致创建队列和对列操作完全错误。
当内存起始地址为4字节对齐地址的情况时，编译器分配地址和实际地址一致，因此不存在上述问题。

结 论：

在ARM嵌入式系统中，当把一个内存区域初始化为某个结构体时，必须注意字节对齐的情况。如果该内存起始地址为非对齐地址，不仅得不到预期的结果，还可能导致一些很奇怪的让人无法理解表面问题。在C层面上不太容易观察到这些问题的实质，只有深入到汇编一层去分析程序，才可能理解这些现象的深层原因。

一、啥是字对齐？为啥要字对齐？

      现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问都可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就是对齐。

字节对齐的原因大致是如下两条：

1、平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2、性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

、ARM平台的对齐问题

在ARM中，有ARM和Thumb两种指令。

ARM指令：每执行一条指令，PC的值加4个字节（32bits）.一次访问4字节内容，该字节的起始地址必须是4字节对齐的位置上，即地址的低两位为bits[0b00],也就是说地址必须是4的倍数。

Thumb指令：每执行一条指令，PC的值加2个字节（16bits）.）.一次访问2字节内容，该字节的起始地址必须是2字节对齐的位置上，即地址的低两位为bits[0b0],也就是说地址必须是2的倍数。

     遵循以上方式叫对齐（aligned）方式，不遵守这样方式称为非对齐（unaligned）的存储访问操作。

 

五、ARM平台字节对齐关键字
1. __align(num)
   用于修改最高级别对象的字节边界。
A、在汇编中使用LDRD或者STRD时，就用到此命令__align(8)进行修饰限制。来保证数据对象是相应对齐。
B、该修饰对象的命令最大是8个字节限制,可让2字节的对象进行4字节
   对齐,但是不能让4字节的对象2字节对齐。
C、 __align是存储类修改,他只修饰最高级类型对象不能用于结构或者函数对象。
   
2. __packed 
__packed是进行一字节对齐。
A、不能对packed的对象进行对齐；
B、所有对象的读写访问都进行非对齐访问；
C、float及包含float的结构联合及未用__packed的对象将不能字节对齐；
D、__packed对局部整形变量无影响；
D、强制由unpacked对象向packed对象转化是未定义,整形指针可以合法定
义为packed __packed int* p; //__packed int 则没有意义。

3. __unaligned
   用于修饰该变量可按照非对齐访问。

arm中的字节对齐问题

  (2011-04-02 11:03:56)

转载▼

标签：  杂谈

昨天调程序，发现一个不得解的问题，传过来的地址明明是正确的，可是一读却是一条非法指令。不写操作。很长时间不能解决，师兄过来看了一下，才现是字节对齐的问题。唉，终于碰到对齐问题了，那就好好解决一下吧。先说下我遇到的问题

typedef sturct

{

char a;

char b;

char c[255];

}   FS;

FS fs;

....

disk_read(...,fs->c,...)

....

void disk_read(...,int* p,...)

{

....

*p++=0x01010101;    //error:

....

}

到了这一步，也就可以看一下问题发生的原因了，在结构体中，对将c做到字节对齐，这样

和disk_read中的P的四字节对齐是不同的，这样写的时候由于不是四字节对齐，就会出错

下面转两篇字节对齐的文章。戒之戒之

=====================================================

有了上面的基础后，在一些数据结构中就要消除这些字节带来的影响，特别是在文件访问的过程中，在各个平台上都会遇到。

文件为了保持最小，利用空间的原则，会按照字节来存储的，但是我们在内存中定义的结构会按最优原则使效率最大，这样会保持边界对齐。那么如何消除影响呢，

 

先看在   vc中如保操作

 

#pragma pack(push, 1)         == #paragma pack(push)   #paragma pack(1)

struct T

{

         int a;

         char b;

}

#paragma pack(pop)

 

再来看看ads 在arm平台是如何操作的

 

__packed

struct T

{

     int a;

     char b;

}

 

最后来看看gcc下面的操作

__attribute__((__packed__))

struct T

{

       int a;

       char b;

}

 

 

最后，让我们来看看怎么定义一个结构才是移植性够好的结构

 

PACK_STRUCT_BEGIN
struct ip_hdr {
 
   PACK_STRUCT_FIELD(u16_t _id);
 
   PACK_STRUCT_FIELD(struct ip_addr src);
} PACK_STRUCT_STRUCT;
PACK_STRUCT_END

 

通过引个宏来改变这些相应的结构

#ifdef __GNU_C__

#define PACK_STRUCT_FIELD(x)   x
#define PACK_STRUCT_STRUCT   __attribute__((__packed__))
#define PACK_STRUCT_BEGIN
#define PACK_STRUCT_END

#elif__ADS__

#define PACK_STRUCT_FIELD(x) __packed x
#define PACK_STRUCT_STRUCT
#define PACK_STRUCT_BEGIN    __packed
#define PACK_STRUCT_END

#elif __VC__

#define PACK_STRUCT_FIELD(x) x
#define PACK_STRUCT_STRUCT
  #define PACK_STRUCT_BEGIN   #pargma pack (push, 1)  (问题代码)
  #define PACK_STRUCT_END     #pargma pack (pop)       （问题代码）

#else

#define PACK_STRUCT_FIELD(x)
#define PACK_STRUCT_STRUCT
#define PACK_STRUCT_BEGIN
#define PACK_STRUCT_END

#endif

好啦，到此为止一切都结束了，这就是相关的字节对齐的一些操作，原来我只以为只有最后这一种情况才是呢，最上面的那种情况是后来调试才遇到的，至于以后，可能还会有，再做补充了

 

ps:上面有两行问题代码，自己用的时候才发现，宏定义中出现"#"，几乎不可能，所以放弃这样的想法

宏定义中的#可以把一个数字变成字串 ##则代表字符串连接。

所以想要实现就要麻烦一些了，最后我是这样实现的，不好看但管用。

#if defined _ADS_

__packed

#elif defined _GCC_

__attribute__((__packed__))

#elif defined _VC_

#pargma pack(push, 1)

#endif

struct a

{...};

#ifdef _VC_

#pargma pack(pop)

#endif

=============================================================================

http://blogold.chinaunix.net/u1/36006/showart_569730.html

一.什么是字节对齐,为什么要对齐?
     现代计算机中内存空间都是按照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)
struct C
{
     char b;
     int a;
     short c;
};
#pragma pack ()
sizeof(struct C)值是8。
修改对齐值为1：
#pragma pack (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)
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. 如果支持看设置了对齐与否,如果没有则看访问时需要加某些特殊的修饰来标志其特殊访问操作。
八.相关文章:转自http://blog.csdn.net/goodluckyxl/archive/2005/10/17/506827.aspx
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; 


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

 

移植需要注意字节对齐问题

分类： c/c++ 2012-02-15 17:17 196人阅读 评论(0) 收藏 举报

今天YD在移植告警模块时遇到一个很稀罕的warning，google+baidu也没有找到结果。

warning描述如下： Warning[Pa039]: use of address of unaligned structure member ......

对应的程序为： lstInit(&(gCurAlarmList.currentAlarmTable));

gCurAlarmList的定义为：

typedef struct curAlarmList
{
ALARM_ELEMENT *pstCurAlarmList; /*记录的起始地址 */
LIST currentAlarmTable; /* 当前告警表的入口　*/
LIST freeAlarmEntresQueue; /*空闲结点表 */
ALARM_ELEMENT *pstFirstEntryInAlarmList; /*第一个条目的地址 */
int curAlarmItems; /*当前告警的条目数*/
}CUR_ALARM_LIST;

YD先采用强制类型转换的方式告警并未消除。在正文中加入#pragma pack(1)也无效。怀疑为数据结构声明环境的问题。

与YD确认，系统使用的是ARM的体系结构和指令集，ARM有下面限制：

在ARM中，有ARM和Thumb两种指令。

ARM指令：每执行一条指令，PC的值加4个字节（32bits）.一次访问4字节内容，该字节的起始地址必须是4字节对齐的位置上，即地址的低两位为bits[0b00],也就是说地址必须是4的倍数。

Thumb指令：每执行一条指令，PC的值加2个字节（16bits）.）.一次访问2字节内容，该字节的起始地址必须是2字节对齐的位置上，即地址的低两位为bits[0b0],也就是说地址必须是2的倍数。

检查数据结构声明文件中发现头文件中有#pragma pack(1)，遂改为#pragma pack(4)，再编译warning消失。

但是，一定要注意：这绝不是结束，还需要代码允许的正确性，例如结构中的小于4B的char 成员是否还可正常访问。