From ed9809e2c92ce5911c5d79a5c0f7df1ee8621e49 Mon Sep 17 00:00:00 2001
From: sunface <cto@188.com>
Date: Wed, 1 Mar 2023 13:32:26 +0800
Subject: [PATCH] add chapter inline-asm

---
 src/advance/unsafe/inline-asm.md | 151 +++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)

diff --git a/src/advance/unsafe/inline-asm.md b/src/advance/unsafe/inline-asm.md
index b35d9615..6c9d4931 100644
--- a/src/advance/unsafe/inline-asm.md
+++ b/src/advance/unsafe/inline-asm.md
@@ -1 +1,152 @@
 # 内联汇编
+
+Rust 提供了 `asm!` 宏，可以让大家在 Rust 代码中嵌入汇编代码，对于一些极致高性能或者底层的场景还是非常有用的，例如操作系统内核开发。但通常来说，大家并不应该在自己的项目中使用到该项技术，它为极客而生！
+
+本章的例子是基于 `x86/x86-64` 汇编的，但是其它架构也是支持的，目前支持的包括：
+
+- x86 和 x86-64
+- ARM
+- AArch64
+- RISC-V
+
+当使用在不支持的平台上时，编译器会给出报错。
+
+> 注意：本章节不负责教大家使用汇编，需要学习的同学请参考相关书籍 
+
+
+## 基本用法
+
+先从一个简单例子开始：
+
+```rust
+use std::arch::asm;
+
+unsafe {
+    asm!("nop");
+}
+```
+
+注意 `unsafe` 语句块依然是必不可少的，因为可能在里面插入危险的指令，最终破坏代码的安全性。
+
+上面代码将插入一个 `NOP` 指令( 空操作 ) 到编译器生成的汇编代码中，其中指令作为 `asn!` 的第一个参数传入。
+
+## 输入和输出
+
+上面的代码有够无聊的，来点实际的:
+
+```rust
+use std::arch::asm;
+
+let x: u64;
+unsafe {
+    asm!("mov {}, 5", out(reg) x);
+}
+assert_eq!(x, 5);
+```
+
+这段代码将 `5` 赋给 `u64` 类型的变量 `x`，值得注意的是 `asm!` 的指令参数实际上是一个格式化字符串。至于传给格式化字符串的参数，看起来还是比较陌生的:
+
+- 首先，需要说明目标变量是作为内联汇编的输入还是输出，在本例中，是一个输出 `out`
+- 最后，要指定变量将要使用的寄存器，本例中使用通用寄存器 `reg`，编译器会自动选择合适的寄存器
+
+```rust
+use std::arch::asm;
+
+let i: u64 = 3;
+let o: u64;
+unsafe {
+    asm!(
+        "mov {0}, {1}",
+        "add {0}, 5",
+        out(reg) o,
+        in(reg) i,
+    );
+}
+assert_eq!(o, 8);
+```
+
+上面的代码中进一步使用了输入 `in`，将 `5` 加到输入的变量 `i` 上，然后将结果写到输出变量 `o`。实际的操作方式是首先将 `i` 的值拷贝到输出，然后再加上 `5`。
+
+上例还能看出几点：
+
+- `asm!` 允许使用多个格式化字符串，每一个作为单独一行汇编代码存在，看起来跟阅读真实的汇编代码类似
+- 输入变通过 `in` 来声明
+- 和以前见过的格式化字符串一样，可以使用多个参数，通过 {0}, {1} 来指定，这种方式特别有用，毕竟在代码中，变量是经常复用的，而这种参数的指定方式刚好可以复用
+
+事实上，还可以进一步优化代码，去掉 `mov` 指令:
+
+```rust
+use std::arch::asm;
+
+let mut x: u64 = 3;
+unsafe {
+    asm!("add {0}, 5", inout(reg) x);
+}
+assert_eq!(x, 8);
+```
+
+又多出一个 `inout` 关键字，但是不难猜，它说明 `x` 即是输入又是输出。与之前的分离方式还有一点很大的区别，这种方式可以保证使用同一个寄存器来完成任务。
+
+当然，你可以在使用 `inout` 的情况下，指定不同的输入和输出:
+
+```rust
+use std::arch::asm;
+
+let x: u64 = 3;
+let y: u64;
+unsafe {
+    asm!("add {0}, 5", inout(reg) x => y);
+}
+assert_eq!(y, 8);
+```
+
+## 延迟输出操作符
+
+Rust 编译器对于操作数分配是较为保守的，它会假设 `out` 可以在任何时间被写入，因此 `out` 不会跟其它参数共享它的位置。然而为了保证最佳性能，使用尽量少的寄存器是有必要的，这样它们不必在内联汇编的代码块内保存和重加载。
+
+为了达成这个目标( 共享位置或者说寄存器，以实现减少寄存器使用的性能优化 )，Rust 提供一个 `lateout` 关键字，可以用于任何只在所有输入被消费后才被写入的输出，与之类似的还有一个 `inlateout`。
+
+但是 `inlateout` 在某些场景中是无法使用的，例如下面的例子：
+
+```rust
+use std::arch::asm;
+
+let mut a: u64 = 4;
+let b: u64 = 4;
+let c: u64 = 4;
+unsafe {
+    asm!(
+        "add {0}, {1}",
+        "add {0}, {2}",
+        inout(reg) a,
+        in(reg) b,
+        in(reg) c,
+    );
+}
+assert_eq!(a, 12);
+```
+
+一旦用了 `inlateout` 后，上面的代码就只能运行在 `Debug` 模式下，原因是 `Debug` 并没有做任何优化，但是 `release` 发布不同，为了性能是要做很多编译优化的。
+
+在编译优化时，编译器可以很容易的为输入 `b` 和 `c` 分配同样的是寄存器，因为它知道它们有同样的值。如果这里使用 `inlateout`， 那么 `a` 和 `c` 就可以被分配到相同的寄存器，在这种情况下，第一条指令将覆盖掉 `c` 的值，最终导致汇编代码产生错误的结果。
+
+因此这里使用 `inout`，那么编译器就会为 `a` 分配一个独立的寄存器.
+
+但是下面的代码又不同，它是可以使用 `inlateout` 的：
+
+```rust
+use std::arch::asm;
+
+let mut a: u64 = 4;
+let b: u64 = 4;
+unsafe {
+    asm!("add {0}, {1}", inlateout(reg) a, in(reg) b);
+}
+assert_eq!(a, 8);
+```
+
+原因在于输出只有在所有寄存器都被读取后，才被修改。因此，即使 `a` 和 `b` 被分配了同样的寄存器，代码也会正常工作，不存在之前的覆盖问题。
+
+## 显式指定寄存器
+
+