内联汇编
内联汇编，顾名思义，一种语言的内部使用汇编，一般的语言是不能直接操作寄存器的，而汇编可以，所以在这种语言内部以某种方式嵌入汇编代码来提升能力，一般来说也就是 c/c 使用内联汇编比较多，本文用的 c 语言来叙述，废话不再多说，直接来看。
基本形式
代码语言：c复制//关键字的宏定义
#define __asm__ asm
#define __volatile__ volatile
//内敛汇编基本形式
asm [volatile] ("汇编代码/指令");asm 同 __asm__(两根下划线)，用来申明内联汇编表达式
volatile 同 __volatile__，可选项，它会告诉编译器不要优化代码，保持原样
汇编代码得好好说道说道，有着以下规则：
指令必须用双引号括起来，里面可以是一条指令也可以是多条指令甚至没有指令，多条指令的话需要用分割符隔开，一般就是用 ';'
代码语言：c复制asm (""); // ✔
asm ("movl $1, �x"); // ✔
asm ("movl $1, �x; pushl �x"); // ✔可以有多对双引号，里面有着一条或多条指令，成对双引号之间也需要隔开，最后一对双引号之间的最后一条指令后面不需要分隔符
代码语言：c复制asm ("movl $1, �x;""pushl �x"); // ✔一对双引号之间不能跨行，若要跨行，在结尾用 '' 转义
代码语言：c复制asm ("movl $1, �x;
pushl �x"); // ✔其实不论多少对双引号，编译器在处理的时候都要合并到一起，所以基本规则就是，指令在双引号之间，指令之间用分隔符隔开。这样说内联汇编的基本形式还是挺简单的吧，下面来看内联汇编最重要的扩展形式
扩展形式
代码语言：c复制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: 第二个浮点寄存器
看个简单例子：
代码语言：c复制int main()
{
int in_a = 1, in_b = 2;
int out_sum;
asm ("addl %�x, %�x":"=a"(out_sum):"a"(in_a),"b"(in_b));
printf("The result is %dn", 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" 了，表示使用系统支持的任何一种内存形式而不借助于寄存器，来看个例子：
代码语言：c复制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：表示浮点数
举个例子如下：
代码语言：c复制asm volatile ("movl %0, %�x"::"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 个变量使用相同的寄存器或内存。
同样的看个例子来理解：
代码语言：c复制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 中。
- ：表示操作数是可读可写的，相应的寄存器或内存先被读再被写入。
- &：表示该操作数要独占相应的寄存器。
"=" 前面每个例子基本都有，就不看了，来看个关于 " " 的例子：
代码语言：c复制int main()
{
int io_a = 1, in_b = 2;
asm("addl %�x, %�x":" 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 部分的格式：名称"约束"(变量)，在代码中引用的格式：%名称
看个例子：
代码语言：c复制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 指令用法：
代码语言：text复制in port, %al
in port, %ax
out %al, port
out %ax, portin 表示从端口 port 读取一个字节的数据到 al，或者从端口 port 读取一个字的数据到 ax，out 反着来。具体使用 al 还是 ax，是要看 port 对应的寄存器位宽。port 可以使用立即数的方式，范围为 0~255，也可以使用寄存器 dx 指定，此时范围 0~65535。
代码语言：c复制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 时停止
例子
联合内联汇编来看上述指令的例子：
代码语言：c复制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"。
代码语言：c复制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 指令实现的：
代码语言：c复制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 中几个典型的例子：
代码语言：c复制static inline uint readeflags(void) //返回eflags寄存器
{
uint eflags;
asm volatile("pushfl; popl %0" : "=r" (eflags));
return eflags;
}pushfl 压入eflags，popl弹出栈顶数据(eflags)到 %0 引用的通用寄存器 r。然后该寄存器的值再传给 eflags(变量)。
代码语言：c复制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 来绑定相同寄存器表读。
该内联汇编也可以如下来写：
代码语言：c复制 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 那个文件里面的函数，还有一些函数就没一一拿出来举例了，都类似或者更简单，把本文举出来的弄清楚，其他的应该没什么问题。
