inline assembly in rust

Rust provides a way to write inline assembly using the asm! macro.

Here's an example of how to write an inline assembly block to add two numbers:

main.rs
fn add_numbers(a: u32, b: u32) -> u32 {
    let result: u32;
    unsafe {
        asm!("add $2, $1
             mov $1, $0"
             : "=r"(result) // output
             : "r"(a), "r"(b) // inputs
             : // no clobbers
             : "volatile"); // prevents the compiler from moving code across asm!() boundaries
    }
    result
}
346 chars
13 lines

In this example, we define a function add_numbers that takes two u32 integers as input and returns their sum as an output.

We use the unsafe block since inline assembly can lead to undefined behaviour, and we want to make sure that the code is safe.

Inside the asm! macro, we specify the assembly instructions. In this case, we use the add instruction to add the two numbers and the mov instruction to move the result into the output register.

The : "=r"(result) line specifies the output register (r) for the result. The : "r"(a), "r"(b) line specifies the input registers for a and b.

The : // no clobbers line specifies that we do not use any registers that could be used elsewhere in the code.

The : "volatile" line prevents the compiler from moving code across asm!() boundaries, which could cause the code to behave in unexpected ways due to register clobbering or other side effects.

Note: the syntax for the assembly code may differ based on the targeted CPU architecture. This example is for an x86 architecture.