clang (LLVM) inline assembly – multiple constraints with useless spills / reloads

by

I had a response on the cfe-dev (clang front end developers’ list) from one of the developers:

LLVM currently always spills “rm” constraints in order to simplify the
handling of inline asm in the backend (you can ask on llvmdev if you want
details). I don’t know of any plans to fix this in the near future.

So it’s clearly a ‘known’ issue. One of the goals of clang is to correctly handle gcc’s inline assembly syntax, amongst other extensions, which it does in this case – just not very efficiently. In short, this isn’t a bug, per se.

Since this isn’t a bug, I’m going to continue with the "r,m" constraint syntax. I figure that this is the best compromise for now. gcc will choose the best – presumably a register where possible – and clang will force the use of a register by ignoring further options after the comma. If nothing else, it still preserves the semantic intent of the assembly statement, i.e., describing possible constraints, even if they are ignored.

A final note (20130715) : This particular example will not compile using the "r,m" constraint in a single position – we would have to supply an alternative constraint match for each, e.g.,

: "=a,a" (rl), "=d,d" (rh) : "%0,0" (x), "r,m" (y)

This is required for multiple alternative constraints with GCC. But we’re getting into territory where GCC has been known to exhibit bugs in the past – whether or not this is true as of 4.8.1, I don’t know. Clang works without the alternatives in the other constraints, which is incompatible with GCC syntax, and must therefore be considered a bug.

If performance is critical, use "r", otherwise, stick with "rm" and maybe clang will address this in the future, even as it benefits GCC.

More Related Contents:

  1. How can I indicate that the memory *pointed* to by an inline ASM argument may be used?
  2. The advantages of using 32bit registers/instructions in x86-64
  3. How to load address of function or label into register
  4. Calling printf in extended inline ASM
  5. How to set gcc or clang to use Intel syntax permanently for inline asm() statements?
  6. Why does the x86-64 System V calling convention pass args in registers instead of just the stack?
  7. Understanding GCC’s floating point constants in assembly listing output
  8. Why did GCC generate mov %eax,%eax and what does it mean?
  9. How to write multiline inline assembly code in GCC C++?
  10. How to convert Linux 32-bit gcc inline assembly to 64-bit code? [closed]
  11. x86_64: Is it possible to “in-line substitute” PLT/GOT references?
  12. How to remove “noise” from GCC/clang assembly output?
  13. What is the difference between ‘asm’, ‘__asm’ and ‘__asm__’?
  14. Can I use Intel syntax of x86 assembly with GCC?
  15. Vectorizing with unaligned buffers: using VMASKMOVPS: generating a mask from a misalignment count? Or not using that insn at all
  16. When to use earlyclobber constraint in extended GCC inline assembly?
  17. Looping over arrays with inline assembly
  18. Why is the address of static variables relative to the Instruction Pointer?
  19. Reading a register value into a C variable [duplicate]
  20. Cuda Clang and OS X Mavericks
  21. How to detect SSE/SSE2/AVX/AVX2/AVX-512/AVX-128-FMA/KCVI availability at compile-time?
  22. How to set a variable in GCC with Intel syntax inline assembly?
  23. Number of executed Instructions different for Hello World program Nasm Assembly and C
  24. Does a compiler always produce an assembly code?
  25. x86_64 : is stack frame pointer almost useless?
  26. Why do compilers insist on using a callee-saved register here?
  27. Why do the addresses in my assembler dump differ from the addresses of registers?
  28. Using condition flags as GNU C inline asm outputs
  29. How to specify an individual register as constraint in ARM GCC inline assembly?
  30. what is the order of source operands in AT&T syntax compared to Intel syntax?

Leave a Comment