How to write multiline inline assembly code in GCC C++?

by

I always find some examples on Internet that the guy manually insert a tab and new-line instead of \t and \n, however it doesn’t work for me. Not very sure if your example even compile.. but this is how I do:

asm volatile(           // note the backslash line-continuation
   "xor %eax,%eax          \n\t\
    mov $0x7c802446, %ebx  \n\t\
    mov $1000, %ax         \n\t\
    push %eax              \n\t\
    call *%ebx             \n\t\
    add $4, %esp           \n\t\
    "
    : "=a"(retval)        // output in EAX: function return value
    :
    : "ecx", "edx", "ebx"   // tell compiler about clobbers
  // Also x87 and XMM regs should be listed.
 );

Or put double quotes around each line, instead of using \ line-continuation. C string literals separately only by whitespace (including a newline) are concatenated into one long string literal. (Which is why you need the \n inside it, so it’s separate lines when it’s seen by the assembler).

This is less ugly and makes it possible to put C comments on each line.

asm volatile(
    "xor %eax,%eax          \n\t"
    "mov $0x7c802446, %ebx  \n\t"
    "mov $1000, %ax         \n\t"
    "push %eax              \n\t"  // function arg
    "call *%ebx             \n\t"
    "add $4, %esp           \n\t"  // rebalance the stack: necessary for asm statements
  : "=a"(retval)
  :
  : "ecx", "edx", "ebx"    // clobbers.  Function calls themselves kill EAX,ECX,EDX
  // function calls also clobber all x87 and all XMM registers, omitted here
);

More Related Contents:

  1. How to set gcc or clang to use Intel syntax permanently for inline asm() statements?
  2. clang (LLVM) inline assembly – multiple constraints with useless spills / reloads
  3. Why doesn’t GCC optimize a*a*a*a*a*a to (a*a*a)*(a*a*a)?
  4. What is the difference between ‘asm’, ‘__asm’ and ‘__asm__’?
  5. Why doesn’t gcc resolve _mm256_loadu_pd as single vmovupd?
  6. The advantages of using 32bit registers/instructions in x86-64
  7. Can I use Intel syntax of x86 assembly with GCC?
  8. How to load address of function or label into register
  9. Vectorizing with unaligned buffers: using VMASKMOVPS: generating a mask from a misalignment count? Or not using that insn at all
  10. When to use earlyclobber constraint in extended GCC inline assembly?
  11. Calling printf in extended inline ASM
  12. Labels in GCC inline assembly
  13. Prefetching Examples?
  14. How to access C variable for inline assembly manipulation?
  15. Reading a register value into a C variable [duplicate]
  16. Does a compiler always produce an assembly code?
  17. Why we need Clobbered registers list in Inline Assembly?
  18. Why does the x86-64 System V calling convention pass args in registers instead of just the stack?
  19. Linux process stack overrun by local variables (stack guarding)
  20. Understanding GCC’s floating point constants in assembly listing output
  21. Why do the addresses in my assembler dump differ from the addresses of registers?
  22. How does the GCC implementation of modulo (%) work, and why does it not use the div instruction?
  23. How to use AVX/pclmulqdq on Mac OS X
  24. How to tell GCC to generate 16-bit code for real mode
  25. Fast Division on GCC/ARM
  26. How to convert Linux 32-bit gcc inline assembly to 64-bit code? [closed]
  27. x86_64: Is it possible to “in-line substitute” PLT/GOT references?
  28. Using condition flags as GNU C inline asm outputs
  29. Is the hash required for immediate values in ARM assembly?
  30. what is the order of source operands in AT&T syntax compared to Intel syntax?

Leave a Comment