Computer System

Hexadecimal Notation

Data Sizes

# 下面编译生成的程序能在32位和64位机器上运行
gcc -m32 prog.c
# 下面编译生成的程序只能在64位机器上运行
gcc -m64 prog.c

• 机器位数的进化
  

  机器从 16 位进化为 32 位又到 64 位。
  

  32 位计算机，是指 CPU 内部的通用寄存器宽度是 32bit；64 位计算机，是指 CPU 内部的通用寄存器宽度是 64bit；同样的，如果有 128 位计算机，则需要 CPU 内部的通用寄存器宽度是 128bit。
  

  那么通用寄存器到底需要多少宽度呢？这个问题首先要回答的是通用寄存器是干什么用的。CPU 内部的寄存器非常多，大体上可以分为几类：
  地址寄存器：用来存储内存地址；
  数据寄存器：用来存储数据；
  通用寄存器：根据需要可以存储内存地址或者数据；
  状态寄存器：存储某些状态，用于判断某些指令是否可以执行除此以外，
  

  还有常量寄存器、特殊目的寄存器等；其中数据寄存器又可以根据存储的数据类型，细分为整数寄存器、浮点寄存器和向量寄存器。
  

  事实上，通用寄存器的宽度和地址寄存器的宽度是一致的，并不会和需要的最大长度的数据寄存器一致。单就 x86 来说(80386 及之前的型号没有 FPU 先不提)：
  

  • 80486~奔腾 2：集成了 FPU，可以处理 80bit 长度的扩展浮点数，通用寄存器是 32 位宽；
    
  • 奔腾 3 及早期的奔腾 4 型号：支持 128bit 的向量数据（SSE），通用寄存器还是 32 位；
    
  • 奔腾 4 后期~第一代 Core：支持 128bit 的向量数据（SSE），通用寄存器升级到 64 位；
    
  • 第二代 Core~第 10 代：支持 256bit 的向量数据（AVX），通用寄存器是 64 位
    
  • 服务器的至强可扩展系列、7代及之后 HEDT 的 Core X、10 代及以后的低压移动 CPU（10 代仅限型号类似于 iX-10yyGz 的基于 Ice Lake 架构的型号）：支持 512bit 的向量数据（AVX512），通用寄存是 64 位。
    

  所以，需要处理多长的数据，并不一定需要多宽的通用寄存器。也就是说，128bit 字长的数据，并不需要 128 位 CPU 去处理。是否需要 128 位 CPU，取决于需要访问多大的内存地址空间。
  

  现在的 64 位 CPU，已经可以访问 2^64 字节的内存地址，换成我们相对熟悉一点的单位，就是:
  

  2^64	B
  16*2^60	B
  16*2^50	KB
  16*2^40	MB
  16*2^30	GB
  16*2^20	TB
  16*2^10	PB
  16	EB

  上面提到，数据宽度早在上世纪 90 年代末的奔腾 3 上已经扩展到 128bit，现在已经达到 512bit 了；因此要想把内存地址总线直接扩展到 128bit，起码在 20 年后的今天，技术上并没有任何难度，成本也并非无法接受。唯一的问题是：有没有这个必要？ 显然目前我们不需要这么大的内存地址空间。
  

  • 为什么没有普及 128 位操纵系统的计算机? https://www.zhihu.com/question/320332089/answer/1466111036
    

Addressing and Byte Ordering

Representing Strings

Representing Code

Introduction to Boolean Algebra

Bit-Level Operations in C

Logical Operations in C

Shift Operations in C

整数的表示

• 为什么要用补码表示有符号整数？
  

  使用补码表示有符号整数有以下几个主要原因，这种表示方式在计算机科学中被广泛采纳，因为它简洁高效，解决了有符号整数表示和算术运算中的多个问题：
  

  1. 统一加减法操作：
     补码使得加法和减法运算可以用相同的电路实现，因为正数的补码就是其本身，负数的补码则是其对应正数按位取反后加 1。这样，无论是正数加正数、负数加负数、正数加负数还是负数加正数，都可以通过加法运算完成，简化了硬件设计和软件实现。
     
  2. 简化逻辑设计：
     由于补码运算自然地包含了溢出处理（即当结果超出数据类型范围时的循环特性），处理器无需额外的硬件来检测并处理加减法中的溢出情况。这对于早期计算资源有限的计算机尤为重要。
     
  3. 包含零值：
     补码表示能够完美地包含零值。在原码或反码表示法中，存在两个零：一个正零和一个负零。而补码表示法只有一种零，即所有位都是 0 的情况，这减少了不必要的复杂性。
     
  4. 便于移位操作：
     在补码系统中，算术移位（包括逻辑右移和算术右移）可以自然地处理符号位，确保负数在移位时不改变其符号，同时也保持了数值的正确性。
     

有符号数和无符号数之间的转换

// 有符号数和无符号数之间的转换
//// 强制类型转换的结果保持位值不变，只是改变了解释这些位的方式。
short int v=-12345;
unsigned short uv = (unsigned short) v;
printf("v = %d, uv = %u\n", v, uv);

// v = -12345, uv = 53191;

// 扩展一个数字
short sx = -12345;           // -12345
unsigned short usx = sx;     // 53191
int x = sx;                  // -12345
unsigned ux = usx;           // 53191

// 截断数字
int x = 53191;
short sx = (short) x; // -12345
int y = sx;           // -12345

整数的运算

浮点数表示

舍入

• 为什么要采用偶数舍入，而不是始终将位于两个可表示的值中间的值都向上舍入呢？
  

  将位于两个可表示的值中间的值都向上舍入，这种方法舍入一组数值，会在计算这些值的平均数中引入统计偏差，其结果比本身略高。相反，将位于两个可表示的值中间的值都向下舍入，其结果比本身略低。使用偶数舍入可以在大多数情况中避免这种统计偏差，在 50%时间里其向上舍入，而在 50%的时间里其向下舍入。
  

浮点数运算

• 浮点数算术运算
  

  
  

  下图展示了，浮点数加法运算时，舍入所导致的误差范围：
  
  

  下图展示了，从浮点运算导出的一些结论：
  
  

• Error Propagation
  

  下图展示了 Forward Error Analysis 和 Backword Error Analysis:
  
  下图展示了对浮点计算误差的分析和定界：
  
  

  • http://www.mathcs.emory.edu/~nagy/courses/fall12/515/Conditioning_and_FLOPS.pdf
    
  • https://baike.baidu.com/item/%E5%8C%BA%E9%97%B4/1273117#viewPageContent
    
• Running Error Analysis
  

  除了通过代数的方法来得出误差范围，也可以让计算机为我们做这项工作，这种方式被称为 running error analysis.其背后的理念是，每次执行浮点运算时，同时计算累积到当前计算的误差范围。
  

  具体的实现参考 ../graphics/PhysicallyBasedRendering.html#org1f4006f
  

• Misc
  

  v>0 v/0 = Infinity
  v<0 v/0 = -Infinity
  v>0 v*Infinity = Infinity
  v<0 v*Infinity = -Infinity
  

  0*infinity = NaN
  Infinity - Infinity = NaN
  Infinity + Infinity = Infinity
  NaN + v = NaN
  NaN 和任意数字的比较都为 false
  

  • 浮点数加法是可交换的。
    
  • 浮点数加法不具有结合性（因为舍入或溢出）。
    (3.14+1e10)-1e10 = 0
    3.14+(1e10-1e10) = 3.14
    1e10 是 C/C++规定的浮点数的科学计数写法,意思是 1.0x10 的 10 次方
    
  • 浮点数加法满足单调性属性：如果 a>=b,那么对于任何 a、b 以及 x 的值，除了 NaN，都有 x+a>=x+b。
    
  • 浮点数乘法是可交换的。
    
  • 浮点数乘法不具有结合性（因为舍入或溢出）。
    (1e20*1e20)*1e-20 为无穷大
    1e20*(1e20*1e-20) 为 1e20
    
  • 浮点乘法在加法上不具备分配性。
    1e20*(1e20-1e20) = 0
    1e20*1e-20-1e20*1e-20 = NaN
    
  • 浮点乘法满足下列单调性：对于任何 a、b、c,并且 a、b、c 都不为 NaN,浮点乘法满足
    a>=b 且 c>=0 则 a*c>=b*c
    a>=b 且 c<=0 则 a*c<=b*c
    无符号或补码的乘法没有这些单调性属性，因为溢出时会取模。
    
