movl -4(%rbp), %eax    #把%rbp-4的值拷贝到%eax
addl -8(%rbp), %eax   #把%rbp-8地址的值加到%eax上
movl %eax, -12(%rbp)   #把%eax的值写到内存地址%rbp-12

and 对两个操作数的内容进行逻辑与运算，并将结果存储到第二个操作数，将溢出标志位及进位标志设置为FALSE。

not 对操作数的每一位逻辑取反，也称为一个数的补数

or 对两个操作数进行逻辑或，并将结果存储到第二个操作数，将溢出标志位设置为FLASE

adc 带进位加法。将进位位与第一个操作数与第二个操作数相加，如果存在溢出，就将溢出及进位标志设置为真。

cdq将%eax中的字带符号扩展为%eax:%eax组成的双字。q表示这是一个双字（64字节）.这条指令通常在发出idivl指令之前。

cmp 比较两个整数，将第二个操作数减去第一个操作数，舍弃结果，设置标志位。

dec将寄存器或内存位置的数据减一。

div执行无符号除法。将%edx:%eax所含的双字除以指定寄存器或内存位置的值。运算后%eax包含商，%edx包含余数，如果商对于%eax来说过大，导致溢出，将触发中断0.

idiv执行有符号除法。

imul执行有符号乘法，将结果保存到第二个操作数。如果第二个操作数空缺，就默认为%eax,且完好的结果将存在%eax:%eax中

inc递增给定寄存器或地址。

mul执行无符号乘法，运算规则与imull相同

neg将给定寄存器或内存位置的内容补齐（二进制求补）

sbb错位减法，与adc用法相同。通常使用sub

sub将两个操作数相减，用第二个操作数减去第一个操作数，将结果保存的到第二个操作数，本指令可用于有符号整数及无符号整数

位操作

rcl将第一个操作数，向左循环移位给定次数，第一个操作数可以是立即数或寄存器%cl。循环移位包含进位标志，因此此指令实际上对33位而非32位进行操作。本指令将设置溢出标志

rcr向右循环移位，其他与上一条指令相同

rol向左循环移位，本指令设置溢出标志和进位标志，但不会将进位位作为循环移位的一部分。向左循环移位的次数可以通过立即寻址方式或寄存器%cl的值指定

ror向右循环移位，其他与上一条指令相同

sal算术左移，符号位移出至进位标志，最低有效位填充0，其他位左移。与一般左移相同，移动位数通过立即寻址方式或是寄存器%cl指定。

sar算术右移（填上符号位），最低有效位移出至进位标志，符号位被向右移入，并保留原符号位。其他位只是向右移。移动位数通过立即寻址方式或是寄存器%cl指定。

shl逻辑左移，将所有位左移（对符号位不做特殊处理）.将最左一位推入进位标志，移动位数通过立即寻址方式或是寄存器%cl指定。

shr逻辑右移，将所有位右移（对符号位不做特殊处理）.将最右一位推入进位标志，移动位数通过立即寻址方式或是寄存器%cl指定。

比较操作指令

标志寄存器

OF: 溢出标志.最近的操作导致一个补码溢出---正溢出或负溢出。

SF : 符号标志.最近的操作得到的结果为负数。

ZF:零标志，最近的操作得出的结果为0。

A 辅助进位标志。

P 奇偶标志，如果最后一个结果的低字节由偶数个1，此标志为真。

CF 进位标志，最近的操作使最高位产生了进位。可用来检查无符号操作的溢出。

例如，用一条ADD指令完成等价于t=a+b的功能，这里a、b和t都是整型。然后根据结果来设置条件码:

CF (unsigned) t < (unsigned) a 无符号溢出

ZF (t = 0) 零

SF (t < 0) 负数

OF (a < 0==b < 0) && (t < 0 !=a < 0) 有符号溢出

流控制指令

call 将%eip所指的下一个值入栈，并跳转到目的地址。这用于函数调用。目的地址也可以是星号后跟寄存器的形式，这种方式为间接函数调用。例如 call *%eax将调用%eax中所含地址所指的函数

int 引起给定数字的中断。

