'asm' operand has impossible constraints - c

Question

I'm trying to compile xen on Arch linux and getting following error:
src/stacks.c:342:5: error: 'asm' operand has impossible constraints
asm volatile(
^
Here is code for the method that is causing error:
void
run_thread(void (*func)(void*), void *data)
{
ASSERT32FLAT();
if (! CONFIG_THREADS || ! ThreadControl)
goto fail;
struct thread_info *thread;
thread = memalign_tmphigh(THREADSTACKSIZE, THREADSTACKSIZE);
if (!thread)
goto fail;
dprintf(DEBUG_thread, "/%08x\\ Start thread\n", (u32)thread);
thread->stackpos = (void*)thread + THREADSTACKSIZE;
struct thread_info *cur = getCurThread();
hlist_add_after(&thread->node, &cur->node);
asm volatile(
// Start thread
" pushl $1f\n" // store return pc
" pushl %%ebp\n" // backup %ebp
" movl %%esp, (%%edx)\n" // cur->stackpos = %esp
" movl (%%ebx), %%esp\n" // %esp = thread->stackpos
" calll *%%ecx\n" // Call func
// End thread
" movl %%ebx, %%eax\n" // %eax = thread
" movl 4(%%ebx), %%ebx\n" // %ebx = thread->node.next
" movl (%5), %%esp\n" // %esp = MainThread.stackpos
" calll %4\n" // call __end_thread(thread)
" movl -4(%%ebx), %%esp\n" // %esp = next->stackpos
" popl %%ebp\n" // restore %ebp
" retl\n" // restore pc
"1:\n"
: "+a"(data), "+c"(func), "+b"(thread), "+d"(cur)
: "m"(*(u8*)__end_thread), "m"(MainThread)
: "esi", "edi", "cc", "memory");
return;
fail:
func(data);
}
I'm not sure what's going on. Can someone with assebly knowledge help look at it and tell if there is some obvious problem here?
Update:
You can fix this error by doing 2 things:
add COMMONCFLAGS += $(call cc-option,$(CC),-fstack-check=no,) into seabios makefile (if you build xen from git AUR then location should be xen/src/xen-4.5.1/tools/firmware/seabios-dir-remote/Makefile)
go to stacks.c and change movl (%5), %%esp to movl %5, %%esp

Answer 1

The immediate cause is probably that you don't have -fomit-frame-pointer enabled, either directly or indirectly through optimization switches. Thus, the compiler runs out of registers since eax, ebx, ecx and edx are used for arguments, esi and edi are clobbers and ebp is the frame pointer. The solution is therefore to make sure this option is enabled.
Apparently this code is part of SeaBIOS (thanks to Michael Petch for finding it). __end_thread there is simply a function, as opposed to a function pointer one would expect from the presence of that casting magic. As such, I think the point of this construct is to work around any eventual name mangling. Unfortunately, it sacrifices a register for that purpose. If you know you your environment does not mangle function names, you can use this simpler version which doesn't need an extra register and should compile fine in debug builds with a frame pointer too:
asm volatile(
// Start thread
" pushl $1f\n" // store return pc
" pushl %%ebp\n" // backup %ebp
" movl %%esp, (%%edx)\n" // cur->stackpos = %esp
" movl (%%ebx), %%esp\n" // %esp = thread->stackpos
" calll *%%ecx\n" // Call func
// End thread
" movl %%ebx, %%eax\n" // %eax = thread
" movl 4(%%ebx), %%ebx\n" // %ebx = thread->node.next
" movl (%4), %%esp\n" // %esp = MainThread.stackpos
" call __end_thread\n" // call __end_thread(thread)
" movl -4(%%ebx), %%esp\n" // %esp = next->stackpos
" popl %%ebp\n" // restore %ebp
" retl\n" // restore pc
"1:\n"
: "+a"(data), "+c"(func), "+b"(thread), "+d"(cur)
: "m"(MainThread)
: "esi", "edi", "cc", "memory");

Answer 2

I'd completely rewrite the asm statement. The basic problem is that the statement either clobbers or uses as an input/output operand every register except EBP. When optimization is disabled and -fno-omit-frame-pointer is used there isn't a register to store the result of evaluating the expression (u8*)__end_thread. Which is a good thing because it because if the frame pointer was available it would generate calll (%ebp) which isn't what is actually wanted here.
Instead of trying assign all the registers and clobbering any that aren't used, the following asm statement makes every register except EBP an output operand. This gives the compiler much more freedom to assign input registers.
int dummy;
asm volatile("push 1f\n\t"
"push %%ebp\n\t"
"mov %%esp, %[cur_stackpos]\n\t"
"mov %[thread_stackpos], %%esp\n\t"
"call *%[func]\n\t"
"mov %p[mainthread_stackpos], %%esp\n\t"
"mov %[thread], %%eax\n\t"
"call %c[end_thread]\n\t"
"mov 4(%[thread]),%%eax\n\t"
"mov -4(%%eax),%%esp\n\t"
"pop %%ebp\n\t"
"pop %%eax\n\t"
"jmp *%%eax\n\t"
"1:\n"
:
[data] "+a" (data),
"=b" (dummy), "=c" (dummy), "=d" (dummy),
"=S" (dummy), "=D" (dummy)
:
[func] "r" (func),
[cur_stackpos] "m" (cur->stackpos),
[thread_stackpos] "rm" (thread->stackpos),
[mainthread_stackpos] "i" (&MainThread.stackpos),
[thread] "bSD" (thread),
[end_thread] "i" (__end_thread)
:
"memory", "cc");
I've used "i" constraints and operand modifiers for the [mainthread_stackpos] and [end_thread] operands to ensure that these operands are simple labels. The compiler can't put them in registers or on the stack. This is a bit of paranoia, using an "m" constraint without operand modifiers will also work. At least until the compiler does something unexpected like it did with *(u8*)__end_thread. Speaking of which, I've replaced it with just __end_thread as the cast and dereference seems to be pointless.
I've also replaced the ret statement with pop %eax; jmp *%eax as this should be faster. The ret statement will always be mispredicted because the address won't be return stack buffer, but there's at least chance that jmp *eax will be predicted. It either jumps to the next instruction or the 1: label in switch_stacks.