Use -masm=intel and don’t use any .att_syntax directives in your inline asm. This works with GCC and I think ICC, and with any constraints you use. Other methods don’t. (See Can I use Intel syntax of x86 assembly with GCC? for a simple answer saying that; this answer explores exactly what goes wrong, including with … Read more
You can use local variables in extended assembly, but you need to tell the extended assembly construct about them. Consider: #include <stdio.h> int main (void) { int data1 = 10; int data2 = 20; int result; __asm__( ” movl %[mydata1], %[myresult]\n” ” imull %[mydata2], %[myresult]\n” : [myresult] “=&r” (result) : [mydata1] “r” (data1), [mydata2] “r” … Read more
From the file gcc/config/i386/i386.c of the GCC sources: b — print the QImode name of the register for the indicated operand. %b0 would print %al if operands[0] is reg 0. w — likewise, print the HImode name of the register. k — likewise, print the SImode name of the register. q — likewise, print the … Read more
implementing alloca actually requires compiler assistance. A few people here are saying it’s as easy as: sub esp, <size> which is unfortunately only half of the picture. Yes that would “allocate space on the stack” but there are a couple of gotchas. if the compiler had emitted code which references other variables relative to esp … Read more
I’m fairly certain you’re being blocked by DEP. The x_CPUIDy_INSNS byte arrays are in a segment of memory marked as data and non-executable. EDIT: That being said, I’ve gotten a version that compiles and runs, but I don’t think gets the right values. Perhaps this will get you along your way. EDIT 2: I think … Read more
First, you have to understand the concept of rings. A kernel runs in ring 0, meaning it has a full access to memory and opcodes. A program runs usually in ring 3. It has a limited access to memory, and cannot use all the opcodes. So when a software need more privileges (for opening a … Read more
Editor’s note: this way of using a local register-asm variable is now documented by GCC as “not supported”. It still usually happens to work on GCC, but breaks with clang. (This wording in the documentation was added after this answer was posted, I think.) The global fixed-register variable version has a large performance cost for … Read more
In GNU C inline asm, with x86 AT&T syntax: (But https://gcc.gnu.org/wiki/DontUseInlineAsm if you can avoid it). // this example doesn’t really need volatile: the result is the same every time asm volatile(“movl $0, %[some]” : [some] “=r” (x) ); after this, x contains 0. Note that you should generally avoid mov as the first or … Read more
According to the x86 ABI, EBX, ESI, EDI, and EBP are callee-save registers and EAX, ECX and EDX are caller-save registers. It means that functions can freely use and destroy previous values EAX, ECX, and EDX. For that reason, save values of EAX, ECX, EDX before calling functions if you don’t want their values to … Read more