• Tips
  

  本节内容部分来自 Physically Based Rendering_v3_en 3.9 节 Managing Rounding Error.
  

机器级代码

# -Og 指示编译器生成符合原始C代码整体结构的机器代码， 使用较高级别优化产生的代码会严重变形，以至于机器代码和源代码之间的关系非常难以理解
gcc -Og main.c -o prog

Code Example

• Example 1
  

  int append_val = 10;
  
  int main()
  {
      int val = 1;
      val = val + append_val;
      val = val + 2;
      char* my_s_1 = "0123456789abcdefg-hello world ";
      char* my_s_2 = "0123456789abcdefg-ABCDEFG";
      int c = my_s_1[val] + my_s_2[val];
      return c;
  }
  

  # 执行下面命令对程序进行编译生成 test_local.s汇编代码
  gcc -S test_local.c -o test_local.s
  

  ##                                                           ;## 段定义和版本信息
  .section    __TEXT,__text,regular,pure_instructions          ;##     定义了代码段，其中`.text`段通常包含程序的可执行代码。
      .macosx_version_min 10, 12                               ;##     指定目标操作系统为 macOS 10.12 或更高版本。
                                                               ;## 函数声明
      .globl  _main                                            ;##     声明`_main`函数为全局，使得其他地方可以调用它。
      .p2align    4, 0x90                                      ;##     确保接下来的指令对齐到 16 字节边界，提高执行效率。
                                                               ;## 函数`_main`
  _main:                                  ## @main             ;##     main函数开始标签。
      .cfi_startproc                                           ;##     +++ .cfi_xxx 都是用于调试的信息
  ## BB#0:
      pushq   %rbp                                             ;##     保存调用者的基址指针（RBP）到栈上。
  Lcfi0:                                                       ;##     +++
      .cfi_def_cfa_offset 16                                   ;##     +++
  Lcfi1:                                                       ;##     +++
      .cfi_offset %rbp, -16                                    ;##     +++
      movq    %rsp, %rbp                                       ;##     将栈顶指针（RSP）的值复制到 RBP，建立新的栈帧。
  Lcfi2:
      .cfi_def_cfa_register %rbp                               ;##     +++
                                                               ;## 数据加载与局部变量初始化
      leaq    L_.str.1(%rip), %rax                             ;##     加载字符串"L_.str.1"的地址到 RAX 寄存器。
      leaq    L_.str(%rip), %rcx                               ;##     加载字符串"L_.str"的地址到 RCX 寄存器。
      movl    $0, -4(%rbp)                                     ;##     在栈上分配 4 字节的空间，并存储 0，作为局部变量初始化。
      movl    $1, -8(%rbp)                                     ;##     在栈上分配 4 字节空间，存储 1，这是另一个局部变量。
                                                               ;## 计算逻辑
      movl    -8(%rbp), %ecx                                   ;##     将局部变量（值为 1）加载到 ECX 寄存器。
      addl    _append_val(%rip), %ecx                          ;##     将 ECX 寄存器中的值与全局变量`_append_val`相加。这里使用了 RIP 相对寻址。
      movl    %ecx, -8(%rbp)                                   ;##     将结果（11）存回局部变量。
      movl    -8(%rbp), %ecx                                   ;##     将局部变量（值为 11）加载到 ECX 寄存器。
      addl    $2, %ecx                                         ;##     将 ECX 寄存器中的值与 2 相加
      movl    %ecx, -8(%rbp)                                   ;##     将结果（13）存回局部变量。
                                                               ;## 字符访问
      movq    %rcx, -16(%rbp)                                  ;##     将字符串0地址保存到栈上。
      movq    %rax, -24(%rbp)                                  ;##     将字符串1地址保存到栈上。
      movq    -16(%rbp), %rax                                  ;##     重新加载字符串 0地址到 RAX。
      movslq  -8(%rbp), %rcx                                   ;##     扩展局部变量的值（13）到 RCX 寄存器（64 位）。
      movsbl  (%rax,%rcx), %edx                                ;##     根据计算的索引从字符串中获取字符并转换为有符号字节存储到 EDX 寄存器。
      movq    -24(%rbp), %rax                                  ;##     重新加载字符串 1 地址到 RAX。
      movslq  -8(%rbp), %rcx                                   ;##     扩展局部变量的值（13）到 RCX 寄存器（64 位）。
      movsbl  (%rax,%rcx), %esi                                ;##     根据计算的索引从字符串中获取字符并转换为有符号字节存储到 ESI 寄存器。
      addl    %esi, %edx                                       ;##     将从两个字符串中获取的字符的 ASCII 值相加。
      movl    %edx, -28(%rbp)                                  ;##     结果存入栈上位置-28(%rbp)
                                                               ;## 函数结束
      movsbl  -28(%rbp), %eax                                  ;##     将最终结果加载到 EAX 寄存器，EAX 通常用于存放函数返回值。
      popq    %rbp                                             ;##     恢复调用者的基址指针。
      retq                                                     ;##     从函数返回，使用 EAX 中的值作为返回值。
      .cfi_endproc                                             ;##
                                                               ;## 全局变量`_append_val`
      .section    __DATA,__data                                ;##     定义数据段，通常存储全局变量和静态变量。
      .globl  _append_val             ## @append_val           ;##     声明全局变量`_append_val`。
      .p2align    2                                            ;##     对齐到 4 字节边界。
  _append_val:                                                 ;##     变量标签
      .long   10                      ## 0xa                   ;##     分配 4 字节空间，存储十进制数 10（十六进制为 0xa）。
                                                               ;## 字符串常量
      .section    __TEXT,__cstring,cstring_literals            ;##     定义常量字符串段。
  L_.str:                                 ## @.str             ;##     字符串常量0
      .asciz  "0123456789abcdefg-hello world "
  L_.str.1:                               ## @.str.1           ;##     字符串常量1
      .asciz  "0123456789abcdefg-ABCDEFG"
  
  .subsections_via_symbols                                     ;## 指示链接器通过符号来决定如何划分子节区段，这是一个链接器指令。
  

