C Language
Assemblaggio in linea

Osservazioni

gcc Supporto di base asm

Il supporto dell'assembly di base con gcc ha la seguente sintassi:

asm [ volatile ] ( AssemblerInstructions )

dove AssemblerInstructions è il codice di assemblaggio diretto per il processore specificato. La parola chiave volatile è facoltativa e non ha alcun effetto in quanto gcc non ottimizza il codice all'interno di un'istruzione asm di base. AssemblerInstructions può contenere più istruzioni di assemblaggio. Un'istruzione asm di base viene utilizzata se si dispone di una routine asm che deve esistere al di fuori di una funzione C. Il seguente esempio è tratto dal manuale GCC:

 /* Note that this code will not compile with -masm=intel */
 #define DebugBreak() asm("int $3")

In questo esempio, è possibile utilizzare DebugBreak() in altri punti del codice e verrà eseguita l'istruzione di assemblaggio int $3 . Nota che anche se gcc non modificherà alcun codice in un'istruzione asm di base, l'ottimizzatore potrebbe comunque spostare istruzioni asm consecutive attorno. Se si dispone di più istruzioni di assemblaggio che devono essere eseguite in un ordine specifico, includerle in una dichiarazione asm.

gcc Supporto esteso asm

Il supporto esteso di asm in gcc ha la seguente sintassi:

asm [volatile] ( AssemblerTemplate
                  : OutputOperands
                  [ : InputOperands
                  [ : Clobbers ] ])
 
 asm [volatile] goto ( AssemblerTemplate
                       :
                       : InputOperands
                       : Clobbers
                       : GotoLabels)

dove AssemblerTemplate è il modello per l'istruzione assembler, OutputOperands sono tutte le variabili C che possono essere modificate dal codice assembly, InputOperands sono tutte le variabili C utilizzate come parametri di input, Clobbers sono un elenco o registri modificati dal codice assembly e GotoLabels sono tutte le etichette di istruzioni goto che possono essere utilizzate nel codice assembly.

Il formato esteso viene utilizzato all'interno delle funzioni C ed è l'utilizzo più tipico dell'assembly inline. Di seguito è riportato un esempio del kernel di Linux per lo scambio di byte a 16 bit e numeri a 32 bit per un processore ARM:

/* From arch/arm/include/asm/swab.h in Linux kernel version 4.6.4 */
#if __LINUX_ARM_ARCH__ >= 6

static inline __attribute_const__ __u32 __arch_swahb32(__u32 x)
{
    __asm__ ("rev16 %0, %1" : "=r" (x) : "r" (x));
    return x;
}
#define __arch_swahb32 __arch_swahb32
#define __arch_swab16(x) ((__u16)__arch_swahb32(x))

static inline __attribute_const__ __u32 __arch_swab32(__u32 x)
{
    __asm__ ("rev %0, %1" : "=r" (x) : "r" (x));
    return x;
}
#define __arch_swab32 __arch_swab32

#endif

Ogni sezione di asm usa la variabile x come parametro di input e output. La funzione C restituisce quindi il risultato manipolato.

Con il formato asm esteso, gcc può ottimizzare le istruzioni di assemblaggio in un blocco asm seguendo le stesse regole che usa per l'ottimizzazione del codice C. Se vuoi che la tua sezione asm non venga toccata, usa la parola chiave volatile per la sezione asm.

gcc Assieme in linea in macro

Possiamo inserire istruzioni di assemblaggio all'interno di una macro e utilizzare la macro come se fosse chiamata una funzione.

#define mov(x,y) \
{ \
    __asm__ ("l.cmov %0,%1,%2" : "=r" (x) : "r" (y), "r" (0x0000000F)); \
}

/// some definition and assignment
unsigned char sbox[size][size];
unsigned char sbox[size][size];

///Using
mov(state[0][1], sbox[si][sj]);

L'uso di istruzioni di assemblaggio inline incorporate nel codice C può migliorare il tempo di esecuzione di un programma. Questo è molto utile in situazioni di tempo critico come algoritmi crittografici come AES. Ad esempio, per una semplice operazione di spostamento che è necessaria nell'algoritmo AES, possiamo sostituire un'istruzione di montaggio Rotate Right diretta con l'operatore C shift >> .

In un'implementazione di 'AES256', nella funzione 'AddRoundKey ()' abbiamo alcune istruzioni come questa:

unsigned int w;          // 32-bit
unsigned char subkey[4]; // 8-bit, 4*8 = 32 

subkey[0] = w >> 24;     // hold 8 bit, MSB, leftmost group of 8-bits 
subkey[1] = w >> 16;     // hold 8 bit, second group of 8-bit from left    
subkey[2] = w >> 8;      // hold 8 bit, second group of 8-bit from right
subkey[3] = w;           // hold 8 bit, LSB, rightmost group of 8-bits

/// subkey <- w

Assegnano semplicemente il valore di bit di w all'array di subkey .

Possiamo cambiare tre turni + assegnare e assegnare un'espressione C con un solo assieme Rotate Right .

__asm__ ("l.ror  %0,%1,%2" : "=r" (* (unsigned int *) subkey)  : "r" (w), "r" (0x10));

Il risultato finale è esattamente lo stesso.