Rust
Assemblage en ligne

Syntaxe

• #! [feature (asm)] // Activer l'asm! porte caractéristique macro
• asm! (<template>: <output>: <input>: <clobbers>: <options>) // Emet le modèle d'assemblage fourni (par exemple "NOP", "ADD% eax, 4") avec les options données.

L'asm! macro

L'assemblage en ligne ne sera pris en charge que dans les versions nocturnes de Rust jusqu'à ce qu'il soit stabilisé . Pour permettre l'utilisation de l' asm! macro, utilisez l'attribut de fonctionnalité suivant en haut du fichier principal (une porte de fonctionnalité ):

 #![feature(asm)]

Ensuite, utilisez l' asm! macro dans tout bloc unsafe :

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

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

Compiler sous condition l'assemblage en ligne

Utilisez la compilation conditionnelle pour vous assurer que le code ne compile que pour le jeu d'instructions voulu (tel que x86 ). Sinon, le code pourrait devenir invalide si le programme est compilé pour une autre architecture, telle que les processeurs ARM.

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

Entrées et sorties

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

Les codes de contraintes de LLVM peuvent être trouvés ici , mais cela peut varier en fonction de la version de LLVM utilisée par votre compilateur rustc .