• Example 2
  

  // mstore.c
  long mult2(long, long);
  void multstore(long a, long b, long *c)
  {
    long t = mult2(a,b);
    *c = t;
  }
  
  // main.c
  void multstore(long, long, long *);
  int main()
  {
    long d;
    multstore(2,3,&d);
    return 0;
  }
  
  long mult2(long a, long b)
  {
    long c = a*b;
    return c;
  }
  

  # 执行下面命令对程序进行编译生成 prog.exe程序
  gcc -Og -o prog.exe main.c mstore.c
  # 执行下面命令，将二进制机器码prog.exe转化为字符表示的机器码
  objdump -d prog.exe > asm-code.txt
  

    //0000000000401550 <main>:
      401550: 48 83 ec 38             sub    $0x38,%rsp
      401554: e8 f7 00 00 00          callq  401650 <__main>
      401559: 4c 8d 44 24 2c          lea    0x2c(%rsp),%r8
      40155e: ba 03 00 00 00          mov    $0x3,%edx
      401563: b9 02 00 00 00          mov    $0x2,%ecx
      401568: e8 13 00 00 00          callq  401580 <multstore>
      40156d: b8 00 00 00 00          mov    $0x0,%eax
      401572: 48 83 c4 38             add    $0x38,%rsp
      401576: c3                      retq
  
    //0000000000401577 <mult2>:
      401577: 89 c8                   mov    %ecx,%eax
      401579: 0f af c2                imul   %edx,%eax
      40157c: c3                      retq
      40157d: 90                      nop
      40157e: 90                      nop
      40157f: 90                      nop
  
    //0000000000401580 <multstore>:
      401580: 53                      push   %rbx               // save %rbx
      401581: 48 83 ec 20             sub    $0x20,%rsp         //
      401585: 4c 89 c3                mov    %r8,%rbx           // copy dest to %rbx
      401588: e8 ea ff ff ff          callq  401577 <mult2>     // call mult2
      40158d: 89 03                   mov    %eax,(%rbx)        // store result at *dest
      40158f: 48 83 c4 20             add    $0x20,%rsp         //
      401593: 5b                      pop    %rbx               // restore %rbx
      401594: c3                      retq                      // return
      401595: 90                      nop
      401596: 90                      nop
      401597: 90                      nop
      401598: 90                      nop
      401599: 90                      nop
      40159a: 90                      nop
      40159b: 90                      nop
      40159c: 90                      nop
      40159d: 90                      nop
      40159e: 90                      nop
      40159f: 90                      nop
  

操作数指示符

数据传送指令

压入和弹出栈数据

leaq

;## 假如寄存器%rdx 的值为 x，%rax 的值为 7+5x
leaq 7(%rdx, %rdx, 4), %rax    ;; 7 + x + 4x = 7 + 5x

特殊的算术操作

运行时栈

转移控制

数据传送

int func(int v0, int v1, int v2, int v3, int v4, int v5, int v6, int v7)
{
    int v = 10;
    v = v + v0  + v1  + v2  + v3  + v4  + v5  + v6  + v7;
    return v;
}

int main()
{
    int v = -10;
    int v0 = 0;
    int v1 = 1;
    int v2 = 2;
    int v3 = 3;
    int v4 = 4;
    int v5 = 5;
    int v6 = 6;
    int v7 = 7;
    v += func(v0  , v1  , v2  , v3  , v4  , v5  , v6  , v7);
    return v;
}

_func:
100000f60:  55  pushq   %rbp
100000f61:  48 89 e5    movq    %rsp, %rbp
100000f64:  8b 45 18    movl    24(%rbp), %eax
100000f67:  01 f7   addl    %esi, %edi
100000f69:  01 d7   addl    %edx, %edi
100000f6b:  01 cf   addl    %ecx, %edi
100000f6d:  44 01 c7    addl    %r8d, %edi
100000f70:  44 01 cf    addl    %r9d, %edi
100000f73:  03 7d 10    addl    16(%rbp), %edi
100000f76:  8d 44 38 0a     leal    10(%rax,%rdi), %eax
100000f7a:  5d  popq    %rbp
100000f7b:  c3  retq
100000f7c:  0f 1f 40 00     nopl    (%rax)

_main:
100000f80:  55  pushq   %rbp
100000f81:  48 89 e5    movq    %rsp, %rbp
100000f84:  bf 00 00 00 00  movl    $0, %edi                         ## 参数 v0 利用寄存器传递
100000f89:  be 01 00 00 00  movl    $1, %esi                         ## 参数 v1 利用寄存器传递
100000f8e:  ba 02 00 00 00  movl    $2, %edx                         ## 参数 v2 利用寄存器传递
100000f93:  b9 03 00 00 00  movl    $3, %ecx                         ## 参数 v3 利用寄存器传递
100000f98:  41 b8 04 00 00 00   movl    $4, %r8d                     ## 参数 v4 利用寄存器传递
100000f9e:  41 b9 05 00 00 00   movl    $5, %r9d                     ## 参数 v5 利用寄存器传递
100000fa4:  6a 07   pushq   $7                                       ## 参数 v7 放入栈中
100000fa6:  6a 06   pushq   $6                                       ## 参数 v6 放入栈中, 在栈顶
100000fa8:  e8 b3 ff ff ff  callq   -77 <_func>
100000fad:  48 83 c4 10     addq    $16, %rsp
100000fb1:  83 c0 f6    addl    $-10, %eax
100000fb4:  5d  popq    %rbp
100000fb5:  c3  retq

栈上的局部存储

寄存器中的局部存储空间

递归过程

指针运算

嵌套数组

定长数组

变长数组

结构体

Union

数据对齐

struct S1
{
    char c;    // 偏移 0，按1字节对齐，c后填充7个空字节
    double d;  // 偏移8，按8字节对齐
    int i;     // 偏移16，按4字节对齐
    char c1;   // 偏移20，按1字节对齐
}

struct S2
{
    char c;    // 偏移 0，按1字节对齐，c后填充7个空字节
    double d;  // 偏移8，按8字节对齐
    char c1;   // 偏移16，按1对齐，c后填充7个空字节，结构体整体按照24字节对齐
}

struct S3
{
    char c;
    double d;
    char c1;
}
printf("S3 alignment = %d\n", alignof(A));

• 为什么对齐数据可以提高内存系统的性能？
  

  对齐数据可以提高内存系统性能的原因主要与计算机硬件的存储和访问机制有关。
  

  1. 内存访问粒度：现代计算机的主存（RAM）是以字节为单位编址的，但是处理器并不是以字节为最小单位来访问内存的。常见的访问粒度是字（word）大小，例如 32 位系统中的 4 字节或 64 位系统中的 8 字节。这意味着，当处理器尝试读取或写入一个数据类型时，它倾向于一次性读取该类型的完整字节数量，并且这个操作最高效发生在地址边界对齐的情况下。
     
  2. 性能优化：
     
     • 减少内存访问次数：如果数据未对齐，处理器可能需要进行两次或更多次访问才能获取完整数据，这称为“非对齐访问”。这不仅增加了访问延迟，还可能导致额外的总线传输和处理开销。
       
     • 硬件设计简化：对齐的数据访问可以简化内存控制器和总线的设计，因为它们可以假设每次读写都符合一定的边界规则，从而提高效率。
       
     • 缓存行对齐：缓存系统通常以缓存行（cache line）为单位工作，通常是 64 字节或更多。当数据对齐到缓存行边界时，可以更有效地利用缓存，减少缓存未命中率。
       
  3. 避免性能惩罚：一些处理器在遇到非对齐访问时，要么根本不支持（导致访问错误），要么需要额外的周期来处理这种访问，这会导致性能下降。即使支持非对齐访问的处理器，也会比对齐访问慢，因为它们可能需要进行两次物理内存访问并组合数据。
     

  因此，通过对齐数据，可以确保数据访问操作更加高效，减少内存访问延迟，提升整体的系统性能。这也是许多编程语言和编译器默认对结构体成员和基本数据类型进行对齐的原因之一。
  

• 参考资料
  
  • 结构体成员内存对齐问题 https://imzlp.com/posts/61962/
    
  • 什么是字节对齐，为什么要对齐? https://www.zhihu.com/question/23791224
    

理解指针

内存越界引用和缓冲器溢出

#include <stdio.h>

char* my_gets(char* s)
{
    int c;
    char* dest = s;
    while((c = getchar()) != '\n' && c!= EOF)
        *dest++ = c;                  // buf 大小只有8个字符，越界会导致缓冲器溢出
    if(c == EOF && dest==s)
        return NULL;
    *dest++ = '\0';                   // buf 大小只有8个字符，越界会导致缓冲器溢出
    return s;
}

