内联汇编

内联汇编，顾名思义，一种语言的内部使用汇编，一般的语言是不能直接操作寄存器的，而汇编可以，所以在这种语言内部以某种方式嵌入汇编代码来提升能力，一般来说也就是 c/c++ 使用内联汇编比较多，本文用的 c 语言来叙述，废话不再多说，直接来看。

基本形式

//关键字的宏定义
#define __asm__ asm
#define __volatile__ volatile
//内敛汇编基本形式
asm [volatile] ("汇编代码/指令");

asm 同 __asm__(两根下划线)，用来申明内联汇编表达式

volatile 同 __volatile__，可选项，它会告诉编译器不要优化代码，保持原样

汇编代码得好好说道说道，有着以下规则：

指令必须用双引号括起来，里面可以是一条指令也可以是多条指令甚至没有指令，多条指令的话需要用分割符隔开，一般就是用 ';'

asm ("");   // ✔
asm ("movl $1, %eax");   // ✔
asm ("movl $1, %eax; pushl %eax");   // ✔

可以有多对双引号，里面有着一条或多条指令，成对双引号之间也需要隔开，最后一对双引号之间的最后一条指令后面不需要分隔符

asm ("movl $1, %eax;""pushl %eax");   // ✔

一对双引号之间不能跨行，若要跨行，在结尾用 '\' 转义

asm ("movl $1, %eax;   \
      pushl %eax");          // ✔

其实不论多少对双引号，编译器在处理的时候都要合并到一起，所以基本规则就是，指令在双引号之间，指令之间用分隔符隔开。这样说内联汇编的基本形式还是挺简单的吧，下面来看内联汇编最重要的扩展形式

扩展形式

asm [volatile] ("Instruction list":Output:Input:Clobber/Modify)

扩展形式多了三部分，其中每部分都可以省略，假设前面部分省略为空，如果后面部分非空，则这个后面部分前面的冒号不能省略，如果后面部分也省略为空，那么前面的冒号可省略。比如说 Output 和 Input 部分为空，Clobber/Modify 部分非空，那么 Output 和 Input 前面的冒号不能省略，反之则能省略，退变成基本形式。冒号省略与否的问题主要是给编译器看的，要让编译器分清楚哪部分属于哪部分。

基本形式的寄存器前面只有一个 %，而扩展形式的寄存器需要使用两个 %%，这是因为扩展性是经常使用占位符，使用一个 % 后面跟上数字或名称来表示占位符，后面再详述。

Output

格式："约束"(c 变量名)

上面的引号和圆括号都是必须的，不是文章中的特殊标识。上面的意思就是说汇编指令的结果按照某种约束/方式传给 c 变量。具体的约束形式后面详述。

变量名可能有多个，则用下面的形式："约束1"(c 变量1), "约束2"(c 变量2) ...

Input

格式："约束"(c 变量名)

意为某 c 中的数据按照某种约束输入给汇编使用，一般就是将某 c 变量传给某个寄存器。有关多个变量的情况写法同 Output，具体的约束也后面详述。

另外内联汇编的用法挺多，上面所写的格式可能不太准确但也没什么错，因为最主要的用法就是使用约束将 c 中的变量和寄存器联系起来。

Clobber/Modify

指定此项会通知编译器可能会破坏寄存器/内存里面的数据，然后编译器就会将这些可能被破坏的内存和寄存器提前保护起来。

• 若改变了寄存器 ebx 就可以申明 "bx"，bl，ebx 都行，都代表的是一个寄存器，其他的寄存器同样如此申明
• 若改变了 eflags 寄存器，可以申明 "cc"
• 若改变了内存，可以申明 "memory"

一般的，如果在 Output 和 Input 部分指定了寄存器约束，那么编译器一定知道该寄存器被改变了，那么就不用申明。

操作约束

寄存器约束

寄存器约束就是要求编译器使用哪个寄存器，将 Output 和 Input 的变量约束到哪个寄存器。常见的寄存器约束如下：

• a: eax/ax/al；b: ebx/bx/bl；c: ecx/cx/cl；d: edx/dx/dl
• D: edi/di；S: esi/si
• r: eax/ebx/ecx/edx/esi/edi 之一；q: eax/ebx/ecx/edx 之一
• f: 浮点寄存器；t: 第一个浮点寄存器；u: 第二个浮点寄存器

