内联汇编 asm!
核心概念
asm! 宏允许在 Rust 代码中直接嵌入汇编指令。这是 Rust 中最底层的操作方式——跳过编译器直接控制 CPU 的寄存器和指令。Rust 从 1.59 版本开始在稳定版中支持 asm! 宏(仅限 x86、x86_64、ARM、AArch64 和 RISC-V 架构)。
内联汇编主要用于以下场景:访问特殊的 CPU 指令(如 CPUID、RDTSC)、实现极致性能优化、操作系统内核开发、以及与硬件寄存器直接交互。对于大多数应用开发来说,几乎不需要使用内联汇编——Rust 编译器生成的代码已经足够好。
asm! 是 unsafe 的,因为编译器无法验证汇编指令的正确性。错误的汇编代码可能破坏栈、覆盖关键寄存器或违反调用约定。
use std::arch::asm;
fn main() {
// 最简单的内联汇编:空操作
// SAFETY: nop 不执行任何操作,不影响程序状态
unsafe {
asm!("nop");
}
println!("nop 执行完毕");
// 带输出的汇编:读取值
let result: u64;
// SAFETY: mov 只是将立即数加载到寄存器
unsafe {
asm!(
"mov {}, 42", // 将 42 放入输出寄存器
out(reg) result, // 将寄存器的值输出到 result
);
}
println!("汇编返回: {}", result);
}asm! 的基本语法
use std::arch::asm;
fn main() {
// asm! 的语法结构:
// asm!(
// "汇编指令模板",
// 操作数1,
// 操作数2,
// ...
// 选项
// )
// === 输入操作数 (in) ===
let x: u64 = 10;
let y: u64 = 20;
let sum: u64;
// SAFETY: add 指令不影响其他内存
unsafe {
asm!(
"add {0}, {1}", // {0} += {1}
inout(reg) x => sum, // x 作为输入,sum 接收输出
in(reg) y, // y 作为输入
);
}
println!("{} + {} = {}", x, y, sum);
// === 输出操作数 (out) ===
let value: u64;
unsafe {
asm!(
"mov {}, 100",
out(reg) value,
);
}
println!("输出: {}", value);
// === 输入输出操作数 (inout) ===
let mut num: u64 = 5;
unsafe {
asm!(
"add {0}, {0}", // num = num + num = num * 2
inout(reg) num,
);
}
println!("5 * 2 = {}", num);
// === 丢弃输出 (lateout / out(_)) ===
unsafe {
asm!(
"nop",
out(reg) _, // 占用一个寄存器但不关心输出
);
}
}| 操作数类型 | 语法 | 说明 |
|---|---|---|
| 输入 | in(reg) expr | 表达式的值传入寄存器 |
| 输出 | out(reg) var | 寄存器的值输出到变量 |
| 输入输出 | inout(reg) var | 变量既是输入又是输出 |
| 输入→输出 | inout(reg) in_expr => out_var | 输入和输出用不同变量 |
| 丢弃输出 | out(reg) _ | 寄存器被使用但不输出 |
| 延迟输出 | lateout(reg) var | 输出寄存器可与输入重叠 |
寄存器约束
use std::arch::asm;
fn main() {
// === reg:通用寄存器 ===
let a: u64 = 3;
let b: u64 = 7;
let result: u64;
unsafe {
asm!(
"imul {0}, {1}",
inout(reg) a => result,
in(reg) b,
);
}
println!("3 * 7 = {}", result);
// === 具名寄存器:指定特定寄存器 ===
// 某些指令要求使用特定寄存器
let input: u64 = 42;
let output: u64;
unsafe {
asm!(
"mov rax, {input}", // 将 input 放入 rax
"add rax, 8", // rax += 8
"mov {output}, rax", // 将 rax 复制到 output
input = in(reg) input,
output = out(reg) output,
out("rax") _, // 声明 rax 被使用(clobber)
);
}
println!("42 + 8 = {}", output);
// === 命名操作数 ===
let x: u64 = 100;
let y: u64 = 50;
let diff: u64;
unsafe {
asm!(
"mov {result}, {x}",
"sub {result}, {y}",
x = in(reg) x,
y = in(reg) y,
result = out(reg) diff,
);
}
println!("100 - 50 = {}", diff);
}| 寄存器类 | x86_64 示例 | 说明 |
|---|---|---|
reg | rax, rbx, rcx... | 通用寄存器 |
reg_byte | al, bl, cl... | 字节寄存器 |
xmm_reg | xmm0-xmm15 | SSE 寄存器 |
ymm_reg | ymm0-ymm15 | AVX 寄存器 |
| 具名 | "rax", "rcx" | 特定寄存器 |
asm! 选项
use std::arch::asm;
fn main() {
// === nomem:汇编不读写内存 ===
// 告诉编译器可以自由重排内存操作
let a: u64 = 10;
let b: u64;
unsafe {
asm!(
"mov {}, {}",
out(reg) b,
in(reg) a,
options(nomem, nostack),
);
}
println!("nomem: {}", b);
// === nostack:汇编不使用栈 ===
// 告诉编译器不需要调整栈指针
unsafe {
asm!("nop", options(nostack));
}
// === pure:汇编是纯函数(无副作用)===
// 必须与 nomem 或 readonly 一起使用
let x: u64 = 5;
let doubled: u64;
unsafe {
asm!(
"lea {}, [{} + {} * 2]", // doubled = x + x = 2x(利用 lea 技巧)
out(reg) doubled,
in(reg) x,
in(reg) x,
options(pure, nomem, nostack),
);
}
println!("pure: 5 * 2 = {}", doubled);
// === preserves_flags:汇编不修改标志寄存器 ===
unsafe {
asm!("nop", options(preserves_flags, nostack));
}
// === att_syntax:使用 AT&T 语法(默认是 Intel 语法)===
let val: u64;
unsafe {
asm!(
"movq $42, {0}",
out(reg) val,
options(att_syntax, nostack),
);
}
println!("AT&T 语法: {}", val);
}| 选项 | 效果 |
|---|---|
nomem | 声明不读写内存 |
readonly | 声明只读内存 |
nostack | 声明不使用栈 |
pure | 声明无副作用(需配合 nomem/readonly) |
preserves_flags | 声明不修改标志寄存器 |
att_syntax | 使用 AT&T 语法 |
raw | 不转义模板字符串 |
global_asm! 全局汇编
use std::arch::global_asm;
// global_asm! 在函数外部使用,定义全局汇编
// 可以用来定义完整的汇编函数
// 定义一个汇编函数
global_asm!(
".global asm_add",
"asm_add:",
"lea rax, [rcx + rdx]", // Windows x64: 参数在 rcx, rdx
"ret",
);
// 声明外部函数以在 Rust 中调用
extern "C" {
fn asm_add(a: u64, b: u64) -> u64;
}
fn main() {
// SAFETY: asm_add 是我们自己定义的简单加法函数
let result = unsafe { asm_add(10, 20) };
println!("asm_add(10, 20) = {}", result);
}实用示例
use std::arch::asm;
/// 使用 RDTSC 读取时间戳计数器
fn read_tsc() -> u64 {
let lo: u32;
let hi: u32;
// SAFETY: rdtsc 读取时间戳,不修改其他状态
unsafe {
asm!(
"rdtsc",
out("eax") lo,
out("edx") hi,
options(nostack, nomem),
);
}
((hi as u64) << 32) | (lo as u64)
}
/// 使用 CPUID 获取 CPU 信息
fn cpuid(leaf: u32) -> (u32, u32, u32, u32) {
let eax: u32;
let ebx: u32;
let ecx: u32;
let edx: u32;
// SAFETY: cpuid 是只读查询指令
unsafe {
asm!(
"cpuid",
inout("eax") leaf => eax,
out("ebx") ebx,
inout("ecx") 0_u32 => ecx,
out("edx") edx,
options(nostack),
);
}
(eax, ebx, ecx, edx)
}
/// 获取 CPU 厂商字符串
fn cpu_vendor() -> String {
let (_, ebx, ecx, edx) = cpuid(0);
let mut vendor = [0u8; 12];
vendor[0..4].copy_from_slice(&ebx.to_le_bytes());
vendor[4..8].copy_from_slice(&edx.to_le_bytes());
vendor[8..12].copy_from_slice(&ecx.to_le_bytes());
String::from_utf8_lossy(&vendor).to_string()
}
/// 使用位操作指令计算前导零
fn count_leading_zeros(x: u64) -> u32 {
if x == 0 {
return 64;
}
let result: u64;
// SAFETY: lzcnt 是安全的位操作指令
unsafe {
asm!(
"lzcnt {}, {}",
out(reg) result,
in(reg) x,
options(nostack, nomem, pure),
);
}
result as u32
}
/// 使用 POPCNT 计算置位数
fn popcount(x: u64) -> u32 {
let result: u64;
// SAFETY: popcnt 是安全的位操作指令
unsafe {
asm!(
"popcnt {}, {}",
out(reg) result,
in(reg) x,
options(nostack, nomem, pure),
);
}
result as u32
}
/// 使用 BSF 找到最低位的 1
fn find_lowest_bit(x: u64) -> Option<u32> {
if x == 0 {
return None;
}
let result: u64;
// SAFETY: bsf 在输入非零时安全
unsafe {
asm!(
"bsf {}, {}",
out(reg) result,
in(reg) x,
options(nostack, nomem),
);
}
Some(result as u32)
}
fn main() {
// TSC 时间戳
println!("=== 时间戳计数器 ===");
let t1 = read_tsc();
let t2 = read_tsc();
println!("TSC: {} → {} (差: {} 周期)", t1, t2, t2 - t1);
// CPUID
println!("\n=== CPU 信息 ===");
println!("厂商: {}", cpu_vendor());
let (max_leaf, _, _, _) = cpuid(0);
println!("最大 CPUID leaf: {}", max_leaf);
// 位操作
println!("\n=== 位操作 ===");
let test_values: Vec<u64> = vec![0, 1, 0xFF, 0x8000_0000_0000_0000, u64::MAX];
for &v in &test_values {
println!(" 0x{:016X}:", v);
println!(" 前导零: {}", count_leading_zeros(v));
println!(" 置位数: {}", popcount(v));
println!(" 最低位: {:?}", find_lowest_bit(v));
}
// 性能测试
println!("\n=== 简单计时 ===");
let start = read_tsc();
let mut sum = 0u64;
for i in 0..1000 {
sum += i;
}
let end = read_tsc();
println!("1000 次循环求和: {} (耗时 {} 周期)", sum, end - start);
}基本示例
一个综合的内联汇编工具库:
use std::arch::asm;
/// 汇编级别的内存屏障
fn memory_barrier() {
// SAFETY: mfence 是内存屏障指令,不修改数据
unsafe {
asm!("mfence", options(nostack));
}
}
/// 暂停指令(用于自旋等待循环)
fn spin_hint() {
// SAFETY: pause 只是降低功耗的提示
unsafe {
asm!("pause", options(nostack, nomem));
}
}
/// 用汇编实现快速的绝对值(i64)
fn fast_abs(x: i64) -> i64 {
let result: i64;
// SAFETY: 纯数学运算
unsafe {
asm!(
"mov {tmp}, {x}",
"sar {tmp}, 63", // 算术右移 63 位:负数→全1,正数→全0
"xor {x}, {tmp}", // 负数翻转所有位,正数不变
"sub {x}, {tmp}", // 负数 +1(补码取反+1=取绝对值)
x = inout(reg) x => result,
tmp = out(reg) _,
options(nostack, nomem, pure),
);
}
result
}
/// 用汇编实现字节交换(大小端转换)
fn byte_swap_u32(x: u32) -> u32 {
let result: u32;
// SAFETY: bswap 是安全的位操作
unsafe {
asm!(
"bswap {0:e}", // :e 表示 32 位寄存器名
inout(reg) x => result,
options(nostack, nomem, pure),
);
}
result
}
/// 用汇编实现 64 位字节交换
fn byte_swap_u64(x: u64) -> u64 {
let result: u64;
unsafe {
asm!(
"bswap {}",
inout(reg) x => result,
options(nostack, nomem, pure),
);
}
result
}
/// 使用 CRC32 指令(需要 SSE4.2)
fn crc32_byte(crc: u32, byte: u8) -> u32 {
let result: u32;
unsafe {
asm!(
"crc32 {crc:e}, {byte:l}",
crc = inout(reg) crc => result,
byte = in(reg_byte) byte,
options(nostack, nomem, pure),
);
}
result
}
/// 简单的 CRC32 校验
fn crc32_slice(data: &[u8]) -> u32 {
let mut crc = 0xFFFF_FFFFu32;
for &byte in data {
crc = crc32_byte(crc, byte);
}
crc ^ 0xFFFF_FFFF
}
fn main() {
// 绝对值
println!("=== 快速绝对值 ===");
let values = [-42i64, 0, 42, i64::MIN + 1, i64::MAX];
for &v in &values {
println!(" abs({}) = {}", v, fast_abs(v));
}
// 字节交换
println!("\n=== 字节交换 ===");
let u32_val = 0x12345678u32;
println!(" u32 0x{:08X} → 0x{:08X}", u32_val, byte_swap_u32(u32_val));
let u64_val = 0x0102030405060708u64;
println!(" u64 0x{:016X} → 0x{:016X}", u64_val, byte_swap_u64(u64_val));
// CRC32
println!("\n=== CRC32 ===");
let data1 = b"Hello, World!";
let data2 = b"Hello, World?";
println!(" \"Hello, World!\" CRC32: 0x{:08X}", crc32_slice(data1));
println!(" \"Hello, World?\" CRC32: 0x{:08X}", crc32_slice(data2));
// 相同数据的 CRC 一致
println!(" 一致性: {}", crc32_slice(data1) == crc32_slice(data1));
// 内存屏障和自旋提示
println!("\n=== 屏障和提示 ===");
memory_barrier();
println!(" 内存屏障执行完毕");
spin_hint();
println!(" 自旋提示执行完毕");
// 与标准库的对比
println!("\n=== 标准库对比 ===");
println!(" abs(-42): asm={}, std={}", fast_abs(-42), (-42_i64).abs());
println!(" bswap32: asm=0x{:08X}, std=0x{:08X}",
byte_swap_u32(0x12345678), 0x12345678u32.swap_bytes());
println!(" bswap64: asm=0x{:016X}, std=0x{:016X}",
byte_swap_u64(0x0102030405060708), 0x0102030405060708u64.swap_bytes());
}常见问题
问题一:什么时候需要用内联汇编?
极少数场景:访问特殊 CPU 指令(CPUID、RDTSC、CRC32 等)、内核开发中的中断/系统调用、极致性能优化(编译器做不到的指令选择)、以及特定硬件寄存器访问。普通应用开发几乎不需要。
问题二:asm! 在不同平台上通用吗?
不通用。汇编是平台特定的——x86_64 的汇编不能在 ARM 上运行。需要用 #[cfg(target_arch = "x86_64")] 等条件编译来处理不同平台。Rust 的 asm! 在 x86/x86_64 上默认使用 Intel 语法。
问题三:编译器能优化 asm! 中的代码吗?
不能。编译器把 asm! 中的汇编当作"黑盒"。但通过 options(pure, nomem) 等选项,编译器可以了解汇编的副作用特征,从而对周围的 Rust 代码做更好的优化(如消除冗余的内存加载)。
问题四:为什么 asm! 是 unsafe 的?
编译器无法验证汇编指令的正确性。错误的汇编可能破坏栈帧、覆盖被调用者保存的寄存器、违反调用约定,或写入任意内存地址。这些都是安全的 Rust 代码不可能做到的事情。
适用场景
- CPU 特性检测:CPUID 查询
- 性能计数:RDTSC 读取时钟周期
- 硬件加速:CRC32、AES-NI 等硬件指令
- 操作系统开发:系统调用、中断处理
- 内存屏障:多核同步的 fence 指令
注意事项
asm!是 unsafe 的,必须在 unsafe 块中使用- 汇编是平台特定的,不可移植
- 必须正确声明所有被修改的寄存器(clobber)
- 使用
options告知编译器汇编的副作用特征 - 默认使用 Intel 语法,可通过
att_syntax切换 global_asm!用于定义完整的汇编函数- 优先使用 Rust 标准库的跨平台方案(如
swap_bytes)
总结
asm! 宏允许在 Rust 中嵌入汇编指令,是最底层的操作方式。它使用模板字符串加操作数的语法,支持 in(输入)、out(输出)、inout(输入输出)等操作数类型,以及 nomem、nostack、pure 等选项来描述副作用。汇编是平台特定的,x86_64 上默认使用 Intel 语法。global_asm! 用于定义全局汇编函数。asm! 是 unsafe 的,因为编译器无法验证汇编代码的正确性。实际使用中极少需要内联汇编——它主要用于访问特殊 CPU 指令(CPUID、RDTSC)、操作系统内核开发和极致性能优化。大多数情况下,Rust 标准库和 LLVM 编译器已经提供了等价或更好的方案。