jxx条件分支。xx为条件（由前一条指令设置）为TRUE，就跳转到给定的地址；否则，执行下一条指令。条件代码如下：

• [n]a[e]—大于（无符号大于）、不大于、大于等于
• [n]b[e]—小于（无符号小于）
• [n]e—等于
• [n]z—0
• [n]g[e]—大于（带符号比较）
• [n]l[e]—小于（带符号比较）
• [n]c——进位标志集
• [n]o ——溢出标志集
• [p]p ——相等标志集
• [n]s ——符号标志集
• ecxz——%ecx为0

jmp无条件跳转。仅仅是将%eip设置为目的地址，目的地址也可以是星号后跟寄存器的形式，这种方式为间接函数调用。jmp *%eax用寄存器中的值作为跳转目标，jmp *(%rax)以内存地址%rax中的值作为跳转目标。

ret从栈种弹出值，并将%eip设置为该值，用于从函数调用返回。

三、伪指令

.equ

.equ允许你为数字分配名称。例如

.equ LINUX_SYSCALL,0x80

int $LINUX_SYSCALL

.section .data
helloworld:
	.ascii "hello world\n"
helloworld_end;
.equ helloworld_len, helloworld_end - helloworld

.rept 30  #填充30字节0
.byte 0
.endr

.section .bss
.locmm my_buffer, 500

movl $my_buffer, %ecx #将缓冲区地址加载到%ecx中

.globl _start
_start:

.type power, @function
power：
	……

call power

begin:
	.long 0

int fun1(int x1, int x2, int x3, int x4, int x5, int x6, int x7, int x8){
    int c = 10; 
    return x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + c;
}
println("fun1:" + fun1(1,2,3,4,5,6,7,8));

# function-call2-craft.s 函数调用和参数传递
    # 文本段,纯代码
    .section    __TEXT,__text,regular,pure_instructions
_fun1:
    # 函数调用的序曲,设置栈指针
    pushq   %rbp           # 把调用者的栈帧底部地址保存起来   
    movq    %rsp, %rbp     # 把调用者的栈帧顶部地址,设置为本栈帧的底部
    movl    $10, -4(%rbp)  # 变量c赋值为10,也可以写成 movl $10, (%rsp)
    # 做加法
    movl    %edi, %eax     # 第一个参数放进%eax
    addl    %esi, %eax     # 加参数2
    addl    %edx, %eax     # 加参数3
    addl    %ecx, %eax     # 加参数4
    addl    %r8d, %eax     # 加参数5
    addl    %r9d, %eax     # 加参数6
    addl    16(%rbp), %eax  # 加参数7
    addl    24(%rbp), %eax  # 加参数8
    
    addl    -4(%rbp), %eax # 加上c的值
    # 函数调用的尾声,恢复栈指针为原来的值
    popq    %rbp           # 恢复调用者栈帧的底部数值
    retq                   # 返回
    .globl  _main          # .global伪指令让_main函数外部可见
_main:                                  ## @main
    
    # 函数调用的序曲,设置栈指针
    pushq   %rbp           # 把调用者的栈帧底部地址保存起来  
    movq    %rsp, %rbp     # 把调用者的栈帧顶部地址,设置为本栈帧的底部
    
    subq    $16, %rsp      # 这里是为了让栈帧16字节对齐，实际使用可以更少
    # 设置参数
    movl    $1, %edi     # 参数1
    movl    $2, %esi     # 参数2
    movl    $3, %edx     # 参数3
    movl    $4, %ecx     # 参数4
    movl    $5, %r8d     # 参数5
    movl    $6, %r9d     # 参数6
    movl    $7, (%rsp)   # 参数7
    movl    $8, 8(%rsp)  # 参数8
    callq   _fun1                # 调用函数
    # 为pritf设置参数
    leaq    L_.str(%rip), %rdi   # 第一个参数是字符串的地址
    movl    %eax, %esi           # 第二个参数是前一个参数的返回值
    callq   _printf              # 调用函数
    # 设置返回值。这句也常用 xorl %esi, %esi 这样的指令,都是置为零
    movl    $0, %eax
    addq    $16, %rsp    # 缩小栈
    
    # 函数调用的尾声,恢复栈指针为原来的值
    popq    %rbp         # 恢复调用者栈帧的底部数值
    retq                 # 返回
    # 文本段,保存字符串字面量                                  
    .section    __TEXT,__cstring,cstring_literals
