Compiler produces some strange code when using C++11 global thread local variables. The produced
binary also permamently crashes when built in some circumstances. The problem is visible on all
optimization levels above -O0, the binary compiled with -O0 looks good.
I use MSYS2 build environment with gcc 8.3.0 installed. Extract the attached minimal example and
run the following commands:
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make
Then inspect the produced code with the GDB:
gdb sample.exe
(gdb) disas main
Dump of assembler code for function main():
0x0000000000402d20 <+0>: sub $0x28,%rsp
0x0000000000402d24 <+4>: callq 0x401610 <__main>
0x0000000000402d29 <+9>: lea -0x402d30(%rip),%rax # 0x0
0x0000000000402d30 <+16>: test %rax,%rax
0x0000000000402d33 <+19>: je 0x402d3a <main()+26>
0x0000000000402d35 <+21>: callq 0x0
0x0000000000402d3a <+26>: mov 0x160f(%rip),%rcx # 0x404350 <.refptr.__emutls_v.tl>
0x0000000000402d41 <+33>: callq 0x402af0 <__emutls_get_address>
0x0000000000402d46 <+38>: movl $0x2a,(%rax)
0x0000000000402d4c <+44>: xor %eax,%eax
0x0000000000402d4e <+46>: add $0x28,%rsp
0x0000000000402d52 <+50>: retq
The strange thing is instruction at <+9> "lea -0x703813bb(%rip),%rax" which calculates some
address, the result is tested against zero at <+16> and call to this address is executed at <+21>
in case it is non-zero. In this particular example the result is zero, so it does not crash. But in
my case the result was not zero and still invalid which causes a crash. Unfortunately my example is
not easy reproducible, it probably was triggered after I statically linked my DLL with large library
(ffmpeg) and the calculated address became non-zero. Besides that even in the attached example the
idea behind this strange address manipulation is not clear and looks like some code optimization
bug.
cmake -DCMAKE_BUILD_TYPE=Debug ..
make
(gdb) disas main
Dump of assembler code for function main():
0x0000000000401560 <+0>: push %rbp
0x0000000000401561 <+1>: mov %rsp,%rbp
0x0000000000401564 <+4>: sub $0x20,%rsp
0x0000000000401568 <+8>: callq 0x401640 <__main>
0x000000000040156d <+13>: callq 0x402d50 <_ZTW2tl> // "TLS wrapper function for tl"
0x0000000000401572 <+18>: movl $0x2a,(%rax)
0x0000000000401578 <+24>: mov $0x0,%eax
0x000000000040157d <+29>: add $0x20,%rsp
0x0000000000401581 <+33>: pop %rbp
0x0000000000401582 <+34>: retq
(gdb) disas _ZTW2tl
Dump of assembler code for function _ZTW2tl:
0x0000000000402d50 <+0>: push %rbp
0x0000000000402d51 <+1>: mov %rsp,%rbp
0x0000000000402d54 <+4>: sub $0x20,%rsp
0x0000000000402d58 <+8>: mov 0x15a1(%rip),%rax # 0x404300 <.refptr._ZTH2tl> //"TLS init function for tl"
0x0000000000402d5f <+15>: test %rax,%rax
0x0000000000402d62 <+18>: je 0x402d69 <_ZTW2tl+25>
0x0000000000402d64 <+20>: callq 0x0
0x0000000000402d69 <+25>: mov 0x15e0(%rip),%rcx # 0x404350 <.refptr.__emutls_v.tl>
0x0000000000402d70 <+32>: callq 0x402b20 <__emutls_get_address>
0x0000000000402d75 <+37>: add $0x20,%rsp
0x0000000000402d79 <+41>: pop %rbp
0x0000000000402d7a <+42>: retq
It is seen that TLS wrapper is not inlined in this case and instead of calculating some address, some
real variable read is generated at <+8> which looks more correct. The calling address at <+20> is
probably replaced with a correct one when runtime-linked to some process context. In my case it looks
like this:
(gdb) disas _ZTWN4java6jniEnvE
Dump of assembler code for function _ZTWN4java6jniEnvE:
0x000000005c4aa790 <+0>: push %rbp
0x000000005c4aa791 <+1>: mov %rsp,%rbp
0x000000005c4aa794 <+4>: sub $0x20,%rsp
0x000000005c4aa798 <+8>: mov 0xa1cf1(%rip),%rax # 0x5c54c490 <.refptr._ZTHN4java6jniEnvE>
0x000000005c4aa79f <+15>: test %rax,%rax
0x000000005c4aa7a2 <+18>: je 0x5c4aa7a9 <_ZTWN4java6jniEnvE+25>
0x000000005c4aa7a4 <+20>: callq 0xffffffffec9a0000
0x000000005c4aa7a9 <+25>: mov 0xa1ff0(%rip),%rcx # 0x5c54c7a0 <.refptr.__emutls_v._ZN4java6jniEnvE>
0x000000005c4aa7b0 <+32>: callq 0x5c1a0268 <__emutls_get_address>
0x000000005c4aa7b5 <+37>: add $0x20,%rsp
0x000000005c4aa7b9 <+41>: pop %rbp
0x000000005c4aa7ba <+42>: retq
And it does not crash and works as expected, and crashing if compiled with -O1, -O2 or -O3. It would
be nice to know what is the idea behind the address calculation instead of variable reading in debug
build, which also significantly changes application logic between release and debug build which is
very suspicious. For now, it looks like some optimization bug.
I'm closing this, as invalid, for the following reasons:—
The code you illustrate is for a 64-bit host, so it most definitely was not generated by any compiler originating from this project.
GCC often uses lea instructions, as multi-byte nop filler code; that may, or may not be the intent here, but it's something to bear in mind.
In any case, since you are using tools originating from some other project, (which, BTW, is abusing our registered trademark, without authorization), we cannot help you.
keith 
Fork
Compiler produces some strange code when using C++11 global thread local variables. The produced binary also permamently crashes when built in some circumstances. The problem is visible on all optimization levels above -O0, the binary compiled with -O0 looks good.
I use MSYS2 build environment with gcc 8.3.0 installed. Extract the attached minimal example and run the following commands:
Then inspect the produced code with the GDB:
The strange thing is instruction at <+9> "lea -0x703813bb(%rip),%rax" which calculates some address, the result is tested against zero at <+16> and call to this address is executed at <+21> in case it is non-zero. In this particular example the result is zero, so it does not crash. But in my case the result was not zero and still invalid which causes a crash. Unfortunately my example is not easy reproducible, it probably was triggered after I statically linked my DLL with large library (ffmpeg) and the calculated address became non-zero. Besides that even in the attached example the idea behind this strange address manipulation is not clear and looks like some code optimization bug.
Compare this code with one compiled with -O0:
It is seen that TLS wrapper is not inlined in this case and instead of calculating some address, some real variable read is generated at <+8> which looks more correct. The calling address at <+20> is probably replaced with a correct one when runtime-linked to some process context. In my case it looks like this:
And it does not crash and works as expected, and crashing if compiled with -O1, -O2 or -O3. It would be nice to know what is the idea behind the address calculation instead of variable reading in debug build, which also significantly changes application logic between release and debug build which is very suspicious. For now, it looks like some optimization bug.
I also tried to compile the sample with clang, it failed to link: