I got the answer from GCC’s mailing list: asm(“call %P0” : : “i”(callee)); // FIXME: missing clobbers Now I just need to find out what %P0 actually means because it seems to be an undocumented feature… Edit: After looking at the GCC source code, it’s not exactly clear what the code P in front of … Read more
I don’t think gcc for ARM allows you to use constraints to specify exactly which register to use. However, you can use explicit register variables to specify a register to store a variable in: register int my_variable asm(“r0”);
Starting with GCC6 on x86 you can actually use “=@ccCOND” as output (where COND is any valid x86 condition code). Example originally from here, cleaned up by David’s suggestions: int variable_test_bit(long n, volatile const unsigned long *addr) { int oldbit; asm volatile(“bt %[value],%[bit]” : “=@ccc” (oldbit) : [value] “m” (*addr), [bit] “Jr” (n)); return oldbit; … Read more
According to GCC docs: 6.45.2.3 Output Operands You can pass the values like this: #include <stdio.h> int main(int argc, char *argv[]) { int src = 1; int dst; asm (“mov %1, %0\n\t add $1, %0” : “=r” (dst) : “r” (src)); printf(“0x%X\n”, dst); return 0; } After your asm code you put the ‘:’ character … Read more
How to convert Linux 32-bit gcc inline assembly to 64-bit code? [closed]
GCC 5.2.0 (and possible earlier versions) support 16-bit code generation with the -m16 flag. However, the code will almost certainly rely on 32-bit processor features (such as 32-bit wide registers), so you should check the generated assembly carefully. From the man pages: The -m16 option is the same as -m32, except for that it outputs … Read more
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 … Read more
There are a few possibilities… here are a couple I can think of off the top of my head: You could access it relative to a label that comes after the .byte directive. Example: .byte 0x0a label: mov (label – 1), %eax Based on the final linked layout of the program, maybe the .byte directives … Read more
The only way of doing this in MSVC is by using inline assembly (which basically buggers you for x64): int _tmain(int argc, _TCHAR* argv[]) { case_1: void* p; __asm{ mov [p],offset case_1 } printf(“0x%p\n”,p); return 0; } If you plan on doing something like this, then the best way would be to write the whole … Read more
Extended-asm syntax requires writing %% to get a single % in the asm output. e.g. for x86: asm(“inc %eax”) // bad: undeclared clobber asm(“inc %%eax” ::: “eax”); // safe but still useless 😛 %r7 is treating r7 as an operand number. As commenters have pointed out, just omit the %s, because you don’t need them … Read more