L_.str:                                 ## @.str
    .asciz  "fun1 :%d \n"

printf("The numer is %d"，88);

.section .data
test_string:
.ascii "The numer is %d\0"
.section .text

pushl $88
pushl $test_string
call printf
popl %eax
popl %eax

int my_global_var;
int foo()
{
    int my_local_var;
    
    my_local_var = 1;
    my_glocal_var = 2;
    
    return 0
}

.section .data
.lcomm my_globl_var, 4

.type foo, @function
foo:
	pushl %ebp #保存原栈基址
	movl %esp, %ebp #令栈指针指向新基址指针
	subl $4, %esp #为变量my_local_var保留空间
	.equ my_local_var, -4 #用my_local_var寻找局部变量
	
	movl $1, my_local_var(%ebp)
	movl $2, my_global_var
	
	movl %ebp, %esp #清除函数变量并返回
	popl %ebp
	ret

int global_data = 30;

.section .data
global_data:
	.long 30

p = &global_data;

movl $global_data, %eax

void foo()
{
    int a;
    int  *b;
    
    a = 30;
    
    b = &a;
    *b = 44;
}

foo:
#标准函数开头
	pushl %ebp
	movl %ebp,%esp
	
	#保留两个字的内存
	subl -8, %ebp
	.equ A_VAR, -4
	.equ B_VAR, -8
	
	#a = 30
	movl $30, A_VAL(%ebp)
	
	#b = &a
	movl $A_VAR, B_VAR(%ebp)
	addl %ebp, B_VAR(%ebp)
	
	#*b = 30
	movl B_VAR(%ebp), %eax  #B
	movl $30, (%eax)
	
#标准结束函数
	movl %ebp ,%esp
	popl %ebp
	ret

#b = &a
leal A_VAR(%ebp), %eax
movl %eax, B_VAR(%ebp)

struct person{
    char pristname[40];
    char lastname[40];
    int age
};

.equ PERSON_SIZE, 84
.equ PERSON_FIRSTNAME_OFFSET, 0
.equ PERSON_LASTNAME_OFFSET, 40
.equ PERSON_AGE_OFFSET, 80

void foo()
{
    struct person p;
    /**/
    ……
}

foo:
	#标准开头
	pushl %ebp
	movl %esp, %ebp
	
	#为局部变量分配空间
	subl $PERSON_SIZE, %esp 
	#这是变量相对于%ebp的偏移量
	.equ P_VAR, 0-PERSON_SIZE
	
	……
	#标准结束
	movl %ebp, %esp
	pop %ebp
	ret

p.age = 30;

movl $30, P_VAR + PERSON_AGE_OFFSET(%ebp)

while (a <　b){
    /*某些操作*/
}
/*结束循环*/

loop_begin:
	movl a, %eax
	movl b, %ebx
	cmpl %eax, %ebx
	jge loop_end
	
	loop_body:
	#某些操作
	jmp loop_begin
	
loop_end:
#结束循环

for (i = 0; i < 100; i++){
   /*某些操作*/
}

loop_initalize:
	movl 100,%ecx
loop_begin:
	#某些操作
	#递减%ecx，若%ecx不为0则继续循环
	loop loop_begin
	
rest_of_program:

if(a == b){
    /*真分支操作*/
}else{
    /*假分支操作*/
}
/*真假汇合*/

	#将a.b移入寄存器用于比较
    movl a, %eax
    movl b, %ebx

    #比较
    cmpl %eax, %ebx
    #跳转到真分支
    je true_branch
fale_branch: #非必要标签，只是为了说明这是假分支
#假分支代码

#跳到真假汇合
	jmp reconverge
true_branch：
	#真分支代码
reconverge:

float fun1(float a, float b){
    float c = 2.0;
    return a + b + c;
}