动机

考虑以下使用 x86_64 汇编的代码

unsafe fn f() -> u64 {
    let mut x = 20;
    asm!(
        ".macro mad x, y",
        "  mul x, y",
        "  lea x, [x + y]",
        ".endm",
        "mad {x}, 5",
        
        x = inout(reg) x
    );
    x
}

如果我们想在另一个函数中重用 mad，我们必须复制宏的原文并更改其名称。否则，我们将遇到由于名称冲突导致的编译错误。

unsafe fn f() -> u64 {
    let mut x = 20;
    asm!(
        ".macro mad x, y",
        "  mul x, y",
        "  lea x, [x + y]",
        ".endm",
        "mad {x}, 5",
        
        x = inout(reg) x
    );
    x
}

unsafe fn g() -> u64 {
    let mut x = 10;
    asm!(
        // Only compiles if we remove this macro definition
        // or rename it to another name
        ".macro mad x, y",
        "  mul x, y",
        "  lea x, [x + y]",
        ".endm",
        "mad {x}, 8",
        
        x = inout(reg) x
    );
    x
}

上述代码将失败

error: macro 'mad' is already defined

如果我们省略在 g(()) 中 mad 的定义，它将可以编译，但仅当 g(()) 在 f(()) 之后执行。不清楚哪个函数应该包含这个定义，因此唯一合理的选项是将它放在 global_asm! 代码中。但再次强调，很难保证定义的输出在真正使用之前。

在这种情况下，使用 Rust 宏是自然的，但由于 asm! 接受模板字符串，所以替换元变量变得繁琐。

macro_rules! mad {
    ($x: ident, $y: literal) => {
        concat!(
            "mul {", stringify!($x), "}, ", stringify!($y), "\n",
            "lea {", stringify!($x), "}, [{", stringify!($x), "}+", stringify!($y), "]"
        )
    };
}

unsafe fn f() -> u64 {
    let mut x = 20;
    asm!(
        mad!(x, 5),
        
        x = inout(reg) x
    );
    x
}

这种方法存在一些缺点

• 定义非常杂乱，使得阅读和理解变得困难。如果定义变长，情况会更糟，如果 rustfmt 尝试格式化它，那么就会更加糟糕。
• 当定义变长时，很容易忘记 , 和 \n。
• mad! 只能接受一个命名的寄存器作为第一个参数和一个字面量作为第二个参数。我们不能调用 mad!(x, rbx) 或 mad!([rax], rbp)，如果我们使用汇编宏，我们原本可以这样做。尝试通过将 ident 和 literal 改为 tt 来解决这个问题也是有问题，因为 stringify!({x}) 变为 "{ x }"，这是一个无效的占位符。

use asm_block::asm_block;

macro_rules! mad {
    ($x: tt, $y: tt) => {
        asm_block! {
            mul $x, $y;
            lea $x, [$x + $y];
        }
    };
}

#[rustfmt::skip::macros(mad)]
unsafe fn f() -> u64 {
    let mut x = 20;
    asm!(
        mad!({x}, 5),
        
        x = inout(reg) x
    );
    x
}