Namespaces
Variants

Inline assembly

From cppreference.net

L'assemblage en ligne (généralement introduit par le mot-clé asm ) permet d'intégrer du code source en langage assembleur dans un programme C.

Contrairement au C++, l'assembleur en ligne est considéré comme une extension en C. Il est conditionnellement pris en charge et défini par l'implémentation, ce qui signifie qu'il peut ne pas être présent et, même lorsqu'il est fourni par l'implémentation, il n'a pas de signification fixe.

Table des matières

Syntaxe

asm ( string_literal ) ;

Explication

Ce type de syntaxe d'assemblage en ligne est accepté par la norme C++ et appelé asm-declaration en C++. Le string_literal est généralement un court programme écrit en langage assembleur, qui est exécuté chaque fois que cette déclaration est exécutée. Différents compilateurs C ont des règles extrêmement variables pour les asm-declarations, et différentes conventions pour l'interaction avec le code C environnant.

La déclaration asm peut apparaître à l'intérieur d'un bloc (un corps de fonction ou une autre instruction composée), et, comme toutes les autres déclarations, cette déclaration peut également apparaître en dehors d'un bloc.

Notes

MSVC ne prend pas en charge l'assemblage en ligne sur les processeurs ARM et x64, et ne prend en charge que la forme introduite par __asm sur les processeurs x86.

Lors de la compilation en mode ISO C par GCC ou Clang (par exemple avec l'option - std = c11 ), __asm__ doit être utilisé à la place de asm .

Exemples

Démontre deux types de syntaxe d'assemblage en ligne offerts par le compilateur GCC. Ce programme ne fonctionnera correctement que sur la plateforme x86-64 sous Linux. Notez que l'"assemblage en ligne standard" est également traité comme une extension dans la norme C.

#include <stdio.h>
extern int func(void);
// the definition of func is written in assembly language
__asm__(".globl func\n\t"
        ".type func, @function\n\t"
        "func:\n\t"
        ".cfi_startproc\n\t"
        "movl $7, %eax\n\t"
        "ret\n\t"
        ".cfi_endproc");
int main(void)
{
    int n = func();
    // gcc's extended inline assembly
    __asm__ ("leal (%0,%0,4),%0"
           : "=r" (n)
           : "0" (n));
    printf("7*5 = %d\n", n);
    fflush(stdout); // flush is intentional
    // standard inline assembly in C++
    __asm__ ("movq $60, %rax\n\t" // the exit syscall number on Linux
             "movq $2,  %rdi\n\t" // this program returns 2
             "syscall");
}

Sortie :

7*5 = 35

Références

  • Norme C23 (ISO/CEI 9899:2024) :
  • J.5.10 Le mot-clé asm (p: TBD)
  • Norme C17 (ISO/CEI 9899:2018) :
  • J.5.10 Le mot-clé asm (p: 422)
  • Norme C11 (ISO/CEI 9899:2011) :
  • J.5.10 Le mot-clé asm (p: 580)
  • Norme C99 (ISO/CEI 9899:1999) :
  • J.5.10 Le mot-clé asm (p: 512)
  • Norme C89/C90 (ISO/IEC 9899:1990) :
  • G.5.10 Le mot-clé asm

Voir aussi

Documentation C++ pour asm declaration

Liens externes

1. Guide GCC sur l'Assemblage Inline
2. Assemblage Inline IBM XL C/C++
3. Assemblage Inline Intel C++
4. Assembleur Inline Visual Studio
5. Instructions Asm Sun Studio 12
6. Assemblage inline pour HP-UX basé sur Itanium