void test_overflow()
{
    char buf[8];
    my_gets(buf);
    printf("buf = %s \n", buf);
}

int main()
{
    test_overflow();
    return 0;
}

对抗缓冲区溢出攻击

• 栈随机化
  

  栈随机化的思想使得栈的位置在程序每次运行时都有变化。因此，即使许多机器都运行同样的代码，它们的栈地址都是不同的。实现的方式是：程序开始时，在栈上分配一段 0-n 字节之间的随机大小的空间。程序不使用这段空间，但是它会导致程序每次执行时后续的栈位置发生了变化。
  

  #include <stdio.h>
  
  int main()
  {
      long local;
      printf("local at %p\n", &local);
      return 0;
  }
  
  // 多次执行，得到不同的地址
  // local at 0x7fff5a0559b0
  // local at 0x7fff5b3cf9b0
  // local at 0x7fff52ea59b0
  

  栈随机化是更大的一类技术中的一种，这类技术称为地址空间布局随机化（Address-Space Layout Randomization）,或者简称 ASLR。采用 ASLR，每次运行时程序的不同部分，包括程序代码、库代码、栈、全局变量和堆数据，都会被加载到内存的不同区域。
  

  但是，还是能够用蛮力克服随机化，可以反复地用不同的地址进行攻击。一种常见的把戏就是在实际的攻击代码前插入很长一段的 nop 指令 (no operation) 。执行这种指令除了对程序计数器加 1，使之指向下一条指令之外，没有任何的效果。只要攻击者能够猜中这段序列中的某个地址，程序就会经过这个序列，到达攻击代码。这个序列常用的术语是“空操作雪橇(nop sled)”, 意思是程序会“滑过”这个序列。
  

• 栈破坏检测
  

  最近的 GCC 版本在产生的代码中加入了一种 stack protector 机制。其在栈帧中任何局部缓冲区与栈状态之间存储一个特殊的 canary value(金丝雀值)，也称为 guard value(哨兵值), 该值是程序每次运行时随机产生的，攻击者没有简单的办法能够知道它是什么。在恢复寄存器状态和从函数返回之前，程序检查这个金丝雀值是否被该函数的某个操作或者函数调用的某个函数的某个操作改变了。如果是，则程序异常中止。
  

  使用下面代码可以使 gcc 强制不使用栈保护者:
  

  gcc -fno-stack-protector -Og test_overflow.c -o test_overflow
  

  栈保护很好地防止了缓冲区溢出攻击破坏存储在程序栈上的状态。它只会带来很小的性能损失，特别是因为 GCC 只在函数中有局部 char 类型缓冲区的时候才插入这样的代码。
  

• 限制可执行代码区域
  

  一种方法是限制哪些内存区域能够存放可执行代码。在典型的程序中，只有保存编译器产生的代码的那部分内存才需要是可执行的。其他部分可以被限制为只允许读和写的。
  

  以前，x86 体系结构将读和执行访问控制合并成一个 l 位的标志，这样任何被标记为可读的页也都是可执行的。最近，AMD 为它的 64 位处理器的内存保护引入了“NX”位(No-Execute 位)，将读和执行访问模式分开，Intel 也跟进了。有了这个特性，栈可以被标记为可读和可写，但是不可执行，而检查页是否可执行由硬件来完成，效率上没有损失。
  

  有些类型的程序要求动态产生和执行代码的能力。例如，JIT 编译技术位解释语言（如 Java）编写的程序动态地产生代码，以提高执行性能。是否能够将可执行代码限制在由编译器在创建原始程序时产生的那个部分中，取决于语言和操作系统。
  

支持变长栈帧

#include <stdio.h>

long vframe(long n, long idx, long *q)
{
    long i;
    long *p[n];
    p[0] = &i;
    for (i = 1; i < n; i++)
        p[i] = q;
    return *p[idx];
}

int main()
{
    long local = 3;
    long ret = vframe(9, 2, &local);
    printf("ret0 = %lx", ret);
    ret = vframe(10, 2, &local);
    printf("ret1 = %lx", ret);
    return 0;
}

.section    __TEXT,__text,regular,pure_instructions
    .macosx_version_min 10, 12
    .globl  _vframe
    .p2align    4, 0x90
_vframe:                                ## @vframe
    pushq   %rbp
Lcfi0:
Lcfi1:
    movq    %rsp, %rbp
Lcfi2:
    subq    $48, %rsp
    leaq    -32(%rbp), %rax
                                     ; vframe param n
    movq    %rdi, -8(%rbp)             ; n -> -8(%rbp)
    movq    %rsi, -16(%rbp)
    movq    %rdx, -24(%rbp)
    movq    -8(%rbp), %rdx             ; n -> %rdx
    movq    %rsp, %rsi
    movq    %rsi, -40(%rbp)
    leaq    15(,%rdx,8), %rdx          ; 15+n*8 -> %rdx
    andq    $-16, %rdx                 ; -16+15+n*8 = -1+n*8 -> %rdx
    movq    %rsp, %rsi                 ; %rsp -> %rsi
    subq    %rdx, %rsi                 ; (-1+n*8)-%rsp        计算分配long* p[n] 后栈指针 %rsp应该为多少
    movq    %rsi, %rsp                 ; -1+n*8-%rsp -> %rsp  为 %rsp赋值，完成 long* p[n] 内存空间的分配
    movq    %rax, (%rsi)
    movq    $1, -32(%rbp)
    movq    %rsi, -48(%rbp)         ## 8-byte Spill
LBB0_1:                                 ## =>This Inner Loop Header: Depth=1
    movq    -32(%rbp), %rax
    cmpq    -8(%rbp), %rax
    jge LBB0_4
## BB#2:                                ##   in Loop: Header=BB0_1 Depth=1
    movq    -24(%rbp), %rax
    movq    -32(%rbp), %rcx
    movq    -48(%rbp), %rdx         ## 8-byte Reload
    movq    %rax, (%rdx,%rcx,8)
## BB#3:                                ##   in Loop: Header=BB0_1 Depth=1
    movq    -32(%rbp), %rax
    addq    $1, %rax
    movq    %rax, -32(%rbp)
    jmp LBB0_1
LBB0_4:
    movq    -16(%rbp), %rax
    movq    -48(%rbp), %rcx         ## 8-byte Reload
    movq    (%rcx,%rax,8), %rax
    movq    (%rax), %rax
    movq    -40(%rbp), %rdx
    movq    %rdx, %rsp
    movq    %rbp, %rsp
    popq    %rbp
    retq

    .globl  _main
    .p2align    4, 0x90
_main:                                  ## @main
    pushq   %rbp
Lcfi3:
Lcfi4:
    movq    %rsp, %rbp
Lcfi5:
    subq    $32, %rsp
                                                     ;; vframe0(9, 2, &local)
                                                     ;; vframe1(10, 2, &local)
    movl    $9, %eax
    movl    %eax, %edi                                 ;; vframe0-param-9 ($9->%eax)->%edi
    movl    $2, %eax
    movl    %eax, %esi                                 ;; vframe0-param-2  ($2->%eax)->%esi
    leaq    -16(%rbp), %rdx                            ;; &local -> %rdx
    movl    $0, -4(%rbp)
    movq    $3, -16(%rbp)                              ;; local -> -16(%rbp)
    callq   _vframe                                    ;; call vframe0
    leaq    L_.str(%rip), %rdi
    movq    %rax, -24(%rbp)
    movq    -24(%rbp), %rsi
    movb    $0, %al
    callq   _printf
    movl    $10, %ecx
    movl    %ecx, %edi                                 ;; vframe1-param-10 ($10->%ecx)->%edi
    movl    $2, %ecx
    movl    %ecx, %esi                                 ;; vframe1-param-2 ($2->%ecx)->%esi
    leaq    -16(%rbp), %rdx                            ;; &local -> %rdx
    movl    %eax, -28(%rbp)         ## 4-byte Spill
    callq   _vframe                                    ;; call vframe1
    leaq    L_.str.1(%rip), %rdi
    movq    %rax, -24(%rbp)
    movq    -24(%rbp), %rsi
    movb    $0, %al
    callq   _printf
    xorl    %ecx, %ecx
    movl    %eax, -32(%rbp)         ## 4-byte Spill
    movl    %ecx, %eax
    addq    $32, %rsp
    popq    %rbp
    retq

    .section    __TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
    .asciz  "ret0 = %lx"

