asm volatile(
     "汇编语句"
     : 输出部分
     : 输入部分
     : 会被修改的部分(clobbered register)
);

#include <stdio.h>
int main()
{
	int src = 1;
	int dst;   
	asm volatile(
        "movl %1, %0\n\t"
        "add $1, %0\n\t"
        "add $3, %0\n\t"
        : "=r" (dst) 
        : "r" (src)
        );

	printf("%d\n", dst);
}

__asm__ __volatile__("movl %1,%0" : "=r" (result) : "m" (input));

int main()
{
    int a=0,b=0,c=2,d=3,e=4,f=5,g=6,h=7,i=8,j=9,k=10,m=11;
    asm(
        "add %2,%0\n\t"
        "add %13,%1\n\t"
        :"+r"(a),"+r"(b),"+r"(c)
        :"r"(d),"r"(e),"r"(f),"r"(g),"r"(h),"r"(i),"r"(j),"r"(k),"r"(m)
    );//此处给出的输出参数三个都是可读可写的"+r"而不是只可写的"=r"，当调用参数的数字，超过输入参数数量的就用下几个（超过数量）可读的参数
//如此处都为"+r"，则%12就是a，%13就是b，%14就是c
    printf("a=%d,b=%d,c=%d,d=%d",a,b,c,d);
    return 0;
}

int main()
{
    int a=0,b=0,c=2,d=3,e=4,f=5,g=6,h=7,i=8,j=9,k=10,m=11;
    asm(
        "add %2,%0\n\t"
        "add %13,%1\n\t"
        :"=r"(a),"+r"(b),"+r"(c)
        :"r"(d),"r"(e),"r"(f),"r"(g),"r"(h),"r"(i),"r"(j),"r"(k),"r"(m)
    );//此处a为只写所以不可读,%12为b，%13为c，%14就超出调用范围了
    printf("a=%d,b=%d,c=%d,d=%d",a,b,c,d);
    return 0;
}

/*
a=5, b=3, c=2, d=3

asm(
    ".intel_syntax noprefix\n"
    "...\n"
);
/*
编译选项加 -masm=intel

asm volatile(
	".intel_syntax noprefix\n"
    "jz 1f\n"
    "jnz 1f\n"
    ".byte 0xE8\n"
    "1:\n\t"
);

asm volatile(
    ".intel_syntax noprefix\n\t"
    "push rbx\n\t"          // 64 位必须 rbx
    "xor ebx, ebx\n\t"      // 32 位子寄存器清零并零扩展 rbx
    "test ebx, ebx\n\t"
    "jnz 1f\n\t"
    "jz 2f\n\t"
    "1:\n\t"
    ".byte 0xE8\n\t"
    "2:\n\t"
    "pop rbx\n\t"
    ".att_syntax prefix\n\t"
    :
    :
    : "rbx", "cc", "memory"
);

 ; __unwind {
 F3 0F 1E FA                               endbr64
 55                                        push    rbp
 48 89 E5                                  mov     rbp, rsp
 48 83 EC 10                               sub     rsp, 10h
 64 48 8B 04 25 28 00 00 00                         mov     rax, fs:28h
 48 89 45 F8                               mov     [rbp+var_8], rax
 31 C0                                     xor     eax, eax
 C6 45 F7 C3                               mov     [rbp+var_9], 0C3h
 48 8D 45 F7                               lea     rax, [rbp+var_9]
 FF D0                                     call    rax
 C6 45 08 96                               mov     byte ptr [rbp+8], 96h
 C6 45 09 46                               mov     byte ptr [rbp+9], 46h ; 'F'
 C6 45 0A 40                               mov     byte ptr [rbp+0Ah], 40h ; '@'
 90                                        nop
 48 8B 45 F8                               mov     rax, [rbp+var_8]
 64 48 33 04 25 28 00 00 00                xor     rax, fs:28h
 74 05                                     jz      short locret_425EF0
 E8 90 B1 FD FF                            call    ___stack_chk_fail
 ; ---------------------------------------------------------------------------

locret_425EF0:                          ; CODE XREF: y0u_d0nt_n33d_to_r3verse_th1s(void)+3F↑j
 C9              						  leave
 C3             						  retn
 ; } // starts at 425EAA

asm volatile (
        ".intel_syntax noprefix\n"
        
        // 伪造指令序列：
        // 1. mov ax, 05EBh
        // 2. xor eax, eax
        // 3. jz -2
        
        // 实际执行序列：
        // 1. mov ax, 03EBh
        // 2. jmp short +5
        // 3. (跳转到真正的指令)
        
        // 构造字节序列：66 B8 EB 03 31 C0 74 FA E8
        
        "    .byte 0x66\n"   // 66: 操作数大小前缀，表示 mov ax
        "    .byte 0xB8\n"   // B8: mov reg, imm 的操作码
        "    .byte 0xEB\n"   // EB: mov ax 的立即数低位，同时是 jmp 的操作码
        "    .byte 0x05\n"   // 03: mov ax 的立即数高位，同时是 jmp 的偏移量
        
        "    .byte 0x31\n"   // 31: xor eax, eax 的操作码
        "    .byte 0xC0\n"   // C0: xor eax, eax 的 ModR/M 字节
        "    .byte 0x74\n"   // 74: jz 的操作码
        "    .byte 0xFA\n"   // FA: jz 的偏移量
        "    .byte 0xE8\n"   // E8: junk code

        "    .att_syntax\n"
    );