看个简单例子：

int main()
{
   
    int in_a = 1, in_b = 2;
    int out_sum;

    asm ("addl %%ebx, %%eax":"=a"(out_sum):"a"(in_a),"b"(in_b));
    printf("The result is %d\n", out_sum);
}
//The result is 3.

这是一个简单的用汇编写的加法程序，输入 in_a = 1, in_b = 2，输出和 out_sum = 3，是用指令 addl 实现的，来具体分析分析：

• "=a"(out_sum) 表示 out_sum 是只写的，也就是 out_sum = xx，返回值一般存放在 eax，这个值再传给 c 变量 out_sum。
• "a"(in_a) 表示 in_a 的值传给寄存器 eax，"b"(in_b) 表示 in_b 的值传给寄存器 ebx

这里 output 和 input 部分使用了同一个约束 "a"，这会造成混乱吗？不会，因为照着逻辑走一遍程序，in_a 的值传给 eax，in_b 的值传给 ebx，算出来的结果还是放在 eax，再将其中的结果传给 out_sum，所以不会造成混乱数据出错的情况。

内存约束

内存约束是将 c 变量的地址作为汇编代码的操作数，不需要寄存器作为中转，直接进行内存读写。

主要的内存约束就是 "m" 了，表示使用系统支持的任何一种内存形式而不借助于寄存器，来看个例子：

int main()
{
   
    int in_a = 1, in_b = 2;
    asm("movl %0, %1"::"a"(in_a),"m"(in_b));
    printf("in_a is %d, in_b is %d.\n", in_a, in_b);
    //in_a is 1, in_b is 1.

    in_a = 1; in_b = 2;
    asm("movl %0, %1"::"a"(in_a),"b"(in_b));
    printf("in_a is %d, in_b is %d.\n", in_a, in_b);
    //in_a is 1, in_b is 2.

    in_a = 1; in_b = 2;
    int out_a, out_b;
    asm("movl %0, %1":"=a"(out_a),"=b"(out_b):"a"(in_a),"b"(in_b));
    printf("in_a is %d, in_b is %d, out_a is %d, out_b is %d.\n", in_a, in_b, out_a, out_b);
    //in_a is 1, in_b is 2, out_a is 1, out_b is 1.
}

第一个例子和第二个例子结合起来看，%0 和 %1 为占位符，分别引用 in_a 和 in_b。

第一个例子中 in_b 使用的内存约束，所以 movl 操作直接操作的是 in_b 所在的内存，将 eax 的值移到 in_b 所在的内存，所以 in_b 本身的值变成 1。

第二个例子中 in_b 也是用的寄存器约束，所以 movl 操作的是寄存器 eax, ebx，将 eax 的值移到 ebx，但 in_b 所在的内存不受影响，所以本身的值不变还是 2。

第三个例子在第二个例子上增加 Output 部分，将寄存器的值输出，会发现寄存器的值变了，这个例子只是作为对照来看。从上面几个例子来看，会发现寄存器约束和值传递类似，内存约束和传指针类似。

立即数约束

立即数在 c 中只能作为右值，所以这只属于 Input 部分。立即数约束在传值的时候不需要借助内存和寄存器，主要约束如下：

• i：表示整数
• F：表示浮点数

举个例子如下：

asm volatile ("movl %0, %%eax"::"i"(100));

%0 就是占位符，使用一个 % 其后跟 0 表示引用第 0 个操作数，在这里就是立即数 \$100，也就是说这里的 %0 就表示 \$100。而这里的 100 通过 i 来约束表整数。

CPU 能够直接使用的数据就存放在三个地点，寄存器中，内存中，还有指令中的立即数，这就与三种约束对应起来。c 代码和汇编代码要建立联系，要交互，就要传输数据，数据存放地儿就那三个，所以就有了这三种约束。

通用约束

”0，1，2，3，4，5，6，7，8，9“，也只用在 Input 部分，表示与 Output 和 Input 中第 n 个变量使用相同的寄存器或内存。

同样的看个例子来理解：

int main()
{
   
    int in_a = 1, in_b = 2;
    int out_sum;
    asm("addl %1, %0":"=a"(out_sum):"b"(in_b),"0"(in_a));
    printf("The result is %d.\n", out_sum);
}