L_.str.1:                               ## @.str.1
    .asciz  "ret1 = %lx"

#include <stdio.h>
#include <stdlib.h>

int get_v(int n, int idx)
{
    // alloca 是在栈上分配空间，不需要手动释放
    int* p = (int*)alloca(sizeof(int)*n);
    for(int i=0; i<n; i++)
    {
        p[i] = i;
    }
    int ret = p[idx];
    // free(p); //不能用free()去释放，会导致错误
    return ret;
}

int main()
{
    printf("ret = %d", get_v(9, 8));
    return 0;
}

.section    __TEXT,__text,regular,pure_instructions
    .macosx_version_min 10, 12
    .globl  _get_v
    .p2align    4, 0x90
_get_v:                                 ## @get_v
  movl  $9, %edi                 ; get_v-param-n
    movl    $8, %esi                 ; get_v-param-idx

    pushq   %rbp
Lcfi0:
Lcfi1:
    movq    %rsp, %rbp
Lcfi2:
    subq    $32, %rsp
                                      ; get_v(n, idx)
    movl    %edi, -4(%rbp)              ; n   -> -4(%rbp)
    movl    %esi, -8(%rbp)              ; idx -> -8(%rbp)
    movslq  -4(%rbp), %rax              ; n   -> %rax
    leaq    15(,%rax,4), %rax           ; 15+n*4 -> %rax
    andq    $-16, %rax                  ; -16+15+n*4=-1+n*4 -> %rax
    movq    %rsp, %rcx                  ; rsp -> rcx
    subq    %rax, %rcx                  ; -1+n*4-%rsp 计算分配 alloca(sizeof(int)*n) 后栈指针 %rsp应该为多少
    movq    %rcx, %rsp                  ; -1+n*4-%rsp -> rsp 为 %rsp赋值，完成 alloca(sizeof(int)*n) 内存空间的分配
    movq    %rcx, -16(%rbp)
    movl    $0, -20(%rbp)
LBB0_1:                                 ## =>This Inner Loop Header: Depth=1
    movl    -20(%rbp), %eax
    cmpl    -4(%rbp), %eax
    jge LBB0_4
## BB#2:                                ##   in Loop: Header=BB0_1 Depth=1
    movl    -20(%rbp), %eax
    movq    -16(%rbp), %rcx
    movslq  -20(%rbp), %rdx
    movl    %eax, (%rcx,%rdx,4)
## BB#3:                                ##   in Loop: Header=BB0_1 Depth=1
    movl    -20(%rbp), %eax
    addl    $1, %eax
    movl    %eax, -20(%rbp)
    jmp LBB0_1
LBB0_4:
    movq    -16(%rbp), %rax
    movslq  -8(%rbp), %rcx
    movl    (%rax,%rcx,4), %edx
    movl    %edx, -24(%rbp)
    movl    -24(%rbp), %eax
    movq    %rbp, %rsp
    popq    %rbp
    retq
    .cfi_endproc

    .globl  _main
    .p2align    4, 0x90
_main:                                  ## @main
    pushq   %rbp
Lcfi3:
Lcfi4:
    movq    %rsp, %rbp
Lcfi5:
    subq    $16, %rsp
    movl    $9, %edi                 ; get_v-param-n
    movl    $8, %esi                 ; get_v-param-idx
    movl    $0, -4(%rbp)
    callq   _get_v                   ; get_v(9, 8)
    leaq    L_.str(%rip), %rdi
    movl    %eax, %esi
    movb    $0, %al
    callq   _printf
    xorl    %esi, %esi
    movl    %eax, -8(%rbp)          ## 4-byte Spill
    movl    %esi, %eax
    addq    $16, %rsp
    popq    %rbp
    retq

    .section    __TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
    .asciz  "ret = %d"

浮点传送和转换操作

; 把单精度转换位双精度
; 假设 %xmm0 的低位4字节保存着一个单精度值
vcvtss2sd %xmm0, %xmm0, %xmm0

; 但是，gcc生成的代码为:(不使用上面单条指令没有明显直接的意义)
;    replicate first vector element 假设 %xmm0 为[s3,s2,s1,s0]
vunpcklps %xmm0, %xmm0, %xmm0   ; %xmm0 变为 [s1, s1, s0, s0]
;    convert two vector elements to double
vcvtps2pd %xmm0, %xmm0          ; %xmm0 变为 [dx0, dx0]

; 把双精度转换位单精度
; 假设 %xmm0 的低位8字节保存着一个双精度值
vcvtsd2ss %xmm0, %xmm0, %xmm0

; 但是，gcc生成的代码为:(不使用上面单条指令没有明显直接的意义)
;    replicate first vector element 假设 %xmm0 为[x1, x0]
vmovddup %xmm0, %xmm0           ; %xmm0 变为 [x0, x0]
;    convert two vector elements to single
vcvtpd2psx %xmm0, %xmm0         ; %xmm0 变为 [0.0, 0.0, x0, x0]

过程中的浮点代码

浮点运算操作

定义和使用浮点常数

在浮点代码中使用位级操作

浮点比较操作

对浮点代码的观察结论

变量

