AT&T汇编语言基础学习示例

Linux内核中硬件相关的代码基本都是用AT&T汇编语言实现，最近决定系统学习一下，以下使用AT&T汇编语言编写的几个简单程序：

1. Hello World.

点击(此处)折叠或打开

1. .section .rodata
   
2. hello:
   
3.   .asciz "Hello, world"        # 定义打印字符串,存放在数据段中，ro表示只读；
   
4. 
   
5. format:
   
6.   .asciz "%s\n"                # 定义打印格式字符串，存放在数据段中；
   
7. 
   
8. 
   
9. .section .text                 # 代码段定义main函数。
   
10. .globl main
    
11. main:
    
12.   pushl $hello                 # push第二个参数到栈中
    
13.   pushl $format                # push第一个参数到栈中
    
14.   call printf                  # 调用printf("%s\n", &hello)
15.   addl $8, %esp
    
16. 
    
17.   pushl $0
    
18.   call exit                    # 调用exit(0)

编译运行的结果：
# gcc -o hello hello.s
./hello
Hello, world

2. 简单的加减法:

点击(此处)折叠或打开

1. .section .rodata
   
2. a:
   
3.   .int 100
   
4. b:
   
5.   .int 200
   
6. 
   
7. .section .data
   
8. c:
   
9.   .int 0
   
10. format:
    
11.   .asciz "%d\n"
    
12. 
    
13. .section .text
    
14. .globl main
    
15. main:
    
16.   movl b, %eax
    
17.   addl a, %eax
    
18.   movl %eax, c                        # c= a+ b = 300
    
19.   pushl c
    
20.   pushl $format
    
21.   call printf                         # printf("%d", c)
    
22.   addl $8, %esp
    
23. 
    
24.   movl b, %eax
    
25.   subl a, %eax
    
26.   movl %eax, c                        # c= a- b = 100
    
27.   pushl c
    
28.   pushl $format
    
29.   call printf                         # printf("%d", c)
    
30.   addl $8, %esp
    
31. 
    
32.   pushl $0
    
33.   call exit

编译运行结果：
# gcc -o math math.s
# ./math
300
100

3. if/else 判断

 

1. # judge.s
   
2. 
   
3. .section .rodata
   
4. num:
   
5.   .int 1
   
6. 
   
7. iszero:
   
8.   .asciz "num is 0\n"
   
9. 
   
10. notzero:
    
11.   .asciz "num is not zero\n"
    
12. 
    
13. .section .text
    
14. .globl main
    
15. main:
    
16.   cmp $0, num
    
17.   jz Yes
    
18. No:
    
19.   pushl $notzero
    
20.   call printf
    
21.   addl $4, %esp
    
22. 
    
23.   jmp end
    
24. Yes:
    
25.   pushl $iszero
    
26.   call printf
    
27.   addl $4, %esp
    
28. 
    
29. end:
    
30.   pushl $0
    
31.   call exit

编译运行：
# gcc -o judge judge.s
# ./judge
num is not zero

4. while循环打印0~100

点击(此处)折叠或打开

1. # while.s
3. .section .data
   
4. format:
   
5.   .asciz "%d\n"
   
6. 
   
7. num:
   
8.   .int 0
   
9. 
   
10. .section .text
    
11. .globl main
    
12. main:
    
13.   movl $0, num
    
14. loop:
    
15.   movl num, %eax
    
16.   addl $1, %eax
    
17.   movl %eax, num
    
18. 
    
19.   pushl %eax
    
20.   pushl $format
    
21.   call printf
    
22.   addl $8, %esp
    
23. 
    
24.   cmp $100, num
    
25.   jnz loop
    
26. 
    
27.   pushl $0
    
28.   call exit

编译并运行：
# gcc -o while while.s
# ./while
0
1
2
...
100

5. 数组的访问
for循环打印数组中的元素

点击(此处)折叠或打开

1. # array.s
   
2. 
   
3. .section .rodata
   
4. array:
   
5.    .int 1, 2, 3 # 定义数组
   
6. format:
   
7.    .asciz "%d\n"
   
8. 
   
9. .section .text
   
10. .globl main
    
11. main:
    
12.    movl $array, %edi # 保存array的地址
    
13. for:
    
14.    pushl (%edi) # 间接寻址得到array中的元素
    
15.    pushl $format
    
16.    call printf
    
17.    addl $8, %esp
    
18.    addl $4, %edi # 得到array中下一个元素的地址
    
19.    cmp $format, %edi
    
20.    jnz for
    
21. 
    
22.    pushl $0
    
23.    call exit

编译运行结果：
# gcc -o array array.s
# ./array
1
2
3
6. 基本的位操作

点击(此处)折叠或打开

1. .section .data
   
2. num:
   
3.   .int 1
   
4. 
   
5. format:
   
6.   .asciz "num is %d\n"
   
7. 
   
8. zfstr:
   
9.   .asciz "ZF is set\n"
   
10. 
    
11. .section .text
    
12. .globl main
    
13. main:
    
14.   # 1. 算术左移
    
15.   # a. 右边直接补0
    
16.   # b. 左边移除的位放在CF进位标志中
    
17.   sall num # num = 2
    
18.   pushl num
    
19.   push $format
    
20.   call printf
    
21.   addl $8, %esp
    
22. 
    
23.   # 2. 逻辑左移
    
24.   # a. 右边直接补0
    
25.   # b. 左边移除的位放在CF进位标志中
    
