Rust
Inline Montering

Syntax

• #! [funktion (asm)] // Aktivera asm! makrofunktionsgrind
• asm! (<template>: <output>: <input>: <clobbers>: <options>) // Avge den medföljande monteringsmallen (t.ex. "NOP", "ADD% eax, 4") med de angivna alternativen.

Asmen! makro

Inline-montering stöds endast i nattliga versioner av Rust tills det är stabiliserat . För att möjliggöra användning av asm! makro, använd följande funktionsattribut överst i huvudfilen (en funktionsport ):

 #![feature(asm)]

Använd sedan asm! makro i något unsafe block:

fn do_nothing() {
    unsafe {
        asm!("NOP");
    }

    // asm!("NOP"); 
    // That would be invalid here, because we are no longer in an 
    // unsafe block.
}

Kompilera inline-montering

Använd villkorlig sammanställning för att säkerställa att koden endast kompileras för den avsedda instruktionsuppsättningen (t.ex. x86 ). Annars kan kod bli ogiltig om programmet är kompilerat för en annan arkitektur, till exempel ARM-processorer.

#![feature(asm)]

// Any valid x86 code is valid for x86_64 as well. Be careful
// not to write x86_64 only code while including x86 in the 
// compilation targets!
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
fn do_nothing() {
    unsafe {
        asm!("NOP");
    }
}

#[cfg(not(any(target_arch = "x86", target_arch = "x86_64"))]
fn do_nothing() {
    // This is an alternative implementation that doesn't use any asm!
    // calls. Therefore, it should be safe to use as a fallback.
}

Ingångar och utgångar

#![feature(asm)]
    
#[cfg(any(target_arch="x86", target_arch="x86_64"))]
fn subtract(first: i32, second: i32) {
   unsafe {
        // Output values must either be unassigned (let result;) or mutable.
        let result: i32;
        // Each value that you pass in will be in a certain register, which
        // can be accessed with $0, $1, $2...
        //
        // The registers are assigned from left to right, so $0 is the 
        // register containing 'result', $1 is the register containing 
        // 'first' and $2 is the register containing 'second'.
        //
        // Rust uses AT&T syntax by default, so the format is:
        // SUB source, destination
        // which is equivalent to:
        // destination -= source;
        //
        // Because we want to subtract the first from the second, 
        // we use the 0 constraint on 'first' to use the same
        // register as the output.
        // Therefore, we're doing:
        // SUB second, first
        // and getting the value of 'first'
        
        asm!("SUB $2, $0" : "=r"(result) : "0"(first), "r"(second));
        println!("{}", result);
    }
}

LLVM: s begränsningskoder kan hittas här , men det kan variera beroende på vilken version av LLVM som används av din rustc kompilator.