C语言到汇编-结构

作者: 故事观察日记 | 来源:发表于2020-04-18 13:40 被阅读0次

C语言到汇编-结构
C语言第一节
目录
C语言概述
2018-04-03 JAVA基础入门
C语言简单实现面向对象思想
2. 指令集对CPU的意义
如何学习编程
2019-03-28 程序设计语言基础知识
C语言特点

结构是一个或多个变量的集合，这些变量可能为不同的类型，为了处理的方便而将这些变量组织在一个名字之下。
比如，将坐标系中的x 坐标和y 坐标组织在一起作为一个“点”结构，或者将姓名、性别、年龄等信息组织在一起作为一个描述“人”的结构。

struct {
    int x;  /* x坐标 */
    int y;   /* y坐标 */
};

struct {
    char *name;
    int sex;
    int age;
};

上面代码是结构本身的声明。结构是一种数据类型，类似int 、double 之类的东西，声明一个int 类型的变量如下：

int a;

类似的，声明一个结构类型的变量格式如下：

struct {
    int x;
    int y; 
} a;

也可以给结构起个名字，或者叫标记，如下：

struct  point {  /* point 是结构的标记 */
    int x;
    int y; 
};

这样就可以用point 代替大括号里的内容，声明结构类型的变量就可以写作：

struct point a;

下面代码是错误的：

main(){ 
    struct point p;
    p.x = 1;
    p.y = 2;
}

struct point {
    int x;
    int y;
};

因为代码的下面部分是结构的声明，而main 函数中要使用这个结构，所以应该把结构的声明放在使用之前，正确代码如下：

struct point {
    int x;
    int y;
};

main(){ 
    struct point p;
    p.x = 1;
    p.y = 2;
}

这与int 等基本类型可以随意使用不同，因为结构是自定义类型。
上面这段正确代码编译后的汇编代码如下：

    .file   "struct.c"
    .intel_syntax
    .def    ___main;    .scl    2;  .type   32; .endef
    .text
.globl _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
    push    ebp
    mov ebp, esp
    sub esp, 24
    and esp, -16
    mov eax, 0
    add eax, 15
    add eax, 15
    shr eax, 4
    sal eax, 4
    mov DWORD PTR [ebp-12], eax
    mov eax, DWORD PTR [ebp-12]
    call    __alloca
    call    ___main
    mov DWORD PTR [ebp-8], 1
    mov DWORD PTR [ebp-4], 2
    leave
    ret

这段代码中并没有能体现原代码中声明的那个点结构的代码，也就是代码：

struct point {
    int x;
    int y;
};

在编译后就没了。原代码与下面代码：

main(){ 
    int x = 1;
    int y = 2;
}

在编译后并无任何不同。这与int 等基础类型也很相似，定义或声明一个int 类型的变量，在编译后的汇编代码中也不存在“int ”这个东西，而是在给变量分配内存空间时会按照int 类型的长度分配4个内存单元（具体长度与机器有关）。若是定义了一个char 类型的变量，那么在分配内存时就会为变量分配1个内存单元。
所以，必然有一个地方存储着有关“结构”的描述内容，编译器才能根据结构描述直接为结构类型的变量分配内存空间，而“结构”也才能不在编译后的代码中存在。相关内容可以参考C语言的“符号表和类型系统”。
再来看一个例子：

struct person {
    char *name;
    char sex;
    int age;
};

main(){ 
    struct person p;
    p.name = "YCY";
    p.sex = 1;
    p.age = 21;
    printf("%d", sizeof(p));
}

编译后的汇编代码：

    .section .rdata,"dr"
LC0:
    .ascii "YCY\0"
LC1:
    .ascii "%d\0"
    .text
_main:
    mov DWORD PTR [ebp-24], OFFSET FLAT:LC0
    mov BYTE PTR [ebp-20], 1
    mov DWORD PTR [ebp-16], 21
    mov DWORD PTR [esp+4], 12
    mov DWORD PTR [esp], OFFSET FLAT:LC1
    call    _printf
    leave
    ret

代码中存储char 类型的值用了4 个字节，而char 指针类型则是用4个字节存储的字符数组首地址。可见，编译后的代码会根据结构声明为结构成员分配内存，同时还会考虑内存对齐的问题。所以结构的长度并不一定等于结构内每个数据类型的长度之和。
本章剩余内容有：

1.结构与函数
2.结构数组
3.自引用结构
4.类型定义
5.联合
6.位字段

下面分别举例进行说明。
1.结构与函数：

#include <stdio.h>