26.   shll num # num = 4
    
27.   pushl num
    
28.   push $format
    
29.   call printf
    
30.   addl $8, %esp
    
31. 
    
32.   # 3. 算术右移动
    
33.   # a. 左边补充符号位
    
34.   # b. 右边移除的位放在CF进位标志中
    
35.   sarl num # num = 2
    
36.   pushl num
    
37.   push $format
    
38.   call printf
    
39.   addl $8, %esp
    
40. 
    
41.   # 4. 逻辑右移动
    
42.   # a. 左边补充符号位
    
43.   # b. 右边移除的位放在CF进位标志中
    
44.   shrl num # num = 1
    
45.   pushl num
    
46.   push $format
    
47.   call printf
    
48.   addl $8, %esp
    
49. 
    
50.   # 5. 与
    
51.   andl $1, num # num = 1
    
52.   pushl num
    
53.   push $format
    
54.   call printf
    
55.   addl $8, %esp
    
56. 
    
57.   # 6. 或
    
58.   orl $2, num # num = 3
    
59.   pushl num
    
60.   push $format
    
61.   call printf
    
62.   addl $8, %esp
    
63. 
    
64.   # 7. 循环右位移
    
65.   rorl num # num = 10000000 | 00000000 | 00000000 | 00000001
    
66.   pushl num
    
67.   push $format
    
68.   call printf
    
69.   addl $8, %esp
    
70. 
    
71.   # 8. 循环左位移
    
72.   roll num # num = 3
    
73.   pushl num
    
74.   push $format
    
75.   call printf
    
76.   addl $8, %esp
    
77. 
    
78.   # 9. 按位异或
    
79.   xorl $1, num # num = 2
    
80.   pushl num
    
81.   push $format
    
82.   call printf
    
83.   addl $8, %esp
    
84. 
    
85.   # 10. test并设置ZF
    
86.   movl $1, %eax
    
87.   test %eax, num
    
88.   jz setzf
    
89. 
    
90.   pushl $0
    
91.   call exit
    
92. 
    
93. setzf:
    
94.   pushl $zfstr
    
95.   call printf
    
96.   pushl $0
    
97.   call exit

编译并运行：
# gcc -o bitop bitop.s
# ./bitop
num is 2
num is 4
num is 2
num is 1
num is 1
num is 3
num is -2147483647
num is 3
num is 2
ZF is set
7. 函数调用实现fibonacci数列

点击(此处)折叠或打开

1. # finn.s
   
2. 
   
3. .section .rodata
   
4. format:
   
5.   .asciz "finn(%d) = %d\n"
   
6. 
   
7. .section .text
   
8. .globl finn
   
9.   .type @function
   
10. finn:
    
11.   pushl %ebp                      # (1). 保存原始的ebp
    
12.   movl %esp, %ebp                 #(2). 保存当前的esp
    
13. 
    
14.   pushl %ebx                      # (3). 保存要被修改的寄存器
    
15.   pushl %ecx
    
16. 
    
17.   # 当前的栈的状态:
    
18.   #              +----------------+
    
19.   #              |      ...      |
    
20.   #              +----------------+
    
21.   #              |      ...      |<-- 12(%ebp)
    
22.   #              +----------------+
    
23.   #              |      arg1      | <-- 8(%ebp)
    
24.   #              +----------------+
    
25.   #              | return address | <-- 4(%ebp)
    
26.   #              +----------------+
    
27.   #              |     old ebp    | <--ebp
    
28.   #              +----------------+
    
29.   #     ^        |     old ebx    |
    
30.   #     |        +----------------+
31.   #   memory     |     old ecx    | <-- esp
    
32.   #  addresses   +----------------+
    
33. 
    
34.   movl 8(%ebp), %ebx              #(4). 得到参数
    
35.   cmpl $2, %ebx                   #(5). 参数与2比较
    
36.   jle L1                          # 参数 <= 2 则直接返回1, 否则计算finn(n-1)+ finn(n-2)
    
37. 
    
38.   subl $1, %ebx                  #(6). 得到(n-1)
    
39.   pushl %ebx
    
40.   call finn
    
41.   addl $4, %esp
    
42. 
    
43.   movl %eax, %ecx                 #(7). 得到finn(n-1)
    
44. 
    
45.   subl $1, %ebx                   #(8). 得到(n-2)
    
46.   pushl %ebx
    
47.   call finn
    
48.   addl $4, %esp
    
49. 
    
50.   addl %ecx, %eax                 #(9). 得到finn(n-1)+ finn(n-2)
    
51.   jmp RET
    
52. 
    
53. L1:
    
54.   movl $1, %eax
    
55. RET:
    
56.   popl %ecx
    
57.   popl %ebx
    
58.   movl %ebp, %esp                # (10). 得到(2)保存的esp
    
59.   popl %ebp                      # (11). 得到(1)保存的ebp
    
60.   ret
    
61. 
    
62. .globl main
    
63. main:
    
64.   movl $10, %edi
    
65.   pushl %edi # 将参数放到栈中
    
66.   call finn
    
67.   addl $4, %esp
    
68. 
    
69.   pushl %eax
    
70.   pushl %edi
    
71.   pushl $format
    
72.   call printf
    
73.   addl $8, %esp
    
74. 
    
75.   pushl $0
    
76.   call exit

编译运行结果：
# gcc -o finn finn.s
# ./finn
finn(10) = 55