• 整型
  

  short my_s_val0;
  int my_i_val0;
  long my_l_val0;
  long long my_ll_val0;
  
  short my_s_val1 = 11;
  int my_i_val1 = 12;
  long my_l_val1 = 13;
  long long my_ll_val1 = 14;
  
  int main()
  {
      short my_local_s_val0;
      int my_local_i_val0;
      long my_local_l_val0;
      long long my_local_ll_val0;
  
      short my_local_s_val1 = 21;
      int my_local_i_val1 = 22;
      long my_local_l_val1 = 23;
      long long my_local_ll_val1 = 24;
  
      long long v = my_s_val0 + my_s_val1 + my_local_s_val0 + my_local_s_val1 +
          my_i_val0 + my_i_val1 + my_local_i_val0 + my_local_i_val1 +
          my_l_val0 + my_l_val1 + my_local_l_val0 + my_local_l_val1 +
          my_ll_val0 + my_ll_val1 + my_local_ll_val0 + my_local_ll_val1 + 30;
      return v;
  }
  

  .section    __TEXT,__text,regular,pure_instructions
      .macosx_version_min 10, 12
      .globl  _main
      .p2align    4, 0x90
  _main:                                  ## @main
      .cfi_startproc
  ## BB#0:
      pushq   %rbp
  Lcfi0:
      .cfi_def_cfa_offset 16
  Lcfi1:
      .cfi_offset %rbp, -16
      movq    %rsp, %rbp
  Lcfi2:
      .cfi_def_cfa_register %rbp
      movq    _my_ll_val0@GOTPCREL(%rip), %rax
      movq    _my_l_val0@GOTPCREL(%rip), %rcx
      movq    _my_i_val0@GOTPCREL(%rip), %rdx
      movq    _my_s_val0@GOTPCREL(%rip), %rsi
      movl    $0, -4(%rbp)
      movw    $21, -34(%rbp)
      movl    $22, -40(%rbp)
      movq    $23, -48(%rbp)
      movq    $24, -56(%rbp)
      movswl  (%rsi), %edi
      movswl  _my_s_val1(%rip), %r8d
      addl    %r8d, %edi
                                         ; -6(%rbp) 对应的是 short my_local_s_val0;  TIPS: 局部变量没有被初始化，其值为栈之前残留的值
      movswl  -6(%rbp), %r8d             ; 将 short 扩展为 int
      addl    %r8d, %edi
      movswl  -34(%rbp), %r8d
      addl    %r8d, %edi
      addl    (%rdx), %edi
      addl    _my_i_val1(%rip), %edi
      addl    -12(%rbp), %edi
      addl    -40(%rbp), %edi
      movslq  %edi, %rdx
      addq    (%rcx), %rdx
      addq    _my_l_val1(%rip), %rdx
      addq    -24(%rbp), %rdx
      addq    -48(%rbp), %rdx
      addq    (%rax), %rdx
      addq    _my_ll_val1(%rip), %rdx
      addq    -32(%rbp), %rdx
      addq    -56(%rbp), %rdx
      addq    $30, %rdx                   ; 临时变量 30 对应于指令中的立即数
      movq    %rdx, -64(%rbp)
      movq    -64(%rbp), %rax
      movl    %eax, %edi
      movl    %edi, %eax
      popq    %rbp
      retq
      .cfi_endproc
  
      .section    __DATA,__data
      .globl  _my_s_val1              ## @my_s_val1
      .p2align    1
  _my_s_val1:
      .short  11                      ## 0xb
  
      .globl  _my_i_val1              ## @my_i_val1
      .p2align    2
  _my_i_val1:
      .long   12                      ## 0xc
  
      .globl  _my_l_val1              ## @my_l_val1
      .p2align    3
  _my_l_val1:
      .quad   13                      ## 0xd
  
      .globl  _my_ll_val1             ## @my_ll_val1
      .p2align    3
  _my_ll_val1:
      .quad   14                      ## 0xe
  
      .comm   _my_s_val0,2,1          ## @my_s_val0
      .comm   _my_i_val0,4,2          ## @my_i_val0
      .comm   _my_l_val0,8,3          ## @my_l_val0
      .comm   _my_ll_val0,8,3         ## @my_ll_val0
  

  整型常量可直接出现在指令中，不需要分配空间
  

  未初始化的全局变量（_my_s_val0）会被放到 bss 数据段
  初始化的全局变量（my_s_val1）会被放到数据段
  

  未初始化的局部变量（my_local_s_val0）只会在栈上分配内存, 且局部变量没有被初始化，其值为栈之前残留的值
  初始化的局部变量（my_local_s_val1）会被放到栈上
  

  临时变量（c 代码中的 30 对应的变量） 对应于指令中的立即数，不会在栈上分配内存
  

• 字符串
  

  char* my_str_val0;
  char* my_str_val1 = "g_val1";
  
  int main()
  {
  
      char* my_local_str_val0;
      char* my_local_str_val1 = "l_val1";
      int v = my_str_val0[0] + my_str_val1[0] + my_local_str_val0[0] + my_local_str_val1[0] + "tmp"[0];
      return v;
  }
  

  .section    __TEXT,__text,regular,pure_instructions
      .macosx_version_min 10, 12
      .globl  _main
      .p2align    4, 0x90
  _main:                                  ## @main
      .cfi_startproc
  ## BB#0:
      pushq   %rbp
  Lcfi0:
      .cfi_def_cfa_offset 16
  Lcfi1:
      .cfi_offset %rbp, -16
      movq    %rsp, %rbp
  Lcfi2:
      .cfi_def_cfa_register %rbp
      movq    _my_str_val0@GOTPCREL(%rip), %rax
      leaq    L_.str.1(%rip), %rcx      ; 加载 L_.str.1 对应的地址到 %rcx
      movl    $0, -4(%rbp)
      movq    %rcx, -24(%rbp)           ; 用L_.str.1 对应的地址初始化 my_local_str_val1
      movq    (%rax), %rax
      movsbl  (%rax), %edx
      movq    _my_str_val1(%rip), %rax
      movsbl  (%rax), %esi
      addl    %esi, %edx
      movq    -16(%rbp), %rax
      movsbl  (%rax), %esi
      addl    %esi, %edx
      movq    -24(%rbp), %rax
      movsbl  (%rax), %esi
      addl    %esi, %edx
      movsbl  L_.str.2(%rip), %esi      ; 获取"tmp"临时变量数据
      addl    %esi, %edx
      movl    %edx, -28(%rbp)
      movl    -28(%rbp), %eax
      popq    %rbp
      retq
      .cfi_endproc
  
      .section    __TEXT,__cstring,cstring_literals
  L_.str:                                 ## @.str
      .asciz  "g_val1"
  
      .section    __DATA,__data
      .globl  _my_str_val1            ## @my_str_val1
      .p2align    3
  _my_str_val1:
      .quad   L_.str
  
      .section    __TEXT,__cstring,cstring_literals
  L_.str.1:                               ## @.str.1
      .asciz  "l_val1"
  
      .comm   _my_str_val0,8,3        ## @my_str_val0   ; 定义一个名为`my_str_val0`的未初始化全局变量，大小为 8字节，对齐单位为 3 字节。
  L_.str.2:                               ## @.str.2
      .asciz  "tmp"
  

  字符串常量被放到 常量字符串段。
  

  指向字符串常量的指针变量：
  未初始化的全局指针变量（char* my_str_val0）会被放到 BSS 数据段(.comm 段)
  初始化的全局指针变量 （char* my_str_val1）会放到数据段
  

  未初始化的局部指针变量（char* my_local_s_val0）只会在栈上分配内存, 且局部变量没有被初始化，其值为栈之前残留的值
  初始化的局部指针变量 （char* my_local_s_val1）会被放到栈上
  

  临时变量（c 代码中的 "tmp" 对应的变量） 对应于指令中的 PC 相对寻址(movsbl L_.str.2(%rip), %esi)，不会在栈上分配内存
  

• 数组
  

  int my_arr_val0[4];
  int my_arr_val1[4] = {1,2,3,4};
  
  int main()
  {
  
      int my_local_arr_val0[4];
      int my_local_arr_val1[4] = {11,12,13,14};
      int v = my_arr_val0[0] + my_arr_val1[0] + my_local_arr_val0[0] + my_local_arr_val1[0] + ((int[]){21,22,23,24})[0];
      return v;
  }
  

  .section    __TEXT,__text,regular,pure_instructions
      .macosx_version_min 10, 12
      .globl  _main
      .p2align    4, 0x90
  _main:                                  ## @main
      pushq   %rbp
  Lcfi0:
  Lcfi1:
      movq    %rsp, %rbp
  Lcfi2:
      .cfi_def_cfa_register %rbp
      movq    _my_arr_val0@GOTPCREL(%rip), %rax
      movl    $0, -4(%rbp)
      movq    L_main.my_local_arr_val1(%rip), %rcx
      movq    %rcx, -48(%rbp)
      movq    L_main.my_local_arr_val1+8(%rip), %rcx
      movq    %rcx, -40(%rbp)
      movl    (%rax), %edx
      addl    _my_arr_val1(%rip), %edx
      addl    -32(%rbp), %edx
      addl    -48(%rbp), %edx
                                        ; (int[]){21,22,23,24}
      movl    $21, -68(%rbp)            ; 初始化临时数组变量  --  开始
      movl    $22, -64(%rbp)            ;
      movl    $23, -60(%rbp)            ;
      movl    $24, -56(%rbp)            ; -- 结束
      addl    -68(%rbp), %edx
      movl    %edx, -52(%rbp)
      movl    -52(%rbp), %eax
      popq    %rbp
      retq
  
      .section    __DATA,__data
      .globl  _my_arr_val1            ## @my_arr_val1
      .p2align    4
  _my_arr_val1:                                                ; 初始化的全局变量 int my_arr_val1[4]
      .long   1                       ## 0x1
      .long   2                       ## 0x2
      .long   3                       ## 0x3
      .long   4                       ## 0x4
  
      .section    __TEXT,__literal16,16byte_literals
      .p2align    4               ## @main.my_local_arr_val1
  L_main.my_local_arr_val1:                                    ; 初始化的局部变量 int my_local_arr_val1[4]
      .long   11                      ## 0xb
      .long   12                      ## 0xc
      .long   13                      ## 0xd
      .long   14                      ## 0xe
  
      .comm   _my_arr_val0,16,4       ## @my_arr_val0          ; 未初始化的全局变量 int my_arr_val0[4]
  

  数组常量可能被放到栈上(临时数组变量)也可能被放到数据段(初始化的全局变量)。
  

  指向字符串常量的指针变量：
  未初始化的全局变量（int my_arr_val0[4]）会被放到 BSS 数据段(.comm 段)
  初始化的全局变量 （int my_arr_val1[4]）会放到数据段
  

  未初始化的局部变量（int my_local_arr_val0）只会在栈上分配内存, 且局部变量没有被初始化，其值为栈之前残留的值
  初始化的局部变量 （int my_local_arr_val1）会被放到 __TEXT 段（在可执行文件中被放置到只读数据段 .rodata ）
  

  临时变量（c 代码中的 ((int[]){21,22,23,24})[0] 对应的变量） 在栈上分配内存
  

