Rust
Inline assemblage

Syntaxis

• #! [feature (asm)] // Schakel het asm in! macro functie poort
• asm! (<template>: <output>: <input>: <clobbers>: <options>) // Verzend de meegeleverde montagesjabloon (bijv. "NOP", "ADD% eax, 4") met de gegeven opties.

Het asm! macro

Inline assemblage wordt alleen ondersteund in nachtelijke versies van Rust totdat deze is gestabiliseerd . Om het gebruik van het asm! macro, gebruik het volgende kenmerk attribuut bovenaan het hoofdbestand (een kenmerkpoort ):

 #![feature(asm)]

Gebruik dan het asm! macro in elk unsafe blok:

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

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

Voorwaardelijk compileren inline assemblage

Gebruik voorwaardelijke compilatie om ervoor te zorgen dat code alleen compileert voor de beoogde instructieset (zoals x86 ). Anders kan code ongeldig worden als het programma is gecompileerd voor een andere architectuur, zoals ARM-processors.

#![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.
}

Ingangen en uitgangen

#![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);
    }
}

De beperkingscodes van LLVM zijn hier te vinden, maar dit kan variëren, afhankelijk van de versie van LLVM die door uw rustc compiler wordt gebruikt.