TLS variable in Linux

__thread int test;
int test2;

int main(int argc, char **argv) {
    test++;
    test2++;
    return 0;
}

0x00000000004004ec <+0>:     push   %rbp
0x00000000004004ed <+1>:     mov    %rsp,%rbp
0x00000000004004f0 <+4>:     mov    %edi,-0x4(%rbp)
0x00000000004004f3 <+7>:     mov    %rsi,-0x10(%rbp)
0x00000000004004f7 <+11>:    mov    %fs:0xfffffffffffffffc,%eax
0x00000000004004ff <+19>:    add    $0x1,%eax
0x0000000000400502 <+22>:    mov    %eax,%fs:0xfffffffffffffffc
0x000000000040050a <+30>:    mov    0x2003c4(%rip),%eax        # 0x6008d4 <test2>
0x0000000000400510 <+36>:    add    $0x1,%eax
0x0000000000400513 <+39>:    mov    %eax,0x2003bb(%rip)        # 0x6008d4 <test2>
0x0000000000400519 <+45>:    mov    $0x0,%eax
0x000000000040051e <+50>:    pop    %rbp
0x000000000040051f <+51>:    retq

long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
{
	int ret = 0;
	int doit = task == current;
	int cpu;

	switch (code) {
	case ARCH_SET_FS:
		/* Not strictly needed for fs, but do it for symmetry
		   with gs */
		if (addr >= TASK_SIZE_OF(task))
			return -EPERM;
		cpu = get_cpu();
		/* handle small bases via the GDT because that's faster to
		   switch. */
		if (addr <= 0xffffffff) {
			set_32bit_tls(task, FS_TLS, addr);
			if (doit) {
				load_TLS(&task->thread, cpu);
				loadsegment(fs, FS_TLS_SEL);
			}
			task->thread.fsindex = FS_TLS_SEL;
			task->thread.fs = 0;
		} else {
			task->thread.fsindex = 0;
			task->thread.fs = addr;
			if (doit) {
				/* set the selector to 0 to not confuse
				   __switch_to */
				loadsegment(fs, 0);
				ret = wrmsrl_safe(MSR_FS_BASE, addr);
			}
		}
		put_cpu();
		break;
	}
	return ret;
}

long sys_arch_prctl(int code, unsigned long addr)
{
	return do_arch_prctl(current, code, addr);
}

/*
 * Set a new TLS for the child thread?
 */
if (clone_flags & CLONE_SETTLS) {
#ifdef CONFIG_IA32_EMULATION
    if (test_thread_flag(TIF_IA32))
        err = do_set_thread_area(p, -1, (struct user_desc __user *)childregs->si, 0);
    else
#endif
    err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
    if (err)
        goto out;
}

__notrace_funcgraph struct task_struct *
__switch_to(struct task_struct *prev_p, struct task_struct *next_p) {
    ......
    savesegment(fs, fsindex);
    savesegment(gs, gsindex);
    
    load_TLS(next, cpu);
    
    /*
     * Leave lazy mode, flushing any hypercalls made here.
     * This must be done before restoring TLS segments so
     * the GDT and LDT are properly updated, and must be
     * done before math_state_restore, so the TS bit is up
     * to date.
     */
    arch_end_context_switch(next_p);
    
    /*
     * Switch FS and GS.
     *
     * Segment register != 0 always requires a reload.  Also
     * reload when it has changed.  When prev process used 64bit
     * base always reload to avoid an information leak.
     */
    if (unlikely(fsindex | next->fsindex | prev->fs)) {
        loadsegment(fs, next->fsindex);
        /*
        * Check if the user used a selector != 0; if yes
        *  clear 64bit base, since overloaded base is always
        *  mapped to the Null selector
        */
        if (fsindex)
            prev->fs = 0;
    }
    /* when next process has a 64bit base use it */
    if (next->fs)
        wrmsrl(MSR_FS_BASE, next->fs);
    prev->fsindex = fsindex;
    ......
}