内联汇编 asm! ​

核心概念 ​

asm! 宏允许在 Rust 代码中直接嵌入汇编指令。这是 Rust 中最底层的操作方式——跳过编译器直接控制 CPU 的寄存器和指令。Rust 从 1.59 版本开始在稳定版中支持 asm! 宏(仅限 x86、x86_64、ARM、AArch64 和 RISC-V 架构)。

内联汇编主要用于以下场景:访问特殊的 CPU 指令(如 CPUID、RDTSC)、实现极致性能优化、操作系统内核开发、以及与硬件寄存器直接交互。对于大多数应用开发来说,几乎不需要使用内联汇编——Rust 编译器生成的代码已经足够好。

asm! 是 unsafe 的,因为编译器无法验证汇编指令的正确性。错误的汇编代码可能破坏栈、覆盖关键寄存器或违反调用约定。

rust
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! 的基本语法 ​

rust
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输出寄存器可与输入重叠

寄存器约束 ​

rust
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 示例说明
regrax, rbx, rcx...通用寄存器
reg_byteal, bl, cl...字节寄存器
xmm_regxmm0-xmm15SSE 寄存器
ymm_regymm0-ymm15AVX 寄存器
具名"rax", "rcx"特定寄存器

asm! 选项 ​

rust
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! 全局汇编 ​

rust
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);
}

实用示例 ​

rust
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);
}

基本示例 ​

一个综合的内联汇编工具库:

rust
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 编译器已经提供了等价或更好的方案。