3

I'm using Apple's llvm-gcc to compile some code with inline assembly. I wrote what I want it to do, but it adds extraneous commands that keep writing variables to memory. Why is it doing this and how can I stop it?

Example:

__asm__{
  mov r11, [rax]
  and r11, 0xff
  cmp r11, '\0'
}

becomes (in the "assembly" assistant view):

mov  0(%rax), %r11     // correct
movq %r11, -104(%rbp)  // no, GCC, obviously wrong
and  $255, %r11
movq %r11, -104(%rbp)
cmp  $0, %r11

Cheers.

Peter G.
  • 14,786
  • 7
  • 57
  • 75
Loyal Tingley
  • 910
  • 1
  • 8
  • 20
  • 3
    Have you tried setting appropriate input, output, and clobber lists using the [extended asm syntax](http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html#s5)? – Adam Rosenfield May 17 '12 at 17:43
  • @Adam, that was my best guess... I'll try it today. Would I have to switch to the `asm("cmd1\n\t" "cmd2" : ... : ... : ... )` style or is there a way to add specifiers to the curly-bracket notation? – Loyal Tingley May 18 '12 at 03:34
  • I don't know if there's a way to add those specifiers using the curly bracket notation; it shouldn't be too hard to convert it to use quoted strings instead. – Adam Rosenfield May 18 '12 at 03:48
  • @Adam looks like this fixes it -- post it as an answer if you want proper credit :) – Loyal Tingley May 18 '12 at 04:53

3 Answers3

2

You need to use GCC's extended asm syntax to tell it which registers you're using as input and output and which registers get clobbered. If you don't do that, it has no idea what you're doing, and the assembly it generates can easily interfere with your code.

By informing it about what your code is doing, it changes how it does register allocation and optimization and avoids breaking your code.

Adam Rosenfield
  • 390,455
  • 97
  • 512
  • 589
0

it's because gcc tries to optimize your code. you can prevent optimizations by adding -O0 to command-line.

RThomas
  • 10,702
  • 2
  • 48
  • 61
sithereal
  • 1,656
  • 9
  • 16
0

Try adding volatile after __asm__ if you don't want that. That additional commands are probably part previous/next C instructions. Without volatile compiler is allowed to do this (as it probably executes faster this way - not your code, the whole routine).

dbrank0
  • 9,026
  • 2
  • 37
  • 55
  • I did some Googling before asking and that was the first thing to come up. Alas, the compiler ignored it (and issued a warning saying such). I don't think the additional commands are from elsewhere in the function, because it's moving to the same memory twice, effectively making the first move a nop. – Loyal Tingley May 18 '12 at 03:37