同样的加法程序，只是这里的输入部分的 in_a 使用的是通用约束 "0" ，表示分配给 in_a 的寄存器跟第 0 个(out_sum) 使用相同的寄存器 eax。

修饰符

• =：表示操作数是只写的，一般存在 Output 中。
• +：表示操作数是可读可写的，相应的寄存器或内存先被读再被写入。
• &：表示该操作数要独占相应的寄存器。

"=" 前面每个例子基本都有，就不看了，来看个关于 "+" 的例子：

int main()
{
   
    int io_a = 1, in_b = 2;
    asm("addl %%ebx, %%eax":"+a"(io_a):"b"(in_b));
    printf("The result is %d.\n", io_a);
    //The result is 3.
}

这个例子就表示 io_a 既是输入对象，又是输出对象，所以省略了 io_a 在 Input 部分的申明。io_a 先被当作输入对象读入，汇编代码运算出结果后又被当作输出对象输出。

占位符

占位符前面已经用过很多次了，这里再具体看看，占位符可以分为两种：序号占位符，名称占位符

序号占位符

对 Output 和 Input 部分出现的操作数从左往右依次从 0~9 编号，然后在汇编代码部分使用 %0~9 来引用。这里的占位符用一个 % 来表示，所以汇编代码直接使用寄存器的话需要用 %% 来表示。

名称占位符

名称占位符，顾名思义，不适用序号，而是给操作数取个名字。

在 Output 和 Input 部分的格式：[名称]"约束"(变量)，在代码中引用的格式：%[名称]

看个例子：

int main()
{
   
    int io_a = 1, in_b = 2;
    asm ("addl %[inb], %[out]":[out]"=a"(out_sum):"0"(in_a),[inb]"b"(in_b));
    printf("The result is %d.\n", io_a);
    //The result is 3.
}

应该很简单就不解释了，与序号占位符没多大区别，只是没有顺序要求，而是使用名称来定位。

xv6

本文的剩余部分来解决 xv6 中涉及内联汇编的部分，顺带讲述一些相关指令的用法

in, out

in 指令用法：

in port, %al
in port, %ax
out %al, port
out %ax, port

in 表示从端口 port 读取一个字节的数据到 al，或者从端口 port 读取一个字的数据到 ax，out 反着来。具体使用 al 还是 ax，是要看 port 对应的寄存器位宽。port 可以使用立即数的方式，范围为 0~255，也可以使用寄存器 dx 指定，此时范围 0~65535。

static inline uchar inb(ushort port)   //从端口port读入一个字节
{
   
  uchar data;      //一字节的数据

  asm volatile("in %1, %0" : "=a" (data) : "d" (port)); //port输入部分，指出端口，data输出部分,作为返回值
  return data;
}

字符串操作指令

先说两个寄存器，esi：源变址寄存器，edi：目的变址寄存器，字符串操作的过程中，esi 作为源地址，edi 作为目的地址。其实还应指定段寄存器，但是由于平坦模式的存在，两个段的段基址都为 0，所以就是 esi 作为源地址，edi 作为目的地址。

常见的字符串操作指令如下：

movs，把 esi 指向的内存数据复制到 edi 指向的内存单元处。

ins：从端口 dx 读入的数据存放到 edi 指向的内存单元处，outs：esi 指向的内存数据送到端口 dx 中去

lods：将 esi 指向的内存数据送到 al/ax/eax 中去，stos：将 al/ax/eax 中的数据送到 edi 指向的内存单元

以上指令通常配合 rep 重复指令一起使用，每次执行完后，根据 eflags 寄存器的 DF 位修改 esi 和 edi 的值

cld, std

cld 指令，将 eflags 寄存器的 DF 位清零，在字符串操作中使变址寄存器 ESI 或 EDI 的值自动增加，字符串从前往后处理，增加的具体数字依每次执行操作的字节数而定。std 指令与 cld 相反。

rep

重复，循环指令，循环次数为 ecx 存放的值，当 ecx 减到 0 时停止

例子

联合内联汇编来看上述指令的例子：

static inline void
insl(int port, void *addr, int cnt)  //从端口port读4*cnt个字节到地址addr
{
    
  asm volatile("cld; rep insl" :                    //清零 DF 位，重复指令 insl
               "=D" (addr), "=c" (cnt) :            //addr目的地址绑定寄存器edi，cnt循环次数绑定ecx
               "d" (port), "0" (addr), "1" (cnt) :  //port端口绑定dx，addr,cnt同上
               "memory", "cc");                     //改变了内存，改变了eflags寄存器
}

