1
2
3
4
5
6

.code16               ; 生成16位的指令
.section .data        ; 数据段
.section .text        ; 代码段


.file ”stage1.s”

1
2

.byte 0x80,0xca    //.byte 伪指令
.word 0x800

1
2
3
4
5
6
7

    .globl  var
    .data
    .align 4
    .type   var, @object
    .size   var, 4
var:
    .long   10

1
2
3

    .long 1,2,3
    .zero 10
    .string "hello"

1
2
3
4
5

    .text
    .globl  func
    .type   func, @function
func:
    汇编指令

1
2
3
4

pushl $0x1234
// 等价于
sub $0x4， %rsp
movl $0x1234 (%rsp)

1

popq %rax

1
2
3
4
5

// square.c
int32_t square(int32_t num) {
    int k = 10;
    return 5 * num + 6 - k;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

; square.s
square:
        // 注意，此时 create_obj 的栈帧还未构建完毕
        // 因此 rsp 虽然是栈顶指针，但起始指向的是上一个汉奸的栈顶
        // 同时 rbp 也是指向上一个函数的栈底
        pushq   %rbp                // 保存前一个栈帧栈底到当前栈顶。
                                    // 这是为了让上一个函数调用后能恢复它栈底的值到 %rbp。
        movq    %rsp, %rbp          // 保存当前栈顶的值到 `%rbp`，作为当前函数的栈底指针的值。
        movl    %edi, -20(%rbp)     // 将函数的第一个参数 num 保存到当前函数的栈底 -20 处。
        movl    $10, -4(%rbp)       // 将函数的第一个局部变量 k 保存到当前函数的栈底 -4 处。
        movl    -20(%rbp), %edx     // 将变量 num 保存到 %edx 中。
        movl    %edx, %eax          // 将变量 num 保存到 %eax 中。
        sall    $2, %eax            // 将变量 num 乘以 4。(左移 2 相当于乘以 4) 得到 %eax = num * 4。
        addl    %edx, %eax          // 将变量 %eax 加上 %edx ，即 %eax = num * 4 + num = num * 5。
        addl    $6, %eax            // 将变量 %eax 加上 6，即 %eax = num * 5 + 6;
        subl    -4(%rbp), %eax      // 将变量 %eax 减去 k ，即 %eax = num * 5 + 6 - k;        
        popq    %rbp                // 将栈顶保存到 %rbp 中，并释放栈帧。
        ret

1
2
3
4
5
6
7
8

; demo.s
.section .data
.section .text
.globl _start
_start:
movl $1, %eax
movl $4, %ebx
int $0x80

1
2
3
4
5
6

// 汇编
[]$ as demo.s -o demo.o
// 链接
[]$ ld demo.o -o demo
//
[]$ ./demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

MOV     传送字或字节
MOVSX   先符号扩展,再传送.  
MOVZX   先零扩展,再传送.  
PUSH    把字压入堆栈.  
POP     把字弹出堆栈.  
PUSHA   把AX,CX,DX,BX,SP,BP,SI,DI依次压入堆栈.  
POPA    把DI,SI,BP,SP,BX,DX,CX,AX依次弹出堆栈.  
PUSHAD  把EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI依次压入堆栈.  
POPAD   把EDI,ESI,EBP,ESP,EBX,EDX,ECX,EAX依次弹出堆栈.  
BSWAP   交换32位寄存器里字节的顺序  
XCHG    交换字或字节.(至少有一个操作数为寄存器,段寄存器不可作为操作数)  
CMPXCHG 比较并交换操作数.(第二个操作数必须为累加器AL/AX/EAX)  
XADD    先交换再累加.(结果在第一个操作数里)  
XLAT    字节查表转换.----BX指向一张256字节的表的起点,AL为表的索引值(0-255,即0-FFH);返回AL为查表结果.([BX+AL]->AL)  

1
2

IN      I/O端口输入. ( 语法: IN   累加器,    {端口号│DX} )  
OUT     I/O端口输出. ( 语法: OUT {端口号│DX},累加器 )输入输出端口由立即方式指定时,    其范围是 0-255; 由寄存器 DX 指定时,其范围是    0-65535.  

1
2
3
4
5
6
7

LEA <DST>, <SRC>  ;将<SRC>的偏移量OA装载到<DST>中.例: LEA DX,string ;  把偏移地址存到DX.  
LDS <DST>, <SRC>  ;将当前数据段中的一个双字数据装入到一个通用寄存器SI(双字数据的低字)和数据段寄存器DS(双字数据的高字)中;
传送目标指针,把指针内容装入DS.例: LDS SI,string   ; 把段地址:偏移地址存到DS:SI.  
LES     传送目标指针,把指针内容装入ES.例: LES DI,string   ;把段地址:偏移地址存到ES:DI.  
LFS     传送目标指针,把指针内容装入FS.例: LFS DI,string   ;把段地址:偏移地址存到FS:DI.  
LGS     传送目标指针,把指针内容装入GS.例: LGS DI,string   ;把段地址:偏移地址存到GS:DI.  
LSS     传送目标指针,把指针内容装入SS.例: LSS DI,string   ;把段地址:偏移地址存到SS:DI.  

1
2
3
4
5
6

LAHF    标志寄存器传送,把标志装入AH.  
SAHF    标志寄存器传送,把AH内容装入标志寄存器.  
PUSHF   标志入栈.  
POPF    标志出栈.  
PUSHD   32位标志入栈.  
POPD    32位标志出栈.  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include<stdio.h>
int function(int x ,int y,int z) 
{
    return x+y-z;
}

int main()
{
    function(2,3,4);  //仅仅调用此函数而已
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

;; 1. 函数调用过程
; 提升堆栈
PUSH EBP             ; 将旧EBP入栈，保存旧栈桢基址
MOV  EBP, ESP        ; 将旧栈顶指针ESP设为新的栈桢基址，即新的栈桢紧接父调用的栈桢
SUB  ESP, 40         ; ESP减少移动40个字节，即开辟40字节大小的函数栈桢空间
; 保留调用现场
PUSH EBX             ; 将EBX入栈
PUSH ESI
PUSH EDI
; 向分配的空间填充数据
LEA  EDI, DWORD PTR SS:[EBP-40]    ;
MOV  ECX, 10
MOV  EAX, CCCCCCCC
REP  STOS DWORD PTR ES:[EDI]
; 函数功能
MOV  EAX, DWORD PTR SS:[EBP+8]
ADD  EAX, DWORD PTR SS:[EBP+C]
; 恢复现场
POP EDI
POP ESI
POP EBX
; 恢复栈桢
MOV ESP, EBP
POP EBP
RETN            ; 返回

1
2
3
4
5
6
7
8

; 函数入口
PUSH 2         ; 将函数参数压入栈中
PUSH 1
CALL 0040100A  ; 调用函数

; 函数出口
MOV EAX, DWORD PTR SS:[EBP+8]
ADD EAX, DWORD PTR SS:[EBP+C]