struct  point {  /* point 是结构的标记 */
    int x;
    int y; 
};

struct point addpoint(struct point p1, struct point p2) 
 { 
 p1.x += p2.x; 
 p1.y += p2.y; 
 return p1; 
 }
 
main(){ 
    struct point p1 = {1,2};
    struct point p2 = {3,4};
    addpoint(p1, p2);
}

上面例子中，函数的参数和返回值都是结构类型。编译后汇编代码：

    .text
_addpoint:
    push    ebp
    mov ebp, esp
    mov eax, DWORD PTR [ebp+16]
    add DWORD PTR [ebp+8], eax
    mov edx, DWORD PTR [ebp+20]
    lea eax, [ebp+12]
    add DWORD PTR [eax], edx
    mov eax, DWORD PTR [ebp+8]
    mov edx, DWORD PTR [ebp+12]
    pop ebp
    ret
_main:
    mov DWORD PTR [ebp-8], 1
    mov DWORD PTR [ebp-4], 2
    mov DWORD PTR [ebp-16], 3
    mov DWORD PTR [ebp-12], 4
    mov eax, DWORD PTR [ebp-16]
    mov edx, DWORD PTR [ebp-12]
    mov DWORD PTR [esp+8], eax
    mov DWORD PTR [esp+12], edx
    mov eax, DWORD PTR [ebp-8]
    mov edx, DWORD PTR [ebp-4]
    mov DWORD PTR [esp], eax
    mov DWORD PTR [esp+4], edx
    call    _addpoint
    leave
    ret

可以看到，结构无论是作为参数还是返回值，结构成员的值都是直接存储在栈内存或者寄存器之中的，与一般变量并无不同。
2.结构数组：

struct key { 
char *word; 
int count; 
} keytab[] = { 
"auto", 0, 
"break", 0, 
"case", 0, 
"char", 0, 
"const", 0, 
"continue", 0, 
"default", 0, 
"unsigned", 0, 
"void", 0, 
"volatile", 0, 
"while", 0 
}; 
 
main(){ 
    int length = sizeof(keytab);
    int i = 0;
    for(; i<length; i++){
        if(keytab[i].word=="char")
            keytab[i].count++;          
    }
}

上述代码声明了key 结构的数组keytab，并进行了初始化。main 函数中遍历结构数组keytab，遇到关键字char 则将其数量加1。编译后汇编代码如下：

    .section .rdata,"dr"
LC0:
    .ascii "auto\0"
LC1:
    .ascii "break\0"
LC2:
    .ascii "case\0"
LC3:
    .ascii "char\0"
LC4:
    .ascii "const\0"
LC5:
    .ascii "continue\0"
LC6:
    .ascii "default\0"
LC7:
    .ascii "unsigned\0"
LC8:
    .ascii "void\0"
LC9:
    .ascii "volatile\0"
LC10:
    .ascii "while\0"
.globl _keytab
    .data
    .align 32
_keytab:
    .long   LC0
    .long   0
    .long   LC1
    .long   0
    .long   LC2
    .long   0
    .long   LC3
    .long   0
    .long   LC4
    .long   0
    .long   LC5
    .long   0
    .long   LC6
    .long   0
    .long   LC7
    .long   0
    .long   LC8
    .long   0
    .long   LC9
    .long   0
    .long   LC10
    .long   0
    .text
_main:
    mov DWORD PTR [ebp-4], 88
    mov DWORD PTR [ebp-8], 0
L2:
    mov eax, DWORD PTR [ebp-8]
    cmp eax, DWORD PTR [ebp-4]
    jge L3
    mov eax, DWORD PTR [ebp-8]
    cmp DWORD PTR _keytab[0+eax*8], OFFSET FLAT:LC3
    jne L4
    mov eax, DWORD PTR [ebp-8]
    inc DWORD PTR _keytab[4+eax*8]
L4:
    lea eax, [ebp-8]
    inc DWORD PTR [eax]
    jmp L2
L3:
    leave
    ret

由此可见，结构数组与普通数组差别不大，只是把结构成员按普通数组成员的形式进行了展开而已。
3.自引用结构

struct tnode { /* the tree node: */ 
 char *word; /* points to the text */ 
 int count; /* number of occurrences */ 
 struct tnode *left; /* left child */ 
 struct tnode *right; /* right child */ 
 };

main(){ 
    struct tnode node1 = {"char",1,NULL,NULL};
    struct tnode node2 = {"void",2,NULL,NULL};
    struct tnode node3 = {"case",3,&node1,&node2};
}