重复执行 insl 指令来读取多个字节的数据到目的地址，具体操作顺序是先读目的地址和循环次数，insl 每次执行后再更新 addr，cnt 的值，所以 addr 和 cnt 是又读又写的，因此 Output 和 Input 部分都存在 addr 和 cnt。期间改变了内存和 eflags 寄存器，所以内联汇编的最后一部分申明 "cc" 和 "memory"。

static inline void stosb(void *addr, int data, int cnt)  //stos指令是将eax中的数据送到地址addr去
{
   
  asm volatile("cld; rep stosb" :                    //清零DF，重复指令stosb
               "=D" (addr), "=c" (cnt) :             //addr目的地址绑定寄存器edi，cnt循环次数绑定ecx
               "0" (addr), "1" (cnt), "a" (data) :   //addr，cnt同上，data为输入数据传给寄存器eax
               "memory", "cc");                      //改变了内存，改变了eflags寄存器
}

重复 stosb 指令，每次将传到寄存器 eax 的数据传送 1 字节到 addr 处，每次执行完后更新 addr 和 cnt 的值。其他的基本同上，就不赘述了。

来看 xv6 字符串函数 memset，就是用 stos 指令实现的：

void* memset(void *dst, int c, uint n)  //将从地址dst开始的n个字节设置为c
{
   
  if ((int)dst%4 == 0 && n%4 == 0){
       //如果以 4 字节对齐，可以使用stosl的封装函数，每次传送4字节，重复n/4次
    c &= 0xFF;
    stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);   
  } else                        //否则就是用stosb的封装函数，每次只传送1字节，重复n次
    stosb(dst, c, n);
  return dst;
}

回到内联汇编上来，再来看 xv6 中几个典型的例子：

static inline uint readeflags(void)  //返回eflags寄存器
{
   
  uint eflags;
  asm volatile("pushfl; popl %0" : "=r" (eflags));  
  return eflags;
}

pushfl 压入eflags，popl弹出栈顶数据(eflags)到 %0 引用的通用寄存器 r。然后该寄存器的值再传给 eflags(变量)。

static inline uint xchg(volatile uint *addr, uint newval)   //交换*addr和newval，返回*addr
{
   
  uint result;

  // The + in "+m" denotes a read-modify-write operand.
  asm volatile("lock; xchgl %0, %1" :
               "+m" (*addr), "=a" (result) :
               "1" (newval) :
               "cc");
  return result;
}

先来说说指令，lock 是一个前缀指令，它会将后面的指令变成原子指令，原子性懂吧不解释了。

xchg 指令交换两个操作数的值，至少有一个操作数的指令为寄存器。

因此上面的内联汇编中 addr 使用了内存约束， result 就必须使用寄存器约束了，\addr 和 newval 都是既读又写的，*addr 就直接使用修饰符 "+" 来表示了，所以在 Input 部分不用再出现 *addr，而 result 使用寄存器约束，用 "=" 来修饰表写，所以 Input 部分还需要 newval 来绑定相同寄存器表读。

该内联汇编也可以如下来写：

  uint result = newval;
  asm volatile("lock; xchgl %0, %1" :
               "+m" (*addr), "+a" (result) ::
               "cc");
  return result;

将两者都变成用 "+" 来修饰，如此 Input 部分便不用再申明，已经测试，效果是一样的。

xchg 这个指令的确是将两个操作数的值呼唤，但是封装的这个 uint xchg(volatile uint *addr, uint newval) 函数并不是将两者之间互换，而是一个单纯的原子性的赋值函数 *addr = newval。为啥？不是用了 xchg 指令吗？原因就在于一个用的内存约束，直接修改的内存，所以值发生变化，而另一个使用寄存器约束，使用 xchg 指令只是使该寄存器的值改变了，但并没有实际改变 newval 的值，就跟写 switch 函数的时候用值传递并不会实际交换一样的道理。

好啦，本文到这儿就结束了，本文主要讲述了内联汇编和一些指令的使用。然后解决了 xv6 里面一些用内联汇编实现的功能函数，也就是 x86.h 那个文件里面的函数，还有一些函数就没一一拿出来举例了，都类似或者更简单，把本文举出来的弄清楚，其他的应该没什么问题。