• 结构体
  

  struct rec{
      int i;
      int j;
      int a[2];
      int *p;
  };
  
  struct rec my_s0 = {1,2,{3,4},0};
  struct rec my_s1;
  int main()
  {
      struct rec my_s2 = {6,7,8};
      struct rec my_s3;
      int v = my_s0.i + my_s1.j + my_s2.j + my_s3.j;
      my_s2 = (struct rec){1,2,3,4,0};
      v += my_s2.i;
      return v;
  }
  

  .section    __TEXT,__text,regular,pure_instructions
      .macosx_version_min 10, 12
      .globl  _main
      .p2align    4, 0x90
  _main:                                  ## @main
      pushq   %rbp
  Lcfi0:
  Lcfi1:
      movq    %rsp, %rbp
  Lcfi2:                                         ;### 数据访问与计算
      movq    _my_s1@GOTPCREL(%rip), %rax          ;    从全局偏移表（GOT）加载`_my_s1`的地址到寄存器`%rax`
      movl    $0, -4(%rbp)                         ;    初始化栈上的局部变量
      movq    l_main.my_s2(%rip), %rcx             ;    从l_main.my_s2 加载一个 64 位的值，然后将这个值存入寄存器%rcx中。
      movq    %rcx, -32(%rbp)                      ;    初始化栈上的局部变量（`my_s2.i 和 my_s2.j`）
      movq    l_main.my_s2+8(%rip), %rcx           ;    从 l_main.my_s2 位置之后的 8 字节处加载一个64位的值，然后将这个值存入寄存器%rcx中。
      movq    %rcx, -24(%rbp)                      ;    初始化栈上的局部变量（`my_s2.a`）
      movq    l_main.my_s2+16(%rip), %rcx          ;    从 l_main.my_s2 位置之后的 16 字节处加载一个64位的值，然后将这个值存入寄存器%rcx中。
      movq    %rcx, -16(%rbp)                      ;    初始化栈上的局部变量（`my_s2.p`）
      movl    _my_s0(%rip), %edx                   ;    my_s0.i -> %edx
      addl    4(%rax), %edx                        ;    my_s1.j + my_s0.i  -> %edx
      addl    -28(%rbp), %edx                      ;    my_s2.j + (my_s1.j + my_s0.i) -> %edx
      addl    -52(%rbp), %edx                      ;    my_s3.j + (my_s2.j + my_s1.j + my_s0.i) -> %edx  TIPS: my_s3 为未初始化的结构体局部变量
      movl    %edx, -60(%rbp)
      movl    $1, -88(%rbp)                        ;    初始化临时结构体变量 -- 开始
      movl    $2, -84(%rbp)                        ;
      movl    $3, -80(%rbp)                        ;
      movl    $4, -76(%rbp)                        ;
      movq    $0, -72(%rbp)                        ;    -- 初始化结束
      movq    -88(%rbp), %rax                      ;    将临时结构体变量赋值给 my_s2 -- 开始
      movq    %rax, -32(%rbp)                      ;
      movq    -80(%rbp), %rax                      ;
      movq    %rax, -24(%rbp)                      ;
      movq    -72(%rbp), %rax                      ;
      movq    %rax, -16(%rbp)                      ;    -- 赋值结束
      movl    -32(%rbp), %edx                      ;    my_s2.i -> %edx
      addl    -60(%rbp), %edx                      ;    v + my_s2.i -> %edx
      movl    %edx, -60(%rbp)                      ;
      movl    -60(%rbp), %eax                      ;
      popq    %rbp
      retq
  
    .section  __DATA,__data                    ;### 数据段定义
      .globl  _my_s0                  ## @my_s0
      .p2align    3
  _my_s0:                                        ;    _my_s0` 是一个全局变量，包含四个32位整数(1, 2, 3, 4)和一个64位整数(0)。
      .long   1                       ## 0x1
      .long   2                       ## 0x2
      .long   3                       ## 0x3
      .long   4                       ## 0x4
      .quad   0
  
      .section    __TEXT,__const                   ;    定义只读数据段。
      .p2align    3               ## @main.my_s2
  l_main.my_s2:                                  ;    l_main.my_s2` 是一个静态存储区中的变量, 包含四个32位整数(6, 7, 8, 0)和一个64位整数(0)
      .long   6                       ## 0x6
      .long   7                       ## 0x7
      .long   8                       ## 0x8
      .long   0                       ## 0x0
      .quad   0
                                                 ;    定义未初始化的数据段（BSS）
      .comm   _my_s1,24,3             ## @my_s1    ;    定义一个名为`_my_s1`的未初始化全局变量，大小为 24 字节，对齐单位为 3 字节。
  

  初始化的结构体全局变量（_my_s0）会被放到数据段
  未初始化的结构体全局变量（_my_s1）会被放到 bss 数据段
  

  初始化的结构体局部变量（_my_s2）会被放到只读数据段
  未初始化的结构体局部变量（_my_s3）只会在栈上分配内存, 且局部变量没有被初始化，其值为栈之前残留的值
  

  临时结构体变量(my_s2 = (struct rec){1,2,3,4,0};)会在栈上分配内存
  

• Union
  

函数参数

程序员可见的状态

Y86-64 指令

## -masm=intel 可以指定生成 intel格式的汇编代码
gcc -Og -S -masm=intel xxxx.c

指令编码

• RISC 与 CISC 之争
  

  RISC 精简指令集计算机(Reduced Instruction Set Computer)。CISC 复杂指令集计算机(Complex Instruction Set Computer)。
  
  无论是单纯的 RISC 还是单纯的 CISC 都不如结合两者思想精华的设计:
  RISC 机器发展进化过程中，引入了更多的指令。那种将实现细节暴露给机器级程序的思想已经被证明是目光短浅的。随着使用更加高级硬件结构的新处理器模型的开发，许多实现细节已经变得很落后了，但它们仍然是指令集的一部分。不过，作为 RISC 设计核心的指令集仍然是非常适合在流水线化的机器上执行的。
  CISC 机器发展进化过程中，也利用了高性能流水线结构。它们读取 CISC 指令，并动态地翻译成比较简单的、像 RISC 那样的操作的序列。例如，一条将寄存器和内存相加的指令被翻译成 3 个操作：1个是读原始的内存值，1个是执行加法运算，第 3 个就是将和写回内存。由于动态翻译通常可以在实际指令执行前进行，处理器仍然可以保持很高的执行速率。
  