上述代码中，node1和node2变量类似int x中的x变量，代表的是等号后面整个大括号里的内容，所以要用&取地址，而不像数组名可以直接赋值给指针类型的变量。
编译后的汇编代码如下：

LC0:
    .ascii "char\0"
LC1:
    .ascii "void\0"
LC2:
    .ascii "case\0"
    .text
_main:
    mov DWORD PTR [ebp-24], OFFSET FLAT:LC0
    mov DWORD PTR [ebp-20], 1
    mov DWORD PTR [ebp-16], 0
    mov DWORD PTR [ebp-12], 0
    mov DWORD PTR [ebp-40], OFFSET FLAT:LC1
    mov DWORD PTR [ebp-36], 2
    mov DWORD PTR [ebp-32], 0
    mov DWORD PTR [ebp-28], 0
    mov DWORD PTR [ebp-56], OFFSET FLAT:LC2
    mov DWORD PTR [ebp-52], 3
    lea eax, [ebp-24]
    mov DWORD PTR [ebp-48], eax
    lea eax, [ebp-40]
    mov DWORD PTR [ebp-44], eax
    leave
    ret

可见，自引用结构只是将（另一个）结构的地址作为值赋给了结构中指向本结构的指针变量。
4.类型定义
C 语言提供了一个称为 typedef 的功能，它用来建立新的数据类型名，例如，声明：

typedef int Length;

将 Length 定义为与 int 具有同等意义的名字。类型 Length 可用于类型声明、类型转换等，它和类型 int 完全相同，例如：

typedef int Length;
main(){ 
    Length len1 = 10; 
    Length len2 = 20;
    Length *lengths[] = {&len1, &len2};
}

类型定义同样在编译后的汇编代码中不存在。
5.联合

union number { 
 int ivalue; 
 float fvalue; 
 char *svalue; 
 };

联合声明形式和结构类似，只是把struct 关键字换成了union 。上面的联合声明表示，这个联合类型的变量可以存储为三种不同的类型值，但它们共用一个内存位置。例如：

union number { 
 int ivalue; 
 float fvalue; 
 char *svalue; 
 };

main(){ 
    union number num;
    num.ivalue = 1;
    num.fvalue = 1.1;
    num.svalue = "hello";
}

编译后的汇编代码：

    .section .rdata,"dr"
LC1:
    .ascii "hello\0"
    .text
_main:
    mov DWORD PTR [ebp-4], 1
    mov eax, 0x3f8ccccd
    mov DWORD PTR [ebp-4], eax
    mov DWORD PTR [ebp-4], OFFSET FLAT:LC1
    leave
    ret

可见，无论给联合中的哪个成员变量赋值，结果都是存在同一个内存位置[ebp-4]中，访问时得到的是最后一次存入的内容。
6.位字段
类似汇编中的标志寄存器flag，用每一个二进制位来表示特定的信息。位字段（bit-field），或简称字段，是“字”中相邻位的集合。“字”（word）是单个的存储单元，它同具体的实现有关。

struct { 
 unsigned int is_keyword : 1; 
 unsigned int is_extern : 1; 
 unsigned int is_static : 1; 
 } flags;

main(){ 
    flags.is_extern = 0;
    flags.is_static = 1;
    if (flags.is_extern == 0)
        printf("hello, world");
    if (flags.is_static == 1)
        printf("hello, world");
}

编译后的汇编代码为：

    .section .rdata,"dr"
LC0:
    .ascii "hello, world\0"
    .text
_main:
    and BYTE PTR _flags, -3
    or  BYTE PTR _flags, 4
    movzx   eax, BYTE PTR _flags
    shr al
    movzx   eax, al
    and eax, 1
    test    eax, eax
    jne L2
    mov DWORD PTR [esp], OFFSET FLAT:LC0
    call    _printf
L2:
    movzx   eax, BYTE PTR _flags
    shr al, 2
    movzx   eax, al
    and eax, 1
    cmp eax, 1
    jne L3
    mov DWORD PTR [esp], OFFSET FLAT:LC0
    call    _printf
L3:
    leave
    ret
    .comm   _flags, 16   # 4

这里存储位字段使用了16位，也即一个“字”的长度。
几个新汇编指令：
movax：数据传送指令mov的变体。无符号扩展，并传送。
test：将两个操作数进行逻辑与运算，并根据运算结果设置相关的标志位。test命令的两个操作数不会被改变。运算结果在设置过相关标记位后会被丢弃。test的其中一个功能是：若运算结果为0，则设置汇编标志寄存器的zf位为0。因此，代码：