x64结构体内存对齐大小的问题

陌路

原以为 x64的结构体是以8字节对齐的
当计算结构大小的时候 不够8字节的补齐,比如
结构大小 0x2c  sizeof的时候 会显示0x30 补齐8字节

可是后来, 反汇编时 发现这么行不通
反汇编的时候 操作的都是+?h 的偏移
所以 判断成员的大小很有必要 ,所以又做了一个实验

1. typedef struct SIZEOF {
   
2.         ULONG Count;
   
3.         PVOID Ower;
   
4.         ULONG A;
   
5.         KEVENT Event;
   
6.         ULONG Irql;
   
7. } SIZEOF;
   
8. DbgPrint("SIZEOF=0x%x\n", sizeof(SIZEOF));
   
9. DbgPrint("KEVENT=0x%x\n", sizeof(KEVENT));
   
10. DbgPrint("PVOID=0x%x\n", sizeof(PVOID));
    
11. DbgPrint("ULONG=0x%x\n", sizeof(ULONG));
    
12. 打印结果:
    
13.                         SIZEOF=0x38
    
14.                         KEVENT=0x18
    
15.                         PVOID=0x8
    
16.                         ULONG=0x4

复制代码

看到打印结构发现了什么 ?
3个ULONG =C;
C+8+0x18= 2c; 可是这与结构完全不同
哦,想了想 原来分配内存的时候
把 不是8字节的 变量 都以8字节对齐
4*8=0x20; 然后 0x20+0x18=0x38;  

哦,原来如此, 挺高兴的,
但是 如果真的这么认为 就大错特错了

当时我是这么认为的, 可是后来又在看汇编代码的时候
发现又发现了问题,按照前面对结构理解的思路
汇编代码中的结构体 对不上号了;
这让我恼火了很长时间,最后发现就是出现在结构上的时候
决定重新 研究下 这个结构什么时候 到底多大;
又实验:

1.         typedef struct SIZEOF {
   
2.                 ULONG Count;
   
3.                 PVOID Ower;
   
4.                 ULONG A;
   
5.                 //KEVENT Event;
   
6.                 ULONG Irql;
   
7.         } SIZEOF;
   
8.         DbgPrint("SIZEOF=0x%x\n", sizeof(SIZEOF));
   
9. SIZEOF=0x18

复制代码

显然 0x18+KEVENT(0x18)=0x30; 跟上边的 0x38 显然是不一样的

然后就想难道以 结构中最大 值来决定的?
或者 ````再多的猜想也没用, 实验吧;
经过了N次 实验后 发现问题了  原来是我对内存对齐的概念没有搞清楚

1.         typedef struct SIZEOF {
   
2.                 UCHAR A;
   
3.                 ULONG64 B;
   
4.                 UCHAR C;
   
5.                 ULONG64 D;
   
6.                 UCHAR E;
   
7.                 ULONG64 F;
   
8.                 ULONG G;
   
9.                 ULONG64 K;
   
10.         } SIZEOF;
    
11.         DbgPrint("SIZEOF=0x%x\n", sizeof(SIZEOF));
    
12.         SIZEOF=0x40

复制代码

       
        结果是0x40 因为是8字节对齐方式
        比如第一个成员 uchar 1个字节
        但是下一个是8个字节的 要对齐
        所以这就成0x10个字节了
       
        同样 我把 成员变量的位置换 一下
        马上就变了

1.                 typedef struct SIZEOF {
   
2.                 UCHAR A;
   
3.                 UCHAR C;
   
4.                 UCHAR E;
   
5.                 ULONG64 B;
   
6.                 ULONG64 D;
   
7.                 ULONG64 F;
   
8.                 ULONG G;
   
9.                 ULONG64 K;
   
10.         } SIZEOF;
    
11.         SIZEOF=0x30

复制代码

因为 少了2个8字节对齐 所以少了0x10
第一个8字节 能存放下 3个uchar 类型
现在 我把ulong 放到上边,一定会又少8个字节

1.         typedef struct SIZEOF {
   
2.                 UCHAR A;
   
3.                 UCHAR C;
   
4.                 UCHAR E;
   
5.                 ULONG G;
   
6.                 ULONG64 B;
   
7.                 ULONG64 D;
   
8.                 ULONG64 F;       
   
9.                 ULONG64 K;
   
10.         } SIZEOF;
    
11.         DbgPrint("SIZEOF=0x%x\n", sizeof(SIZEOF));
    
12. SIZEOF=0x28

复制代码

注意这 上边是以8字节为准的 ,如果没有 8字节的变量呢
所以 这样实验下        

1.         typedef struct SIZEOF {
   
2.                 UCHAR A;
   
3.                 UCHAR C;
   
4.                 UCHAR E;
   
5.                 ULONG G;
   
6.                 ULONG B;
   
7.         } SIZEOF;
   
8.         DbgPrint("SIZEOF=0x%x\n", sizeof(SIZEOF));
   
9. SIZEOF=0xc

复制代码

现在是以4字节对齐的了,
这么看来 如果一个结构中最大的不超过8字节
将不会以8字节为准 以最大的字节 比如这样

1.         typedef struct SIZEOF {
   
2.                 UCHAR E;
   
3.                 USHORT a;
   
4.         } SIZEOF;
   
5.         DbgPrint("SIZEOF=0x%x\n", sizeof(SIZEOF));
   
6. SIZEOF=0x4
   

复制代码

0xAA55

不错的尝试，楼主好评。以前我也只知道有对齐这么一回事儿，现在弄清楚了。

陌路

0xAA55 发表于 2015-4-30 23:47
不错的尝试，楼主好评。以前我也只知道有对齐这么一回事儿，现在弄清楚了。 ...

  我以前也是只知道对齐, 没细想很多```

1.         typedef struct SIZEOF {
   
2.                 UCHAR E;
   
3.                 USHORT a;
   
4.                 USHORT b;
   
5.         } SIZEOF;
   
6.         DbgPrint("SIZEOF=0x%x\n", sizeof(SIZEOF));
   
7. SIZEOF=0x6

复制代码