• Y86-64 与 CISC 和 RISC
  

  Y86-64 指令集既有 CISC 指令集的属性，也有 RISC 指令集的属性。和 CISC 一样，它有条件码、长度可变的指令，并用栈来保存返回地址。和 RISC 一样的是，它采用 load/store 体系机构和规则编码,通过寄存器来传递过程参数。Y86-64 指令集可以看成是采用 CISC 指令集, 但又根据某些 RISC 的原理进行了简化。
  

Y86-64 异常

Y86-64 程序

一些 Y86-64 指令的详情

计算流水线

流水线操作的详细说明

流水线的局限性

带反馈的流水线系统

loop:
  subq %rdx,%rbx
  jne targ
  movq $10,%rdx
  jmp loop
targ:
  retq

void loop_function(int64_t *rbx, int64_t *rdx)
{
    while (1)
    {
        *rbx -= *rdx;
        if (*rbx != 0)
        {
            return;
        }
        *rdx = 10;
    }
}

链接器如何解析多重定义的全局符号

与静态库链接

// vector.h
extern void multvec(int *x, int *y, int *z, int n);
extern void addvec(int *x, int *y, int *z, int n);

// addvec.c
int addcnt = 0;
void addvec(int *x, int *y, int *z, int n)
{
    int i;
    addcnt++;
    for(i=0;i<n;i++)
        z[i] = x[i] + y[i];
}

// multvec.c
int multcnt = 0;
void multvec(int *x, int *y, int *z, int n)
{
    int i;
    multcnt++;
    for(i=0;i<n;i++)
        z[i] = x[i] * y[i];
}

// main2.c
#include <stdio.h>
#include "vector.h"

int x[2] = {1, 2};
int y[2] = {3, 4};
int z[2];
int main()
{
    addvec(x,y,z,2);
    printf("z = [%d, %d]\n", z[0], z[1]);
    return 0;
}

# Linux 平台
## 生成静态库 libvector.a
gcc -c addvec.c multvec.c
ar rcs libvector.a addvec.o multvec.o
## 链接静态库
gcc -c main2.c    ## main2.c 中包含了 vector.h
gcc -static -o prog main2.o ./libvector.a

# Linux 平台组合多个静态库
# 假设有两个静态库lib1.a和lib2.a，我们要将它们组合成一个新的静态库libcombined.a

# 创建新的归档文件
ar -rcs libcombined.a

# 从lib1.a和lib2.a中提取成员
ar -x lib1.a
ar -x lib2.a
# 添加到libcombined.a中
ar -r libcombined.a *.o

# 清理临时生成的*.o文件
rm *.o

# Windows 平台
# 生成静态库 libvector.lib
cl /c addvec.c multvec.c
lib /OUT:libvector.lib addvec.obj multvec.obj

## 链接静态库
cl /c main2.c
link main2.obj libvector.lib /OUT:prog

# Windows 平台组合多个静态库
lib /OUT:AllLibs.lib MathLib.lib IOLib.lib UtilsLib.lib

链接器如何使用静态库来解析引用

重定位条目

# 使用下面命令查看目标文件中的 relocation entry 数据
readelf -r main.o

// test_relocation.c
int val0 = 10;
int val1 = 11;

int sum(int a, int b)
{
    return a+b;
}

int main()
{
    int v = sum(val0,val1);
    return v;
}

# 查看重定位条目
readelf -r test_relocation
# 查看符号表
readelf -s test_relocation

重定位符号引用

# 使用下面命令将目标文件逆向为 汇编代码
# -x, --all-headers        Display the contents of all headers
# -d, --disassemble        Display assembler contents of executable sections
objdump -dx main.o

再看 execve 函数

execve("a.out", NULL, NULL);

malloc 和 free

• TODO 为什么 malloc 在 32 位程序中，分配的地址是按照 8 字节对齐，而不是按照 4 字节对齐？
  
• 为什么 malloc 在 64 位程序中，分配的地址是按照 16 字节对齐，而不是按照 8 字节对齐?
  
  • Chris Dodd 的回答
    

    在 x86_64 架构中，xmm 寄存器被广泛使用（所有浮点操作都在 xmm 寄存器中进行，因为 8087 浮点寄存器已被弃用），并且 xmm 寄存器需要 16 字节对齐以实现高效访问。
    

    因此，在 x86_64 中，大多数东西（包括栈和由 malloc 分配的堆）都被组织为始终 16 字节对齐，这样编译器在涉及 xmm 寄存器时可以随时使用“对齐”指令，而不需要使用（可能较慢的）非对齐指令。
    

    在较新的硬件上，即使使用非对齐指令，速度也和对齐指令一样快，只要内存是对齐的。
    

  • Peter Cordes 的回答
    

    x86-64 System V 使用 x87 进行 long double（80 位类型）的计算，并将其填充到 16 字节，alignof(long double) == 16，这样 long double 永远不会跨越缓存行边界。（这样做是否值得，我不确定；可能 SSE2 是支持 16 字节对齐的一个动机，因为这样可以更便宜地实现。）
    

    但无论如何，SSE 并不是唯一导致 alignof(max_align_t) == 16 的因素（这设定了 malloc 允许返回的最小对齐）。
    

    例如，__m128i 的存在不会直接影响 max_align_t，因为 32 位 C 实现的 malloc 返回地址按照 8 字节对齐（而不是 16 字节）。__m256i 在支持 AVX 的系统上存在也没有增加 malloc 返回地址的对齐保证。（如何解决 AVX 加载/存储操作的 32 字节对齐问题？）但对矢量化（自动和手动）来说，特别是在 x86-64 刚出现且 movups 即使在内存对齐时也有惩罚的旧 CPU 上，malloc 的内存对齐足够对 movaps 是很方便的。如果编译器只能看到一个 float*，那么很难利用这种内存对齐保证，因为你可能传递了一个指向分配中间位置的指针。但是，如果它能看到一个输出数组的 malloc，那么在自动矢量化写入到新分配空间的循环时，它知道它将是对齐的。
    

  • 参考资料
    
    • https://stackoverflow.com/questions/70692795/why-is-malloc-16-byte-aligned
      
    • https://stackoverflow.com/questions/32612190/how-to-solve-the-32-byte-alignment-issue-for-avx-load-store-operations
      

分配器的要求和目标

碎片

隐式空闲链表

放置已分配的块

分割空闲块

带边界标记的合并

综合：实现一个简单的分配器

• 通用分配器设计
  

  我们的分配器使用下图所示的内存系统模型。模型的目的在于允许我们在不干涉已存在的系统层 malloc 包的情况下，运行分配器。
  
  空闲链表组织成为一个隐式空闲链表。
  

  • 第一个字是一个双字节边界对齐的不使用的填充字。(本节中假设字是 4 字节对象，双字是 8 字节对象)
    
  • 紧跟着的是一个特殊的序言块（prologue block）, 这是一个 8 字节的已分配块，只由一个头部和一个脚部组成。序言块实在初始化时创建的，并且永不释放。
    
  • 紧跟着的是零个或者多个由 malloc 或者 free 调用创建的普通块
    
  • 堆总是以一个特殊的结尾块(epilogue block)来结束，这个块是一个大小为 0 的普通块，只有一个头部组成
    

  TIPS: 序言块和结尾块是一种合并时消除边界条件的技巧。
  

  块格式如图 9-39 所示, 最小块的大小为 16 字节(按照 16 字节对齐，满足 64 位程序。16 字节对齐的地址必然是 8 字节对齐的，也就必然是满足 32 位程序的)。
  
  

显式空闲链表

分离的空闲链表