Question

I am trying to use a thread local variable in inline assembly, but when I see the diassembled code, It appears that the compiler doesn’t generate the right code. For the following inline code, where saved_sp is globally declared as __thread long saved_sp,

__asm__ __volatile__ (
        "movq %rsp, saved_sp\n\t");

The disassembly looks like the following.

mov    %rsp,0x612008

Which is clearly not the right thing, because I know that gcc uses the fs segment for thread local variables. It should had generated something like

mov %rsp, fs:somevalue

which it is not. Why is that so? Is using thread local variables in inline assembly problematic?

Answer 1

A simple thing that would surely work is to take a pointer to the thread local variable, and write to it.
Your compiler will surely do long *saved_fp_p = &saved_fp correctly, and inline assembly will only deal with saved_fp_p, which is a local variable.

You can also use gcc’s input and output syntax:

__asm__ __volatile__ (
    "mov %%rsp, 0(%0)" : : "r" (&saved_sp)
);

This puts the compiler in charge of resolving the address of saved_fp, and the assembly code gets it in a register.

We found out that this also works,

__asm__ __volatile__ asm ("mov %rsp,%0" : "=m" (saved_sp))