[1/3] TLS loads opimization (hoist)

[xiangzhangllvm]

Summary

When we access a TLS variable in PIC mode, it usually get the TLS address by calling a lib function, some like
callq __tls_get_addr@PLT
This call was not show in IR or MIR, usually tag by a target-special flag (like pic) and generated in Assembly Printing.
So it is usually call it every time when TLS variable is accessed. Many of them are duplicated, especially in loops.

This patch is try to optimize it. It identifies/eliminate Redundant TLS address call by hoist the TLS access when the related option is set.

For example:

static __thread int x;
int g();
int f(int c) {
  int *px = &x;
  while (c--)
    *px += g();
  return *px;
}

will generated Redundant TLS Loads by compiling it with
Clang++ -fPIC -ftls-model=global-dynamic -O2 -S

.LBB0_2:                                # %while.body
                                        # =>This Inner Loop Header: Depth=1
        callq   _Z1gv@PLT
        movl    %eax, %ebp
        leaq    _ZL1x@TLSLD(%rip), %rdi
        callq   __tls_get_addr@PLT
        addl    _ZL1x@DTPOFF(%rax), %ebp
        movl    %ebp, _ZL1x@DTPOFF(%rax)
        addl    $-1, %ebx
        jne     .LBB0_2
        jmp     .LBB0_3
.LBB0_4:                                # %entry.while.end_crit_edge
        leaq    _ZL1x@TLSLD(%rip), %rdi
        callq   __tls_get_addr@PLT
        movl    _ZL1x@DTPOFF(%rax), %ebp

The Redundant TLS Loads will hurt the performance, especially in loops.
So we try to eliminate/move them if required by customers, let it be:

# %bb.0:                                # %entry
         ...
         movl    %edi, %ebx
         leaq    _ZL1x@TLSLD(%rip), %rdi
         callq   __tls_get_addr@PLT
         leaq    _ZL1x@DTPOFF(%rax), %r14
         testl   %ebx, %ebx
         je      .LBB0_1
 .LBB0_2:                                # %while.body
                                         # =>This Inner Loop Header: Depth=1
         callq   _Z1gv@PLT
         addl    (%r14), %eax
         movl    %eax, (%r14)
         addl    $-1, %ebx
         jne     .LBB0_2
         jmp     .LBB0_3

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableControl.cpp

294–296

This pass is very later at Scalar optmization. I think we no need to preserve all. Let me carefully re-consider here, thanks!

llvm/test/CodeGen/X86/tls-loads-control.ll

1

The test contain "!3 = !{i32 1, !"tls-load-control", !"Optimize"}" , it has same functonality with "--tls-load-control=Optimize"
But test both of them here is not bad, I think.

11–13

This test is directly generate from a clang test I'll commit latter.
So let it be the raw result of source file out put (I comment at line 8) is good to check the source of it.
So I didn't manually change it more.

[xiangzhangllvm]

First let me quickly update some parts of it. Thanks a lot!

[LuoYuanke]

llvm/include/llvm/Transforms/Scalar/TLSVariableControl.h

75

I curious why not include the header file BasicBlock.h?

95

uses -> users?

llvm/lib/Transforms/Scalar/TLSVariableControl.cpp

47

"Eleminate remove" -> Eliminate?

136

Drop brace.

[xiangzhangllvm]

llvm/include/llvm/Transforms/Scalar/TLSVariableControl.h

75

We prefer to include the *.h at x.cpp , this make x.h is simple. This style can easy find example in other files, for example "Scalar/GVNSink.cpp"

95

Make sense, The Use self is no problem, it means where is it used. But I name the "struct TLSUser" for its element, let me change it, thanks!

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableControl.cpp

136

I remember we should not remove "{}" for "else" if "if" has "{}"

[xiangzhangllvm]

Refine the code according to reviews, thanks a lot!

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableControl.cpp

115

The pass will change the code "move GV ahead", so let's just preserve CFG here.

294–296

The pass may change the code "move GV ahead", so let's just preserve CFG here.

[xiangzhangllvm]

Refine name "control" --> "hoist"

[xiangzhangllvm]

Fix tests (MLIR.Examples/standalone::test.toy and libFuzzer.libFuzzer::large.test looks no relation with this patch)

[pengfei]

llvm/include/llvm/LinkAllPasses.h

180

Keep the same format looks better. Up to you.

llvm/include/llvm/Transforms/Scalar.h

431

What's "prepares a function" mean?

llvm/include/llvm/Transforms/Scalar/TLSVariableHoist.h

1 ↗

(On Diff #410450)

Still less than 80.

21 ↗

(On Diff #410450)

clang

llvm/test/CodeGen/AArch64/O3-pipeline.ll

69 ↗

(On Diff #410450)

Maybe preserve loop infor too. The pass does nothing with it. This may help with the following passes not run it again.

llvm/test/CodeGen/X86/tls-loads-control.ll

177

There meta data is annoying, especially the OneAPI info here doesn't make sense to llvm. The same below.

llvm/test/CodeGen/X86/tls-loads-control3.ll

161

Add nounwind in attributes to avoid cfi directives.

[xiangzhangllvm]

Address Phoebe's reviews, thanks a lot!

[xiangzhangllvm]

llvm/include/llvm/LinkAllPasses.h

180

Yes, this is follow clang-format, let it be.

llvm/test/CodeGen/AArch64/O3-pipeline.ll

69 ↗

(On Diff #410450)

This pass changed the instructions, so BB info should better be updated.

llvm/test/CodeGen/X86/tls-loads-control.ll

177

Done, but I think keep more info is not bad for test, maybe it is personal habits, I usually prefer to sync the *.ll with the *.c/cpp

llvm/test/CodeGen/X86/tls-loads-control3.ll

161

Add nounwind to #0, but seems cfi still here, anyway, that is not important, I think.

[pengfei]

llvm/test/CodeGen/X86/tls-loads-control3.ll

41–43

data16 and rex64 don't seem correct instructions.

161

Did you re-generate the tests? It should work. lit test will fail if you didn't update the tests.

[xiangzhangllvm]

llvm/test/CodeGen/X86/tls-loads-control3.ll

41–43

Yes, there are prefix not real instruction, I can see them in X86AsmParser.cpp , not clear what they are used for ? Seems no relation with this patch.

161

Yes, re-generate it with update_llc_test_checks.py
let me show my local status:

[xiangzh1@..]$./llvm/utils/update_llc_test_checks.py llvm/test/CodeGen/X86/tls-loads-control3.ll
[xiangzh1@..]$git diff
[xiangzh1@..]$llvm-lit llvm/test/CodeGen/X86/tls-loads-control3.ll
-- Testing: 1 tests, 1 workers --
PASS: LLVM :: CodeGen/X86/tls-loads-control3.ll (1 of 1)

Testing Time: 0.21s
  Passed: 1

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

30 ↗

(On Diff #410479)

Don't know why clang-format will move it ahead, seems clang-format's bug.
Let me re-clang-format for other places.

[xiangzhangllvm]

Do clang format

[pengfei]

LGTM. Please wait some days for other reviewers' opinions.

[craig.topper]

llvm/include/llvm/Transforms/Scalar/TLSVariableHoist.h

64 ↗

(On Diff #410682)

Is SetVector used by this file?

68 ↗

(On Diff #410682)

are any algorithms used in this file?

70 ↗

(On Diff #410682)

Is vector used by this file?

122 ↗

(On Diff #410682)

Varibles -> Variables.

Can we use llvm::MapVector to avoid a separate SmallVector?

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

10 ↗

(On Diff #410682)

exmaple -> example

10 ↗

(On Diff #410682)

PLS -> Please?

131 ↗

(On Diff #410682)

The GV field in TLSCandidate isn't assigned is it?

136 ↗

(On Diff #410682)

TLSCandMap[GV].addUser(Inst, Idx); works even if GV isn't in the map. The entry will be default constructed before addUser is called.

145 ↗

(On Diff #410682)

can we use llvm::any_of here?

186 ↗

(On Diff #410682)

Is this before the allocas?

218 ↗

(On Diff #410682)

Replaced |= tryReplaceTLSCandidate(Fn, GV);

226 ↗

(On Diff #410682)

Should we call skipFunction() for opt-bisect-limit and optnone support?

228 ↗

(On Diff #410682)

Do we normally use capitalized strings?

[craig.topper]

llvm/include/llvm/IR/Module.h

914

Why a module flag? What is the policy for LTO merging?

[xiangzhangllvm]

llvm/include/llvm/IR/Module.h

914

Because the TLS is Global Value which has Scope for module.
I am not clear about the LTO merging, I think one module's flag should not "spread" to another module.

llvm/include/llvm/Transforms/Scalar/TLSVariableHoist.h

122 ↗

(On Diff #410682)

Let me check the MapVector, rarely use it before : ) thanks a lot!

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

131 ↗

(On Diff #410682)

Yes, I should remove the "GV" field from TLSCandidate.

136 ↗

(On Diff #410682)

Yes, So here the "else" means TLSCandMap.count(GV) != 0 (GV is in the map)

145 ↗

(On Diff #410682)

Yes, I checked it, that is good, I never use it before : )

186 ↗

(On Diff #410682)

Sorry, don't much understand,
What the problem if it before allocas ?
This is in IR level and the Global Value do not need "allocas"

218 ↗

(On Diff #410682)

I think "|=" is a bit operation. Here is bool, the stardard way is "||"

226 ↗

(On Diff #410682)

1 Yes, we should consider skipFunction, good catch!
2 optnone will not created this pass at TargetPassConfig.cpp

228 ↗

(On Diff #410682)

I checked the other similar uses, we normally not use capitalized strings, let me change it, thanks a lot!

[craig.topper]

llvm/include/llvm/IR/Module.h

914

The first thing LTO does is merges all modules into a single module. Then the optimization pipeline runs on that unified module.

If we made it a function attribute would anything break? Could two different functions have a different hoisting policy? That would avoid the LTO issue.

llvm/lib/IR/Module.cpp

738

I believe the ModFlagBehavior::Error here controls what happens in LTO. It will fail to merge if the modules have different flags.

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

186 ↗

(On Diff #410682)

The alloca instructions for the function's local variables are the first instructons in the entry basic block. Not if we should be putting the bitcast before them.

218 ↗

(On Diff #410682)

MadeChange |= is a frequent pattern used by passes in llvm.

226 ↗

(On Diff #410682)

There is an optnone function attribute which is different than the global optlevel.

[xiangzhangllvm]

llvm/include/llvm/IR/Module.h

914

OK, let me move it into function attribute. Thanks a lot!

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

186 ↗

(On Diff #410682)

OK, Let me re-place the bitcast position.

226 ↗

(On Diff #410682)

OK, let me check it again, but for skipFunction, I can't call it here, because the TLSVariableHoistPass not inherit FunctionPass,
but I already check it at TLSVariableHoistLegacyPass::runOnFunction.

[LuoYuanke]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

186 ↗

(On Diff #410682)

Would you add a test case with alloca for checking?

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

186 ↗

(On Diff #410682)

Yes, no problem

[xiangzhangllvm]

Address Craig's reviews

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

186 ↗

(On Diff #410682)

Let me refine here a little later, I am considering get the insert position by checking dominate relation to reduce life range.

[craig.topper]

llvm/include/llvm/Transforms/Scalar/TLSVariableHoist.h

68 ↗

(On Diff #410758)

You're not using std::map in this file

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

126 ↗

(On Diff #410758)

Merge into the previous if with ||

135 ↗

(On Diff #410758)

This line should work for the case when GV isn't already in the map. The operator[] on the MapVector will default construct a TLS candidate before calling addUser. So you don't need to check TLSCandMap.count

[craig.topper]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

223 ↗

(On Diff #410758)

This might be handled by the pass manager for the new pass manager. For the old pass manager it is part of skipFunction.

[lebedev.ri]

What are the legality considerations for this transformation,
when is it legal to perform it? I'm mainly confused why it's opt-in.

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

45–52 ↗

(On Diff #410758)

This should be an enum, not strings

[xiangzhangllvm]

In D120000#3341406, @lebedev.ri wrote:

What are the legality considerations for this transformation,
when is it legal to perform it? I'm mainly confused why it's opt-in.

This only try hoist TLS address call, the TLS variable will only used in thread function, so it is always legal to do this transformation in a function.
Sorry, what you mean "opt-in" ?

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

45–52 ↗

(On Diff #410758)

yes, we usually use enum here, but I find string is better/easier, because we don't need to define the enum (sometimes may define 2 or more times if we want to use it in clang, for example transfer a clang option to "-mllvm -tls-load-hoist=xxx")

135 ↗

(On Diff #410758)

Make sense!

223 ↗

(On Diff #410758)

Yes, Both pass manager will call runImpl, it called by "TLSVariableHoistPass::run" and ."TLSVariableHoistLegacyPass::runOnFunction" , (I forget which is new and which is old)

[xiangzhangllvm]

1 Address Craig's reviews.
2 Re-write the function findInsertPos, use dominate relation to choose the insert position, this will help generate shorter life ranges.

[pengfei]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

168 ↗

(On Diff #411048)

You need run clang-format for your new code.

llvm/test/CodeGen/X86/tls.ll

1–8 ↗

(On Diff #411048)

Why remove the existing test?

512–513 ↗

(On Diff #411048)

The existing tests also prefer simple meta data. So remove them in the new test.

[xiangzhangllvm]

Clang-format and recover tls.ll test. Thanks a lot!

[xiangzhangllvm]

Hi Craig, If you feel no problem, I'll submit it in these days. And go on the 2nd patch for clang. Thanks!

(The biggest change from your last review is that I re-write the function findInsertPos, use dominate relation to choose the insert position.)

[MaskRay]

I just noticed this patch from Phabricator "Recent Activity" and did not look into it closely. How does it interact with createCleanupLocalDynamicTLSPass?
Do we need multiple passes to deal with __tls_get_addr calls?

[MaskRay]

Do you have a plan to implement clang -mtls-dialect=gnu2? I have had such a plan for a long time but always have more prioritized work to do...
ld.lld has great TLSDESC support since D116900. If we can add support and let GCC/Clang default to TLS descriptors, there is just no need adding more code dealing with these traditional (legacy) TLS models.

[xiangzhangllvm]

In D120000#3348110, @MaskRay wrote:

Do you have a plan to implement clang -mtls-dialect=gnu2? I have had such a plan for a long time but always have more prioritized work to do...
ld.lld has great TLSDESC support since D116900. If we can add support and let GCC/Clang default to TLS descriptors, there is just no need adding more code dealing with these traditional (legacy) TLS models.

PLS let me take a look on createCleanupLocalDynamicTLSPass, I never read it before.
Could you give me more information about implement clang -mtls-dialect=gnu2? I am happy to do that, PLS let me try. (If my manager not transfer me urgent jobs)

[xiangzhangllvm]

Clear now. The createCleanupLocalDynamicTLSPass is integrated in ISel , it is mostly a local/peephole optimization for variables with same TLS base address.
It can't analysis the TLS variables in different BBs or Loops. PLS refer https://godbolt.org/z/f7WrqK5he
But it is a good supplement for current patch. because it can optimize different TLS variables in local. (Current patch is focus on same TLS variable which used in different BBs or Loops)

[lebedev.ri]

In D120000#3341823, @xiangzhangllvm wrote:

In D120000#3341406, @lebedev.ri wrote:

What are the legality considerations for this transformation,
when is it legal to perform it? I'm mainly confused why it's opt-in.

This only try hoist TLS address call, the TLS variable will only used in thread function, so it is always legal to do this transformation in a function.

What about profitability, is it always a win?

Sorry, what you mean "opt-in" ?

Why is it not enabled by default?

[xiangzhangllvm]

In D120000#3348559, @lebedev.ri wrote:

What about profitability, is it always a win?

It remove duplicated TLS address call, In theory, it has big profitability to win.
But similar with most optimization, I can't say it must win in any case.

Sorry, what you mean "opt-in" ?

Why is it not enabled by default?

This is a general optimization which will affect all targets test, I'd like to enable it by another independent patch with mainly modify tests.

[xiangzhangllvm]

Let me commit it and go on the 2nd patch. Thanks for all your reviews!

[craig.topper]

Did anyone sign off on the new insertion position code? It looks like the only approval is from before you added that. This should have been moved back to needs review.

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

190 ↗

(On Diff #412302)

Why not pass the Loop* you already looked up in the caller. Why get the loop again?

194 ↗

(On Diff #412302)

outmost -> outermost

201 ↗

(On Diff #412302)

I'm not sure that's true. Control flow in IR is explicit, there is no fallthrough. If it's a predecessor it must have a branch instruction of some kind.

[craig.topper]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

156 ↗

(On Diff #412302)

method names should be lowercase

198 ↗

(On Diff #412302)

Predecessor and PreHeader aren't quite the same thing. A PreHeader also has the loop as it's only successor.

[xiangzhangllvm]

No problem, let me revert and refine. Thanks!

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

198 ↗

(On Diff #412302)

Sorry, not much clear about it.
My understand is the PreHeader here not in loop (currently it is the outermost loop), so if here has PreHeader for the loop, we can directly insert the bitcast instruction in PreHeader.
Because the PreHeader must dominate the Loop (It is the only way to go to Loop).

PreHeader
    |
    V
   Loop

[craig.topper]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

198 ↗

(On Diff #412302)

There is a function called getLoopPredecessor and another called getLoopPreheader. You called the former, but named the variable like you called the latter.

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

198 ↗

(On Diff #412302)

Oh! That's really a big mistake! Thanks so much!

[nlopes]

I have some concerns with this patch:

• Why is it adding a new function attribute (tls-load-hoist) that is not documented in LangRef?
• Why can't this transformation be handled with existing optimizations? Adding e.g. the readonly & speculatable attributes should allow GVN & friends to remove duplicates and hoist these out of loops. If not, then maybe existing optimizations should be improved so others benefit as well.

In summary, do we really need this new pass or is this just a hack?

[xiangzhangllvm]

In D120000#3353738, @nlopes wrote:

I have some concerns with this patch:

• Why is it adding a new function attribute (tls-load-hoist) that is not documented in LangRef?

This is only [1/2] patch, the 2nd will add clang option for it, it will enable this optimization by generating function attribute (tls-load-hoist)

• Why can't this transformation be handled with existing optimizations? Adding e.g. the readonly & speculatable attributes should allow GVN & friends to remove duplicates and hoist these out of loops. If not, then maybe existing optimizations should be improved so others benefit as well.

In summary, do we really need this new pass or is this just a hack?

I don't know which existing optimizations can do this job for the TLS Value (A readable/writable Global Value). Force add readonly attribute to a writable GV is OK/Safe ? Is GVN really suitable to directly handle it ? In fact I am not an mid-end expert, If it can, Please let me know, I'll go to take a look.

[xiangzhangllvm]

Address Craig's Review.

[nlopes]

AFAIU, you want to remove redundant calls to __tls_get_addr@PLT.
The question is why are these redundant? Is it because no other function (visible to compiler) can change the memory in a way that changes the result of this function?
If so, we consider this kind of functions as accessing "inaccessible memory" only. The semantics might be more complicated, I don't how TLS works.

If we are able to match a set of existing function attributes with the semantics of these TLS functions, then LLVM will remove the function calls for you.

Since I don't know enough of TLS, I can't help much. But if you describe precisely why these calls are redundant, we can tell you which attributes apply (if any).

[xiangzhangllvm]

Hi, Lopes, first thank you for your attention about it.
First let me give a short explain about TLS Variable:
The TLS Variable can be simply seem as a common Global Value (for example thread_local int thl_x) "shared" by different threads, but each thread read/write it without affect other threads use it.
So each thread used different address of it. The function __tls_get_addr is used to get the specific address of TLS Value for current thread. (You can simply seem thl_x as an array thl_x[thread_num],
and seem tls_get_addr as "return &thl_x[thread_id]"). So in same thread, the call of 'tls_get_addr' for same TLS Variable is never changed.

How TLS Variable show in LLVM IR and MIR:
LLVM do not distinguish TLS Variables by threads, the llvm IR/MIR directly use it like other normal Global Value. (for example load the thl_x is some like " %1 = load i32, i32* @thl_x, align 4"), So the called
function __tls_get_addr is invistiable to mid-end and back-end. That is why current optimization don't work on it.

AFAIK, Adding readonly & speculatable attributes let GVN optimization is not suitable. The main job of GVN is simplify the common expression to one GV. The TLS Variable is already a simple GV.
And constantHoist or LICM is also not suitable to do this (even suppose marking readonly attribute to it is no problem). Currently these 2 passes are very clean/pure to do their job, I don't want to mix them with handling TLS.

What's more current patch is simple and small, easy to control. I don't think intergrate it into other optimization will be more simple or clean.

[nlopes]

Thank you for the explanation!
My confusion I guess stemmed from all the assembly in the comments and tests, which is quite confusing given that the transformation works at IR level.
Anyway, this transformation works by creating some artificial bitcasts that you expect to be carried over to the backend so the lowering can share the calls to the TLS function.

This strategy seems very brittle to me. If some later optimization decides to remove the bitcast, your optimization will stop working. It's very likely that will be the case once opaque pointers take over.

I guess in the end you want a single fn call per variable, which could be introduced always after the allocas? Unless the price for the call is too high, and then you want to restrict it to the paths where it existed already.

I second Roman's question: why is this not enabled by default?
Also, you cannot introduce a new attribute in LLVM IR without documenting it first in LangRef. Also, we don't use attributes to toggle optimizations on/off. Please remove it and use a cmd flag if the optimization can't be enabled by default for some reason.

[craig.topper]

Anyway, this transformation works by creating some artificial bitcasts that you expect to be carried over to the backend so the lowering can share the calls to the TLS function.

This strategy seems very brittle to me. If some later optimization decides to remove the bitcast, your optimization will stop working. It's very likely that will be the case once opaque pointers take over.

Is this much different than the artificial bitcast we use in ConstantHoisting?

[nlopes]

In D120000#3357413, @craig.topper wrote:

Anyway, this transformation works by creating some artificial bitcasts that you expect to be carried over to the backend so the lowering can share the calls to the TLS function.

This strategy seems very brittle to me. If some later optimization decides to remove the bitcast, your optimization will stop working. It's very likely that will be the case once opaque pointers take over.

Is this much different than the artificial bitcast we use in ConstantHoisting?

Didn't know there was a precedent of using this technique. Seems fragile to me, but...

[efriedma]

In D120000#3357639, @nlopes wrote:

In D120000#3357413, @craig.topper wrote:

Anyway, this transformation works by creating some artificial bitcasts that you expect to be carried over to the backend so the lowering can share the calls to the TLS function.

This strategy seems very brittle to me. If some later optimization decides to remove the bitcast, your optimization will stop working. It's very likely that will be the case once opaque pointers take over.

Is this much different than the artificial bitcast we use in ConstantHoisting?

Didn't know there was a precedent of using this technique. Seems fragile to me, but...

This is running late enough in the pipeline that it's probably fine. Optimization passes that are part of of the codegen pipeline, like ConstantHoisting/CodeGenPrepare/etc. have an implicit contract with each other and SelectionDAG to make this sort of thing work.

Really, this transform should handled by some sort of general LICM, but we can't use IR LICM because the operations aren't visible in IR, and we can't use MachineLICM because we can't really hoist calls after isel. (Making MachineLICM handle this isn't impossible, but it gets messy because you're dealing with target-specific call sequences.)

More generally, the current representation of constants in IR isn't ideal, but improving constant expressions isn't really anyone's priority at the moment. Maybe someone will look at it once the opaque pointers are done.

---

Would it make sense to do this transform as part of ConstantHoisting, instead of as a separate transform? Most of the necessary infrastructure is already there.

I don't understand why you'd want a clang flag to control this. The backend knows when it's going to generate a call to get the tls pointer. And when we generate a call, hoisting that call is pretty obviously profitable.

[xiangzhangllvm]

In D120000#3358477, @efriedma wrote:

In D120000#3357639, @nlopes wrote:

In D120000#3357413, @craig.topper wrote:

Anyway, this transformation works by creating some artificial bitcasts that you expect to be carried over to the backend so the lowering can share the calls to the TLS function.

This strategy seems very brittle to me. If some later optimization decides to remove the bitcast, your optimization will stop working. It's very likely that will be the case once opaque pointers take over.

Didn't know there was a precedent of using this technique. Seems fragile to me, but...

This is running late enough in the pipeline that it's probably fine. Optimization passes that are part of of the codegen pipeline, like ConstantHoisting/CodeGenPrepare/etc. have an implicit contract with each other and SelectionDAG to make this sort of thing work.

Yes, @nlopes , I think efriedma has answered your question, and that is why I put the TLSHoist pass at the late pass of mid-end.

Really, this transform should handled by some sort of general LICM, but we can't use IR LICM because the operations aren't visible in IR, and we can't use MachineLICM because we can't really hoist calls after isel. (Making MachineLICM handle this isn't impossible, but it gets messy because you're dealing with target-specific call sequences.)

Yes, that is right, but for MIR, it still can not see the call func (__tls_get_addr), MIR just mark the TLS with a flag, some like:

TLS_base_addr64 $noreg, 1, $noreg, target-flags(x86-tlsld) @thl_x, $noreg,   ...

And MachineLICM only focus on Loops, current patch want to handle the duplicated call in all the function.

Is this much different than the artificial bitcast we use in ConstantHoisting?

More generally, the current representation of constants in IR isn't ideal, but improving constant expressions isn't really anyone's priority at the moment. Maybe someone will look at it once the opaque pointers are done.
Would it make sense to do this transform as part of ConstantHoisting, instead of as a separate transform? Most of the necessary infrastructure is already there.

In fact, I though about it when I begin do this job, their logic is similar. The main reason I didn't go such way (integrate them) is

1. I want to let TLS hoist pass more later than it.
2. I want to keep ConstantHoisting is pure to handle Constant (In fact, TLS is not constant).
3. Let TLSHoist be simple and easy to control (enable or disable it).

I second Roman's question: why is this not enabled by default?

I answer this question before, just want to split the tests updates into a independent patch.
I don't want to let the patch too big. I wish we can quickly push this part in, and go on the next one.

Also, you cannot introduce a new attribute in LLVM IR without documenting it first in >LangRef. Also, we don't use attributes to toggle optimizations on/off. Please remove it >and use a cmd flag if the optimization can't be enabled by default for some reason.
I don't understand why you'd want a clang flag to control this. The backend knows when it's going to generate a call to get the tls pointer. And when we generate a call, hoisting that call is pretty obviously profitable.

Because I want to add an clang option for it. So I provide such a function attribute (flag) to let clang option "control" it.
May be this is not good idea, but I think that is another independent topic, I can refine it in [2/2] patch.

[xiangzhangllvm]

Hello, anybody still have question or concern ? （I think the discussion before is clear.）

[xiangzhangllvm]

Hello @craig.topper , I think you have reviewed all the code, could you help accept it ?
It has last a long time, I wish to go on it. Thanks a lot!

[efriedma]

One minor concern; otherwise seems fine.

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

52 ↗

(On Diff #412365)

Why is this off by default? Do you plan to turn it on by default in a followup?

[craig.topper]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

200 ↗

(On Diff #412365)

If the Preheader exists, it isn't empty. It will always have a branch to the loop. There are no fallthroughs in IR. So the terminator will not be nullptr.

239 ↗

(On Diff #412365)

Why would DT be null? The pass has DominatorTree as a requirement.

248 ↗

(On Diff #412365)

Why would LI be null? The pass has it as a requirement

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

52 ↗

(On Diff #412365)

Yes, As I answered this question before, the last patch [3/3] will turn it on and update
affected tests.

200 ↗

(On Diff #412365)

Eh ..., Yes, Seems make sense, just a question, in which case there will be an empty BB in IR level ? (even the last BB I see is always append with ret instruction) .
I check the BasicBlock::getTerminator() , it is possible return nullptr.

const Instruction *BasicBlock::getTerminator() const {
  if (InstList.empty() || !InstList.back().isTerminator())
    return nullptr;
  return &InstList.back();
}

239 ↗

(On Diff #412365)

I am not sure if its requirement will must successful build/generate a DominatorTree.
Or here let me change to assert (DT) ?

248 ↗

(On Diff #412365)

The same with DT, thanks for your review!

[craig.topper]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

200 ↗

(On Diff #412365)

It can happen when the basic block is first created and not connected to the CFG. But if it's connected, it has a terminator. The successor list of a basic block is stored directly in the terminator instruction. The predecessor list is found by iterating all of the users of the BasicBlock* and looking at which uses are terminator instructions.

[craig.topper]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

239 ↗

(On Diff #412365)

You can use assert(DT)

[xiangzhangllvm]

Address Craig's review
+ add function attribute "tls-load-hoist" to /docs/LangRef.rst

[xiangzhangllvm]

llvm/lib/Transforms/Scalar/TLSVariableHoist.cpp

200 ↗

(On Diff #412365)

Thanks for your explain!

[xiangzhangllvm]

If no problem, anyone can help re-accepted it? Let me go on. Thanks a lot!

[xiangzhangllvm]

Hello @craig.topper Could you help re-accept it?
I think there is no big problem after times of review, what's more, currently this pass is disable in default.

[craig.topper]

LGTM

[xiangzhangllvm]

Thanks you so much!
Thanks for all reviews!

llvm/include/llvm/CodeGen/CodeGenPassBuilder.h

 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Scalar/ConstantHoisting.h"
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
 #include "llvm/Transforms/Scalar/MergeICmps.h"
 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
 #include "llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h"
+//#include "llvm/Transforms/Scalar/Intel_TLSVariableControl.h" //zxzx
 #include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
 #include "llvm/Transforms/Utils/LowerInvoke.h"
 #include <cassert>
 #include <type_traits>
 #include <utility>
 
 namespace llvm {

llvm/include/llvm/CodeGen/MachinePassRegistry.def

 FUNCTION_PASS("replace-with-veclib", ReplaceWithVeclib, ())
 FUNCTION_PASS("partially-inline-libcalls", PartiallyInlineLibCallsPass, ())
 FUNCTION_PASS("ee-instrument", EntryExitInstrumenterPass, (false))
 FUNCTION_PASS("post-inline-ee-instrument", EntryExitInstrumenterPass, (true))
 FUNCTION_PASS("expand-reductions", ExpandReductionsPass, ())
 FUNCTION_PASS("expandvp", ExpandVectorPredicationPass, ())
 FUNCTION_PASS("lowerinvoke", LowerInvokePass, ())
 FUNCTION_PASS("scalarize-masked-mem-intrin", ScalarizeMaskedMemIntrinPass, ())
+FUNCTION_PASS("tlscontrol", TLSVariableControlPass, ())
 FUNCTION_PASS("verify", VerifierPass, ())
 #undef FUNCTION_PASS
 
 #ifndef LOOP_PASS
 #define LOOP_PASS(NAME, PASS_NAME, CONSTRUCTOR)
 #endif
 LOOP_PASS("loop-reduce", LoopStrengthReducePass, ())
 #undef LOOP_PASS

llvm/include/llvm/IR/Module.h

/// @}
   /// "sysreg".
   StringRef getStackProtectorGuardReg() const;
   void setStackProtectorGuardReg(StringRef Reg);
 
   /// Get/set what offset from the stack protector to use.
   int getStackProtectorGuardOffset() const;
   void setStackProtectorGuardOffset(int Offset);
 
+   /// Get/set the model of TLS address loading.
+   StringRef getTlsAddrLoadControl() const;
+   void setTlsAddrLoadControl(StringRef Model);
+
   /// Get/set the stack alignment overridden from the default.
   unsigned getOverrideStackAlignment() const;
   void setOverrideStackAlignment(unsigned Align);
 
   /// @name Utility functions for querying and setting the build SDK version
   /// @{
 
   /// Attach a build SDK version metadata to this module.

llvm/include/llvm/InitializePasses.h

 void initializeStripSymbolsPass(PassRegistry&);
 void initializeStructurizeCFGLegacyPassPass(PassRegistry &);
 void initializeTailCallElimPass(PassRegistry&);
 void initializeTailDuplicatePass(PassRegistry&);
 void initializeTargetLibraryInfoWrapperPassPass(PassRegistry&);
 void initializeTargetPassConfigPass(PassRegistry&);
 void initializeTargetTransformInfoWrapperPassPass(PassRegistry&);
 void initializeThreadSanitizerLegacyPassPass(PassRegistry&);
+void initializeTLSVariableControlLegacyPassPass(PassRegistry&);
 void initializeTwoAddressInstructionPassPass(PassRegistry&);
 void initializeTypeBasedAAWrapperPassPass(PassRegistry&);
 void initializeTypePromotionPass(PassRegistry&);
 void initializeUnifyFunctionExitNodesLegacyPassPass(PassRegistry &);
 void initializeUnifyLoopExitsLegacyPassPass(PassRegistry &);
 void initializeUnpackMachineBundlesPass(PassRegistry&);
 void initializeUnreachableBlockElimLegacyPassPass(PassRegistry&);
 void initializeUnreachableMachineBlockElimPass(PassRegistry&);

llvm/include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createSafeStackPass();
       (void) llvm::createSROAPass();
       (void) llvm::createSingleLoopExtractorPass();
       (void) llvm::createStripSymbolsPass();
       (void) llvm::createStripNonDebugSymbolsPass();
       (void) llvm::createStripDeadDebugInfoPass();
       (void) llvm::createStripDeadPrototypesPass();
       (void) llvm::createTailCallEliminationPass();
+      (void) llvm::createTLSVariableControlPass();
       (void) llvm::createJumpThreadingPass();
       (void) llvm::createDFAJumpThreadingPass();
       (void) llvm::createUnifyFunctionExitNodesPass();
       (void) llvm::createInstCountPass();
       (void) llvm::createConstantHoistingPass();
       (void) llvm::createCodeGenPreparePass();
       (void) llvm::createEntryExitInstrumenterPass();
       (void) llvm::createPostInlineEntryExitInstrumenterPass();

llvm/include/llvm/Transforms/Scalar.h

 //===----------------------------------------------------------------------===//
 //
 // LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates
 // "block_weights" metadata.
 FunctionPass *createLowerExpectIntrinsicPass();
 
 //===----------------------------------------------------------------------===//
 //
+// TLSVariableControl - This pass prepares a function for expensive TLSVariable.
+//
+FunctionPass *createTLSVariableControlPass();
+
+//===----------------------------------------------------------------------===//
+//
 // LowerConstantIntrinsicss - Expand any remaining llvm.objectsize and
 // llvm.is.constant intrinsic calls, even for the unknown cases.
 //
 FunctionPass *createLowerConstantIntrinsicsPass();
 
 //===----------------------------------------------------------------------===//
 //
 // PartiallyInlineLibCalls - Tries to inline the fast path of library

llvm/include/llvm/Transforms/Scalar/TLSVariableControl.h

+//==- TLSVariableControl.h - Remove Redundant TLS Loads --*- C++ -*-==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass identifies/eliminate Redundant TLS Loads if related option is set.
+// For example:
+// static __thread int x;
+// int g();
+// int f(int c) {
+//   int *px = &x;
+//   while (c--)
+//     *px += g();
+//   return *px;
+// }
+//
+// will generated Redundant TLS Loads by compiling it with
+// Clang++ -fPIC -ftls-model=global-dynamic -O2 -S
+//
+// .LBB0_2:                                # %while.body
+//                                         # =>This Inner Loop Header: Depth=1
+//         callq   _Z1gv@PLT
+//         movl    %eax, %ebp
+//         leaq    _ZL1x@TLSLD(%rip), %rdi
+//         callq   __tls_get_addr@PLT
+//         addl    _ZL1x@DTPOFF(%rax), %ebp
+//         movl    %ebp, _ZL1x@DTPOFF(%rax)
+//         addl    $-1, %ebx
+//         jne     .LBB0_2
+//         jmp     .LBB0_3
+// .LBB0_4:                                # %entry.while.end_crit_edge
+//         leaq    _ZL1x@TLSLD(%rip), %rdi
+//         callq   __tls_get_addr@PLT
+//         movl    _ZL1x@DTPOFF(%rax), %ebp
+//
+// The Redundant TLS Loads will hurt the performance, especially in loops.
+// So we try to eliminate/move them if required by customers, let it be:
+//
+// # %bb.0:                                # %entry
+//         ...
+//         movl    %edi, %ebx
+//         leaq    _ZL1x@TLSLD(%rip), %rdi
+//         callq   __tls_get_addr@PLT
+//         leaq    _ZL1x@DTPOFF(%rax), %r14
+//         testl   %ebx, %ebx
+//         je      .LBB0_1
+// .LBB0_2:                                # %while.body
+//                                         # =>This Inner Loop Header: Depth=1
+//         callq   _Z1gv@PLT
+//         addl    (%r14), %eax
+//         movl    %eax, (%r14)
+//         addl    $-1, %ebx
+//         jne     .LBB0_2
+//         jmp     .LBB0_3
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_SCALAR_TLSVARIABLECONTROL_H
+#define LLVM_TRANSFORMS_SCALAR_TLSVARIABLECONTROL_H
+
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Analysis/LoopInfo.h"
+#include "llvm/IR/PassManager.h"
+#include <algorithm>
+#include <map>
+#include <vector>
+
+namespace llvm {
+
+class BasicBlock;
+class DominatorTree;
+class Function;
+class GlobalVariable;
+class Instruction;
+
+/// A private "module" namespace for types and utilities used by
+/// TLSVariableControl. These are implementation details and should
+/// not be used by clients.
+namespace tlscontrol {
+
+/// Keeps track of the user of a TLS variable and the operand index
+/// where the variable is used.
+struct TLSUser {
+  Instruction *Inst;
+  unsigned OpndIdx;
+
+  TLSUser(Instruction *Inst, unsigned Idx) : Inst(Inst), OpndIdx(Idx) {}
+};
+
+using TLSUseListType = SmallVector<TLSUser, 8>;
+
+/// Keeps track of a TLS variable candidate and its uses.
+struct TLSCandidate {
+  TLSUseListType Uses;
+  GlobalVariable *GV;
+
+  TLSCandidate(GlobalVariable *GV = nullptr) : GV(GV) {}
+
+  /// Add the user to the use list and update the cost.
+  void addUser(Instruction *Inst, unsigned Idx) {
+    Uses.push_back(TLSUser(Inst, Idx));
+  }
+};
+
+using TLSCandidateListType = SmallVector<TLSCandidate, 8>;
+
+} // end namespace tlscontrol
+
+class TLSVariableControlPass : public PassInfoMixin<TLSVariableControlPass> {
+public:
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+  // Glue for old PM.
+  bool runImpl(Function &F, DominatorTree &DT, LoopInfo &LI);
+
+  void collectTLSCandidates(Function &Fn);
+  void collectTLSCandidate(Instruction *Inst);
+  bool tryReplaceTLSCandidates(Function &Fn);
+  bool tryReplaceTLSCandidate(Function &Fn, tlscontrol::TLSCandidate &Cand);
+  Instruction *findMatInsertPt(Instruction *Inst, unsigned Idx = ~0U) const;
+
+private:
+  DominatorTree *DT;
+  LoopInfo *LI;
+
+  /// Keeps track of TLS variable candidates found in the function.
+  using TLSCandMapType = std::map<GlobalVariable *, tlscontrol::TLSCandidate>;
+  TLSCandMapType TLSCandMap;
+
+  /// Use GVs to make sure the order of TLS Global Varibles.
+  SmallVector<GlobalVariable *> GVs;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_SCALAR_TLSVARIABLECONTROL_H

llvm/lib/CodeGen/TargetPassConfig.cpp

void TargetPassConfig::addIRPasses() {
   // the unsupported intrinsic will be replaced with a chain of basic blocks,
   // that stores/loads element one-by-one if the appropriate mask bit is set.
   addPass(createScalarizeMaskedMemIntrinLegacyPass());
 
   // Expand reduction intrinsics into shuffle sequences if the target wants to.
   // Allow disabling it for testing purposes.
   if (!DisableExpandReductions)
     addPass(createExpandReductionsPass());
+
+  if (getOptLevel() != CodeGenOpt::None)
+    addPass(createTLSVariableControlPass());
 }
 
 /// Turn exception handling constructs into something the code generators can
 /// handle.
 void TargetPassConfig::addPassesToHandleExceptions() {
   const MCAsmInfo *MCAI = TM->getMCAsmInfo();
   assert(MCAI && "No MCAsmInfo");
   switch (MCAI->getExceptionHandlingType()) {

llvm/lib/IR/Module.cpp

if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
     return CI->getSExtValue();
   return INT_MAX;
 }
 
 void Module::setStackProtectorGuardOffset(int Offset) {
   addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-offset", Offset);
 }
 
+StringRef Module::getTlsAddrLoadControl() const {
+  Metadata *MD = getModuleFlag("tls-load-control");
+  if (auto *MDS = dyn_cast_or_null<MDString>(MD))
+    return MDS->getString();
+  return {};
+}
+
+void Module::setTlsAddrLoadControl(StringRef Model) {
+  MDString *ID = MDString::get(getContext(), Model);
+  addModuleFlag(ModFlagBehavior::Error, "tls-load-control", ID);
+}
+
 unsigned Module::getOverrideStackAlignment() const {
   Metadata *MD = getModuleFlag("override-stack-alignment");
   if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
     return CI->getZExtValue();
   return 0;
 }
 
 void Module::setOverrideStackAlignment(unsigned Align) {

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/Scalar/Scalarizer.h"
 #include "llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h"
 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
 #include "llvm/Transforms/Scalar/Sink.h"
 #include "llvm/Transforms/Scalar/SpeculativeExecution.h"
 #include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h"
 #include "llvm/Transforms/Scalar/StructurizeCFG.h"
 #include "llvm/Transforms/Scalar/TailRecursionElimination.h"
+#include "llvm/Transforms/Scalar/TLSVariableControl.h"
 #include "llvm/Transforms/Scalar/WarnMissedTransforms.h"
 #include "llvm/Transforms/Utils/AddDiscriminators.h"
 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
 #include "llvm/Transforms/Utils/BreakCriticalEdges.h"
 #include "llvm/Transforms/Utils/CanonicalizeAliases.h"
 #include "llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h"
 #include "llvm/Transforms/Utils/Debugify.h"
 #include "llvm/Transforms/Utils/EntryExitInstrumenter.h"

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("verify<domtree>", DominatorTreeVerifierPass())
 FUNCTION_PASS("verify<loops>", LoopVerifierPass())
 FUNCTION_PASS("verify<memoryssa>", MemorySSAVerifierPass())
 FUNCTION_PASS("verify<regions>", RegionInfoVerifierPass())
 FUNCTION_PASS("verify<safepoint-ir>", SafepointIRVerifierPass())
 FUNCTION_PASS("verify<scalar-evolution>", ScalarEvolutionVerifierPass())
 FUNCTION_PASS("view-cfg", CFGViewerPass())
 FUNCTION_PASS("view-cfg-only", CFGOnlyViewerPass())
+FUNCTION_PASS("tlscontrol", TLSVariableControlPass())
 FUNCTION_PASS("transform-warning", WarnMissedTransformationsPass())
 FUNCTION_PASS("tsan", ThreadSanitizerPass())
 FUNCTION_PASS("memprof", MemProfilerPass())
 #undef FUNCTION_PASS
 
 #ifndef FUNCTION_PASS_WITH_PARAMS
 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
 #endif

llvm/lib/Transforms/Scalar/CMakeLists.txt

add_llvm_component_library(LLVMScalarOpts
   SeparateConstOffsetFromGEP.cpp
   SimpleLoopUnswitch.cpp
   SimplifyCFGPass.cpp
   Sink.cpp
   SpeculativeExecution.cpp
   StraightLineStrengthReduce.cpp
   StructurizeCFG.cpp
   TailRecursionElimination.cpp
+  TLSVariableControl.cpp
   WarnMissedTransforms.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms/Scalar
 
   DEPENDS
   intrinsics_gen

llvm/lib/Transforms/Scalar/Scalar.cpp

void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeScalarizeMaskedMemIntrinLegacyPassPass(Registry);
   initializeSCCPLegacyPassPass(Registry);
   initializeSROALegacyPassPass(Registry);
   initializeCFGSimplifyPassPass(Registry);
   initializeStructurizeCFGLegacyPassPass(Registry);
   initializeSimpleLoopUnswitchLegacyPassPass(Registry);
   initializeSinkingLegacyPassPass(Registry);
   initializeTailCallElimPass(Registry);
+  initializeTLSVariableControlLegacyPassPass(Registry);
   initializeSeparateConstOffsetFromGEPLegacyPassPass(Registry);
   initializeSpeculativeExecutionLegacyPassPass(Registry);
   initializeStraightLineStrengthReduceLegacyPassPass(Registry);
   initializePlaceBackedgeSafepointsImplPass(Registry);
   initializePlaceSafepointsPass(Registry);
   initializeFloat2IntLegacyPassPass(Registry);
   initializeLoopDistributeLegacyPass(Registry);
   initializeLoopLoadEliminationPass(Registry);

llvm/lib/Transforms/Scalar/TLSVariableControl.cpp

+//===- TLSVariableControl.cpp - Remove Redundant TLS Loads --------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass identifies/eliminate Redundant TLS Loads if related option is set.
+// For exmaple:
+// static __thread int x;
+// int g();
+// int f(int c) {
+//   int *px = &x;
+//   while (c--)
+//     *px += g();
+//   return *px;
+// }
+//
+// will generated Redundant TLS Loads by compiling it with
+// Clang++ -fPIC -ftls-model=global-dynamic -O2 -S
+//
+// .LBB0_2:                                # %while.body
+//                                         # =>This Inner Loop Header: Depth=1
+//         callq   _Z1gv@PLT
+//         movl    %eax, %ebp
+//         leaq    _ZL1x@TLSLD(%rip), %rdi
+//         callq   __tls_get_addr@PLT
+//         addl    _ZL1x@DTPOFF(%rax), %ebp
+//         movl    %ebp, _ZL1x@DTPOFF(%rax)
+//         addl    $-1, %ebx
+//         jne     .LBB0_2
+//         jmp     .LBB0_3
+// .LBB0_4:                                # %entry.while.end_crit_edge
+//         leaq    _ZL1x@TLSLD(%rip), %rdi
+//         callq   __tls_get_addr@PLT
+//         movl    _ZL1x@DTPOFF(%rax), %ebp
+//
+// The Redundant TLS Loads will hurt the performance, especially in loops.
+// So we try to eliminate/move them if required by customers, let it be:
+//
+// # %bb.0:                                # %entry
+//         ...
+//         movl    %edi, %ebx
+//         leaq    _ZL1x@TLSLD(%rip), %rdi
+//         callq   __tls_get_addr@PLT
+//         leaq    _ZL1x@DTPOFF(%rax), %r14
+//         testl   %ebx, %ebx
+//         je      .LBB0_1
+// .LBB0_2:                                # %while.body
+//                                         # =>This Inner Loop Header: Depth=1
+//         callq   _Z1gv@PLT
+//         addl    (%r14), %eax
+//         movl    %eax, (%r14)
+//         addl    $-1, %ebx
+//         jne     .LBB0_2
+//         jmp     .LBB0_3
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Value.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Scalar/TLSVariableControl.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <tuple>
+#include <utility>
+
+using namespace llvm;
+using namespace tlscontrol;
+
+#define DEBUG_TYPE "tlscontrol"
+
+static cl::opt<std::string> TLSLoadControl(
+    "tls-load-control",
+    cl::desc("Control the TLS loads in PIC model: "
+             "tls-load-control=Optimize: Eleminate remove redundant TLS load(s)."
+             "tls-load-control=Strict: Strictly load TLS address before every use."
+             "tls-load-control=Non-Optimize: Generally load TLS before use(s)."),
+    cl::init("Non-Optimize"), cl::Hidden);
+
+namespace {
+
+/// The TLS Variable Control pass.
+class TLSVariableControlLegacyPass : public FunctionPass {
+public:
+  static char ID; // Pass identification, replacement for typeid
+
+  TLSVariableControlLegacyPass() : FunctionPass(ID) {
+    initializeTLSVariableControlLegacyPassPass(
+        *PassRegistry::getPassRegistry());
+  }
+
+  bool runOnFunction(Function &Fn) override;
+
+  StringRef getPassName() const override { return "TLS Variable Control"; }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesCFG();
+    AU.addRequired<DominatorTreeWrapperPass>();
+    AU.addRequired<LoopInfoWrapperPass>();
+  }
+
+private:
+  TLSVariableControlPass Impl;
+};
+
+} // end anonymous namespace
+
+char TLSVariableControlLegacyPass::ID = 0;
+
+INITIALIZE_PASS_BEGIN(TLSVariableControlLegacyPass, "tlscontrol",
+                      "TLS Variable Control", false, false)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
+INITIALIZE_PASS_END(TLSVariableControlLegacyPass, "tlscontrol",
+                    "TLS Variable Control", false, false)
+
+FunctionPass *llvm::createTLSVariableControlPass() {
+  return new TLSVariableControlLegacyPass();
+}
+
+/// Perform the TLS Variable Control optimization for the given function.
+bool TLSVariableControlLegacyPass::runOnFunction(Function &Fn) {
+  if (skipFunction(Fn))
+    return false;
+
+  LLVM_DEBUG(dbgs() << "********** Begin TLS Variable Control **********\n");
+  LLVM_DEBUG(dbgs() << "********** Function: " << Fn.getName() << '\n');
+
+  bool MadeChange =
+      Impl.runImpl(Fn, getAnalysis<DominatorTreeWrapperPass>().getDomTree(),
+                   getAnalysis<LoopInfoWrapperPass>().getLoopInfo());
+
+  if (MadeChange) {
+    LLVM_DEBUG(dbgs() << "********** Function after TLS Variable Control: "
+                      << Fn.getName() << '\n');
+    LLVM_DEBUG(dbgs() << Fn);
+  }
+  LLVM_DEBUG(dbgs() << "********** End TLS Variable Control **********\n");
+
+  return MadeChange;
+}
+
+void TLSVariableControlPass::collectTLSCandidate(Instruction *Inst) {
+  // Skip all cast instructions. They are visited indirectly later on.
+  if (Inst->isCast())
+    return;
+
+  // Scan all operands.
+  for (unsigned Idx = 0, E = Inst->getNumOperands(); Idx != E; ++Idx) {
+    auto *GV = dyn_cast<GlobalVariable>(Inst->getOperand(Idx));
+    if (!GV)
+      continue;
+    if (!GV->isThreadLocal())
+      continue;
+
+    // Add Candidate to TLSCandMap (GV --> Candidate).
+    if (TLSCandMap.count(GV) == 0) {
+      tlscontrol::TLSCandidate Candidate(GV);
+      Candidate.addUser(Inst, Idx);
+      TLSCandMap[GV] = Candidate;
+      GVs.push_back(GV);
+    } else {
+      TLSCandMap[GV].addUser(Inst, Idx);
+    }
+  } // end of for all operands
+}
+
+void TLSVariableControlPass::collectTLSCandidates(Function &Fn) {
+  // First, quickly check if there is TLS Variable.
+  Module *M = Fn.getParent();
+  bool HasTLS = false;
+  for (GlobalVariable &GV : M->globals()) {
+    if (GV.isThreadLocal()) {
+      HasTLS = true;
+      break;
+    }
+  }
+
+  // If non, directly return.
+  if (!HasTLS)
+    return;
+
+  TLSCandMap.clear();
+  GVs.clear();
+
+  // Then, collect TLS Variable info.
+  for (BasicBlock &BB : Fn) {
+    // Ignore unreachable basic blocks.
+    if (!DT->isReachableFromEntry(&BB))
+      continue;
+
+    for (Instruction &Inst : BB)
+      collectTLSCandidate(&Inst);
+  }
+}
+
+static bool OneUseOutsideLoop(tlscontrol::TLSCandidate &Cand, LoopInfo *LI) {
+  if (Cand.Uses.size() != 1)
+    return false;
+
+  BasicBlock *BB = Cand.Uses[0].Inst->getParent();
+  if (LI && LI->getLoopFor(BB))
+    return false;
+
+  return true;
+}
+
+// Generate a bitcast (no type change) to replace the uses of TLS Candidate.
+// TODO: Any better insert position ?
+// Currently insert in Entry block (except sched move it to better position)
+static Instruction *genBitCastInst(Function &Fn,
+                                   tlscontrol::TLSCandidate &Cand) {
+  BasicBlock &Entry = Fn.getEntryBlock();
+  BasicBlock::iterator Iter = Entry.getFirstInsertionPt();
+  Type *Ty = Cand.GV->getType();
+  auto *CastInst = new BitCastInst(Cand.GV, Ty, "tls_bitcast");
+  Entry.getInstList().insert(Iter, CastInst);
+  return CastInst;
+}
+
+bool TLSVariableControlPass::tryReplaceTLSCandidate(
+    Function &Fn, tlscontrol::TLSCandidate &Cand) {
+  // If only used 1 time and not in loops, we no need to replace it.
+  if (OneUseOutsideLoop(Cand, LI))
+    return false;
+
+  // Generate a bitcast (no type change)
+  auto *CastInst = genBitCastInst(Fn, Cand);
+
+  // to replace the uses of TLS Candidate
+  for (auto &Use : Cand.Uses)
+    Use.Inst->setOperand(Use.OpndIdx, CastInst);
+
+  return true;
+}
+
+bool TLSVariableControlPass::tryReplaceTLSCandidates(Function &Fn) {
+  if (TLSCandMap.empty())
+    return false;
+
+  bool Replaced = false;
+  for (auto *GV : GVs) {
+    Replaced = tryReplaceTLSCandidate(Fn, TLSCandMap[GV]) || Replaced;
+  }
+
+  return Replaced;
+}
+
+/// Optimize expensive TLS variables in the given function.
+bool TLSVariableControlPass::runImpl(Function &Fn, DominatorTree &DT,
+                                     LoopInfo &LI) {
+  bool MadeChange = false;
+  Module *M = Fn.getParent();
+  if (TLSLoadControl != "Optimize" && M->getTlsAddrLoadControl() != "Optimize")
+    return MadeChange;
+
+  this->LI = &LI;
+  this->DT = &DT;
+  // Collect all TLS variable candidates.
+  collectTLSCandidates(Fn);
+
+  MadeChange = tryReplaceTLSCandidates(Fn);
+
+  return MadeChange;
+}
+
+PreservedAnalyses TLSVariableControlPass::run(Function &F,
+                                              FunctionAnalysisManager &AM) {
+
+  auto &LI = AM.getResult<LoopAnalysis>(F);
+  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
+
+  if (!runImpl(F, DT, LI))
+    return PreservedAnalyses::all();
+
+  PreservedAnalyses PA;
+  PA.preserveSet<CFGAnalyses>();
+  return PA;
+}

llvm/test/CodeGen/X86/tls-loads-control.ll

+; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlscontrol --relocation-model=pic --tls-load-control=Optimize -o - %s | FileCheck %s --check-prefixes=CONTROL0
+; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlscontrol --relocation-model=pic -o - %s | FileCheck %s --check-prefixes=CONTROL0
+
+; The module flag {"tls-load-control", Optimize} is equal with option --tls-load-control=Optimize
+; Currently --tls-load-control=Non-Optimize / {"tls-load-control", Non-Optimize } / non module flag
+; are default action, non module flag test refer to intel-tls-loads-control2.ll.
+
+; This test come from compiling clang/test/CodeGen/intel/tls_loads.cpp with:
+; (clang tls_loads.cpp -fPIC -ftls-model=global-dynamic -mtls-load-control=Optimize -O2 -S -emit-llvm)
+
+$_ZTW5thl_x = comdat any
+
+$_ZTW6thl_x2 = comdat any
+
+@thl_x = thread_local global i32 0, align 4
+@thl_x2 = thread_local global i32 0, align 4
+@_ZZ2f2iE2st.0 = internal thread_local unnamed_addr global i8 0, align 4
+@_ZZ2f2iE2st.1 = internal thread_local unnamed_addr global i32 0, align 4
+
+; Function Attrs: mustprogress uwtable
+define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 {
+; CONTROL0-LABEL: _Z2f1i
+; CONTROL0:      entry:
+; CONTROL0-NEXT:   %tls_bitcast1 = bitcast i32* @thl_x2 to i32*
+; CONTROL0-NEXT:   %tls_bitcast = bitcast i32* @thl_x to i32*
+; CONTROL0-NEXT:   %tobool.not3 = icmp eq i32 %c, 0
+; CONTROL0-NEXT:   br i1 %tobool.not3, label %entry.while.end_crit_edge, label %while.body
+;
+; CONTROL0:      entry.while.end_crit_edge:                        ; preds = %entry
+; CONTROL0-NEXT:   %.pre = load i32, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:   br label %while.end
+;
+; CONTROL0:      while.body:                                       ; preds = %while.body, %entry
+; CONTROL0-NEXT:   %c.addr.04 = phi i32 [ %dec, %while.body ], [ %c, %entry ]
+; CONTROL0-NEXT:   %dec = add nsw i32 %c.addr.04, -1
+; CONTROL0-NEXT:   %0 = load i32, i32* %tls_bitcast1, align 4, !tbaa !5
+; CONTROL0-NEXT:   %call = tail call i32 @_Z6gfunc2i(i32 %0)
+; CONTROL0-NEXT:   %1 = load i32, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:   %add = add nsw i32 %1, %call
+; CONTROL0-NEXT:   store i32 %add, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:   %tobool.not = icmp eq i32 %dec, 0
+; CONTROL0-NEXT:   br i1 %tobool.not, label %while.end, label %while.body, !llvm.loop !9
+;
+; CONTROL0:      while.end:                                        ; preds = %while.body, %entry.while.end_crit_edge
+; CONTROL0-NEXT:   %2 = phi i32 [ %.pre, %entry.while.end_crit_edge ], [ %add, %while.body ]
+; CONTROL0-NEXT:   ret i32 %2
+; CONTROL0-NEXT: }
+entry:
+  %tobool.not3 = icmp eq i32 %c, 0
+  br i1 %tobool.not3, label %entry.while.end_crit_edge, label %while.body
+
+entry.while.end_crit_edge:                        ; preds = %entry
+  %.pre = load i32, i32* @thl_x, align 4, !tbaa !5
+  br label %while.end
+
+while.body:                                       ; preds = %entry, %while.body
+  %c.addr.04 = phi i32 [ %dec, %while.body ], [ %c, %entry ]
+  %dec = add nsw i32 %c.addr.04, -1
+  %0 = load i32, i32* @thl_x2, align 4, !tbaa !5
+  %call = tail call i32 @_Z6gfunc2i(i32 %0)
+  %1 = load i32, i32* @thl_x, align 4, !tbaa !5
+  %add = add nsw i32 %1, %call
+  store i32 %add, i32* @thl_x, align 4, !tbaa !5
+  %tobool.not = icmp eq i32 %dec, 0
+  br i1 %tobool.not, label %while.end, label %while.body, !llvm.loop !9
+
+while.end:                                        ; preds = %while.body, %entry.while.end_crit_edge
+  %2 = phi i32 [ %.pre, %entry.while.end_crit_edge ], [ %add, %while.body ]
+  ret i32 %2
+}
+
+declare i32 @_Z6gfunc2i(i32) local_unnamed_addr #1
+
+; Function Attrs: mustprogress uwtable
+define i32 @_Z2f2i(i32 %c) local_unnamed_addr #0 {
+; CONTROL0-LABEL: _Z2f2i
+; CONTROL0:      entry:
+; CONTROL0-NEXT:   %tls_bitcast2 = bitcast i32* @_ZZ2f2iE2st.1 to i32*
+; CONTROL0-NEXT:   %tls_bitcast1 = bitcast i8* @_ZZ2f2iE2st.0 to i8*
+; CONTROL0-NEXT:   %tls_bitcast = bitcast i32* @thl_x to i32*
+; CONTROL0-NEXT:   %tobool.not9 = icmp eq i32 %c, 0
+; CONTROL0-NEXT:   br i1 %tobool.not9, label %while.end, label %while.body
+;
+; CONTROL0:      while.body:                                       ; preds = %while.body, %entry
+; CONTROL0-NEXT:   %c.addr.010 = phi i32 [ %dec, %while.body ], [ %c, %entry ]
+; CONTROL0-NEXT:   %dec = add nsw i32 %c.addr.010, -1
+; CONTROL0-NEXT:   %call = tail call i32 @_Z5gfuncv()
+; CONTROL0-NEXT:   %0 = load i32, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:   %add = add nsw i32 %0, %call
+; CONTROL0-NEXT:   store i32 %add, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:   %call1 = tail call i32 @_Z5gfuncv()
+; CONTROL0-NEXT:   %1 = load i8, i8* %tls_bitcast1, align 4, !tbaa !11
+; CONTROL0-NEXT:   %2 = trunc i32 %call1 to i8
+; CONTROL0-NEXT:   %conv5 = add i8 %1, %2
+; CONTROL0-NEXT:   store i8 %conv5, i8* %tls_bitcast1, align 4, !tbaa !11
+; CONTROL0-NEXT:   %call6 = tail call i32 @_Z5gfuncv()
+; CONTROL0-NEXT:   %3 = load i32, i32* %tls_bitcast2, align 4, !tbaa !13
+; CONTROL0-NEXT:   %add7 = add nsw i32 %3, %call6
+; CONTROL0-NEXT:   store i32 %add7, i32* %tls_bitcast2, align 4, !tbaa !13
+; CONTROL0-NEXT:   %tobool.not = icmp eq i32 %dec, 0
+; CONTROL0-NEXT:   br i1 %tobool.not, label %while.end, label %while.body, !llvm.loop !14
+;
+; CONTROL0:      while.end:                                        ; preds = %while.body, %entry
+; CONTROL0-NEXT:   %4 = load i32, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:   ret i32 %4
+; CONTROL0-NEXT: }
+entry:
+  %tobool.not9 = icmp eq i32 %c, 0
+  br i1 %tobool.not9, label %while.end, label %while.body
+
+while.body:                                       ; preds = %entry, %while.body
+  %c.addr.010 = phi i32 [ %dec, %while.body ], [ %c, %entry ]
+  %dec = add nsw i32 %c.addr.010, -1
+  %call = tail call i32 @_Z5gfuncv()
+  %0 = load i32, i32* @thl_x, align 4, !tbaa !5
+  %add = add nsw i32 %0, %call
+  store i32 %add, i32* @thl_x, align 4, !tbaa !5
+  %call1 = tail call i32 @_Z5gfuncv()
+  %1 = load i8, i8* @_ZZ2f2iE2st.0, align 4, !tbaa !11
+  %2 = trunc i32 %call1 to i8
+  %conv5 = add i8 %1, %2
+  store i8 %conv5, i8* @_ZZ2f2iE2st.0, align 4, !tbaa !11
+  %call6 = tail call i32 @_Z5gfuncv()
+  %3 = load i32, i32* @_ZZ2f2iE2st.1, align 4, !tbaa !13
+  %add7 = add nsw i32 %3, %call6
+  store i32 %add7, i32* @_ZZ2f2iE2st.1, align 4, !tbaa !13
+  %tobool.not = icmp eq i32 %dec, 0
+  br i1 %tobool.not, label %while.end, label %while.body, !llvm.loop !14
+
+while.end:                                        ; preds = %while.body, %entry
+  %4 = load i32, i32* @thl_x, align 4, !tbaa !5
+  ret i32 %4
+}
+
+declare i32 @_Z5gfuncv() local_unnamed_addr #1
+
+; Function Attrs: mustprogress uwtable
+define i32 @_Z2f3i(i32 %c) local_unnamed_addr #0 {
+; CONTROL0-LABEL: _Z2f3i
+; CONTROL0:      entry:
+; CONTROL0-NEXT:  %tls_bitcast = bitcast i32* @thl_x to i32*
+; CONTROL0-NEXT:  %0 = load i32, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:  %call = tail call i32 @_Z6gfunc2i(i32 %0)
+; CONTROL0-NEXT:  %1 = load i32, i32* %tls_bitcast, align 4, !tbaa !5
+; CONTROL0-NEXT:  %call1 = tail call i32 @_Z6gfunc2i(i32 %1)
+; CONTROL0-NEXT:  ret i32 1
+entry:
+  %0 = load i32, i32* @thl_x, align 4, !tbaa !5
+  %call = tail call i32 @_Z6gfunc2i(i32 %0)
+  %1 = load i32, i32* @thl_x, align 4, !tbaa !5
+  %call1 = tail call i32 @_Z6gfunc2i(i32 %1)
+  ret i32 1
+}
+
+; Function Attrs: uwtable
+define weak_odr hidden i32* @_ZTW5thl_x() local_unnamed_addr #2 comdat {
+  ret i32* @thl_x
+}
+
+; Function Attrs: uwtable
+define weak_odr hidden i32* @_ZTW6thl_x2() local_unnamed_addr #2 comdat {
+  ret i32* @thl_x2
+}
+
+attributes #0 = { mustprogress uwtable "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #1 = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #2 = { uwtable "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+
+!llvm.module.flags = !{!0, !1, !2, !3}
+!llvm.ident = !{!4}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{i32 7, !"uwtable", i32 1}
+!3 = !{i32 1, !"tls-load-control", !"Optimize"}
+!4 = !{!"Intel(R) oneAPI DPC++/C++ Compiler 2022.1.0 (2022.x.0.YYYYMMDD)"}
+!5 = !{!6, !6, i64 0}
+!6 = !{!"int", !7, i64 0}
+!7 = !{!"omnipotent char", !8, i64 0}
+!8 = !{!"Simple C++ TBAA"}
+!9 = distinct !{!9, !10}
+!10 = !{!"llvm.loop.mustprogress"}
+!11 = !{!12, !7, i64 0}
+!12 = !{!"_ZTS2SS", !7, i64 0, !6, i64 4}
+!13 = !{!12, !6, i64 4}
+!14 = distinct !{!14, !10}

llvm/test/CodeGen/X86/tls-loads-control2.ll

+; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlscontrol --relocation-model=pic --tls-load-control=Optimize -o - %s | FileCheck %s --check-prefixes=CONTROL0
+; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlscontrol --relocation-model=pic --tls-load-control=Non-Optimize -o - %s | FileCheck %s --check-prefixes=CONTROL2
+; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlscontrol --relocation-model=pic -o - %s | FileCheck %s --check-prefixes=CONTROL2
+
+$_ZTW5thl_x = comdat any
+
+@thl_x = thread_local global i32 0, align 4
+
+; Function Attrs: mustprogress uwtable
+define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 {
+entry:
+  %0 = load i32, i32* @thl_x, align 4, !tbaa !4
+  %call = tail call i32 @_Z5gfunci(i32 %0)
+  %1 = load i32, i32* @thl_x, align 4, !tbaa !4
+  %call1 = tail call i32 @_Z5gfunci(i32 %1)
+  ret i32 1
+}
+
+;CONTROL0-LABEL: _Z2f1i
+;CONTROL0:     entry:
+;CONTROL0-NEXT:  %tls_bitcast = bitcast i32* @thl_x to i32*
+;CONTROL0-NEXT:  %0 = load i32, i32* %tls_bitcast, align 4, !tbaa !4
+;CONTROL0-NEXT:  %call = tail call i32 @_Z5gfunci(i32 %0)
+;CONTROL0-NEXT:  %1 = load i32, i32* %tls_bitcast, align 4, !tbaa !4
+;CONTROL0-NEXT:  %call1 = tail call i32 @_Z5gfunci(i32 %1)
+;CONTROL0-NEXT:  ret i32 1
+
+;CONTROL2-LABEL: _Z2f1i
+;CONTROL2:     entry:
+;CONTROL2-NEXT:  %0 = load i32, i32* @thl_x, align 4, !tbaa !4
+;CONTROL2-NEXT:  %call = tail call i32 @_Z5gfunci(i32 %0)
+;CONTROL2-NEXT:  %1 = load i32, i32* @thl_x, align 4, !tbaa !4
+;CONTROL2-NEXT:  %call1 = tail call i32 @_Z5gfunci(i32 %1)
+;CONTROL2-NEXT:  ret i32 1
+
+declare i32 @_Z5gfunci(i32) local_unnamed_addr #1
+
+; Function Attrs: uwtable
+define weak_odr hidden i32* @_ZTW5thl_x() local_unnamed_addr #2 comdat {
+  ret i32* @thl_x
+}
+
+attributes #0 = { mustprogress uwtable "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #1 = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #2 = { uwtable "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+
+!llvm.module.flags = !{!0, !1, !2}
+!llvm.ident = !{!3}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{i32 7, !"uwtable", i32 1}
+!3 = !{!"Intel(R) oneAPI DPC++/C++ Compiler 2022.1.0 (2022.x.0.YYYYMMDD)"}
+!4 = !{!5, !5, i64 0}
+!5 = !{!"int", !6, i64 0}
+!6 = !{!"omnipotent char", !7, i64 0}
+!7 = !{!"Simple C++ TBAA"}

llvm/test/CodeGen/X86/tls-loads-control3.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-control=Optimize -o - %s | FileCheck %s --check-prefixes=CONTROL0
+; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic --tls-load-control=Non-Optimize -o - %s | FileCheck %s --check-prefixes=CONTROL2
+; RUN: llc -mtriple=x86_64-unknown-unknown -O2 --relocation-model=pic -o - %s | FileCheck %s --check-prefixes=CONTROL2
+
+; This test has no module flag {"tls-load-control", i32 0}, so use --tls-load-control=x
+; to choose the way of loading thread_local address.
+
+; This test come from compiling clang/test/CodeGen/intel/tls_loads.cpp with:
+; (clang tls_loads.cpp -fPIC -ftls-model=global-dynamic -O2 -S -emit-llvm)
+
+$_ZTW5thl_x = comdat any
+
+$_ZTW6thl_x2 = comdat any
+
+@thl_x = thread_local global i32 0, align 4
+@thl_x2 = thread_local global i32 0, align 4
+@_ZZ2f2iE2st.0 = internal thread_local unnamed_addr global i8 0, align 4
+@_ZZ2f2iE2st.1 = internal thread_local unnamed_addr global i32 0, align 4
+
+; For CONTROL0, check call __tls_get_addr@PLT only one time for each thread_local variable.
+; For CONTROL2, Check the default way: usually call __tls_get_addr@PLT every time when use thread_local variable.
+
+; Function Attrs: mustprogress uwtable
+define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 {
+; CONTROL0-LABEL: _Z2f1i:
+; CONTROL0:       # %bb.0: # %entry
+; CONTROL0-NEXT:    pushq %r15
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL0-NEXT:    pushq %r14
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL0-NEXT:    pushq %rbx
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 32
+; CONTROL0-NEXT:    .cfi_offset %rbx, -32
+; CONTROL0-NEXT:    .cfi_offset %r14, -24
+; CONTROL0-NEXT:    .cfi_offset %r15, -16
+; CONTROL0-NEXT:    movl %edi, %ebx
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    leaq thl_x2@TLSGD(%rip), %rdi
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    rex64
+; CONTROL0-NEXT:    callq __tls_get_addr@PLT
+; CONTROL0-NEXT:    movq %rax, %r14
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    rex64
+; CONTROL0-NEXT:    callq __tls_get_addr@PLT
+; CONTROL0-NEXT:    movq %rax, %r15
+; CONTROL0-NEXT:    testl %ebx, %ebx
+; CONTROL0-NEXT:    je .LBB0_1
+; CONTROL0-NEXT:    .p2align 4, 0x90
+; CONTROL0-NEXT:  .LBB0_2: # %while.body
+; CONTROL0-NEXT:    # =>This Inner Loop Header: Depth=1
+; CONTROL0-NEXT:    movl (%r14), %edi
+; CONTROL0-NEXT:    callq _Z6gfunc2i@PLT
+; CONTROL0-NEXT:    addl (%r15), %eax
+; CONTROL0-NEXT:    movl %eax, (%r15)
+; CONTROL0-NEXT:    decl %ebx
+; CONTROL0-NEXT:    jne .LBB0_2
+; CONTROL0-NEXT:    jmp .LBB0_3
+; CONTROL0-NEXT:  .LBB0_1: # %entry.while.end_crit_edge
+; CONTROL0-NEXT:    movl (%r15), %eax
+; CONTROL0-NEXT:  .LBB0_3: # %while.end
+; CONTROL0-NEXT:    popq %rbx
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL0-NEXT:    popq %r14
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL0-NEXT:    popq %r15
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 8
+; CONTROL0-NEXT:    retq
+;
+; CONTROL2-LABEL: _Z2f1i:
+; CONTROL2:       # %bb.0: # %entry
+; CONTROL2-NEXT:    pushq %rbp
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL2-NEXT:    pushq %rbx
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL2-NEXT:    pushq %rax
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 32
+; CONTROL2-NEXT:    .cfi_offset %rbx, -24
+; CONTROL2-NEXT:    .cfi_offset %rbp, -16
+; CONTROL2-NEXT:    testl %edi, %edi
+; CONTROL2-NEXT:    je .LBB0_4
+; CONTROL2-NEXT:  # %bb.1:
+; CONTROL2-NEXT:    movl %edi, %ebx
+; CONTROL2-NEXT:    .p2align 4, 0x90
+; CONTROL2-NEXT:  .LBB0_2: # %while.body
+; CONTROL2-NEXT:    # =>This Inner Loop Header: Depth=1
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    leaq thl_x2@TLSGD(%rip), %rdi
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    rex64
+; CONTROL2-NEXT:    callq __tls_get_addr@PLT
+; CONTROL2-NEXT:    movl (%rax), %edi
+; CONTROL2-NEXT:    callq _Z6gfunc2i@PLT
+; CONTROL2-NEXT:    movl %eax, %ebp
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    rex64
+; CONTROL2-NEXT:    callq __tls_get_addr@PLT
+; CONTROL2-NEXT:    addl (%rax), %ebp
+; CONTROL2-NEXT:    movl %ebp, (%rax)
+; CONTROL2-NEXT:    decl %ebx
+; CONTROL2-NEXT:    jne .LBB0_2
+; CONTROL2-NEXT:    jmp .LBB0_3
+; CONTROL2-NEXT:  .LBB0_4: # %entry.while.end_crit_edge
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    rex64
+; CONTROL2-NEXT:    callq __tls_get_addr@PLT
+; CONTROL2-NEXT:    movl (%rax), %ebp
+; CONTROL2-NEXT:  .LBB0_3: # %while.end
+; CONTROL2-NEXT:    movl %ebp, %eax
+; CONTROL2-NEXT:    addq $8, %rsp
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL2-NEXT:    popq %rbx
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL2-NEXT:    popq %rbp
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 8
+; CONTROL2-NEXT:    retq
+entry:
+  %tobool.not3 = icmp eq i32 %c, 0
+  br i1 %tobool.not3, label %entry.while.end_crit_edge, label %while.body
+
+entry.while.end_crit_edge:                        ; preds = %entry
+  %.pre = load i32, i32* @thl_x, align 4, !tbaa !4
+  br label %while.end
+
+while.body:                                       ; preds = %entry, %while.body
+  %c.addr.04 = phi i32 [ %dec, %while.body ], [ %c, %entry ]
+  %dec = add nsw i32 %c.addr.04, -1
+  %0 = load i32, i32* @thl_x2, align 4, !tbaa !4
+  %call = tail call i32 @_Z6gfunc2i(i32 %0)
+  %1 = load i32, i32* @thl_x, align 4, !tbaa !4
+  %add = add nsw i32 %1, %call
+  store i32 %add, i32* @thl_x, align 4, !tbaa !4
+  %tobool.not = icmp eq i32 %dec, 0
+  br i1 %tobool.not, label %while.end, label %while.body, !llvm.loop !8
+
+while.end:                                        ; preds = %while.body, %entry.while.end_crit_edge
+  %2 = phi i32 [ %.pre, %entry.while.end_crit_edge ], [ %add, %while.body ]
+  ret i32 %2
+}
+
+declare i32 @_Z6gfunc2i(i32) local_unnamed_addr #1
+
+; Function Attrs: mustprogress uwtable
+define i32 @_Z2f2i(i32 %c) local_unnamed_addr #0 {
+; CONTROL0-LABEL: _Z2f2i:
+; CONTROL0:       # %bb.0: # %entry
+; CONTROL0-NEXT:    pushq %r15
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL0-NEXT:    pushq %r14
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL0-NEXT:    pushq %r12
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 32
+; CONTROL0-NEXT:    pushq %rbx
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 40
+; CONTROL0-NEXT:    pushq %rax
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 48
+; CONTROL0-NEXT:    .cfi_offset %rbx, -40
+; CONTROL0-NEXT:    .cfi_offset %r12, -32
+; CONTROL0-NEXT:    .cfi_offset %r14, -24
+; CONTROL0-NEXT:    .cfi_offset %r15, -16
+; CONTROL0-NEXT:    movl %edi, %ebx
+; CONTROL0-NEXT:    leaq _ZZ2f2iE2st.1@TLSLD(%rip), %rdi
+; CONTROL0-NEXT:    callq __tls_get_addr@PLT
+; CONTROL0-NEXT:    movq %rax, %r15
+; CONTROL0-NEXT:    movq %rax, %r12
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    rex64
+; CONTROL0-NEXT:    callq __tls_get_addr@PLT
+; CONTROL0-NEXT:    movq %rax, %r14
+; CONTROL0-NEXT:    testl %ebx, %ebx
+; CONTROL0-NEXT:    je .LBB1_3
+; CONTROL0-NEXT:  # %bb.1: # %while.body.preheader
+; CONTROL0-NEXT:    leaq _ZZ2f2iE2st.1@DTPOFF(%r15), %r15
+; CONTROL0-NEXT:    leaq _ZZ2f2iE2st.0@DTPOFF(%r12), %r12
+; CONTROL0-NEXT:    .p2align 4, 0x90
+; CONTROL0-NEXT:  .LBB1_2: # %while.body
+; CONTROL0-NEXT:    # =>This Inner Loop Header: Depth=1
+; CONTROL0-NEXT:    callq _Z5gfuncv@PLT
+; CONTROL0-NEXT:    addl %eax, (%r14)
+; CONTROL0-NEXT:    callq _Z5gfuncv@PLT
+; CONTROL0-NEXT:    addb %al, (%r12)
+; CONTROL0-NEXT:    callq _Z5gfuncv@PLT
+; CONTROL0-NEXT:    addl %eax, (%r15)
+; CONTROL0-NEXT:    decl %ebx
+; CONTROL0-NEXT:    jne .LBB1_2
+; CONTROL0-NEXT:  .LBB1_3: # %while.end
+; CONTROL0-NEXT:    movl (%r14), %eax
+; CONTROL0-NEXT:    addq $8, %rsp
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 40
+; CONTROL0-NEXT:    popq %rbx
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 32
+; CONTROL0-NEXT:    popq %r12
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL0-NEXT:    popq %r14
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL0-NEXT:    popq %r15
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 8
+; CONTROL0-NEXT:    retq
+;
+; CONTROL2-LABEL: _Z2f2i:
+; CONTROL2:       # %bb.0: # %entry
+; CONTROL2-NEXT:    pushq %rbp
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL2-NEXT:    pushq %r14
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL2-NEXT:    pushq %rbx
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 32
+; CONTROL2-NEXT:    .cfi_offset %rbx, -32
+; CONTROL2-NEXT:    .cfi_offset %r14, -24
+; CONTROL2-NEXT:    .cfi_offset %rbp, -16
+; CONTROL2-NEXT:    testl %edi, %edi
+; CONTROL2-NEXT:    je .LBB1_3
+; CONTROL2-NEXT:  # %bb.1: # %while.body.preheader
+; CONTROL2-NEXT:    movl %edi, %ebx
+; CONTROL2-NEXT:    .p2align 4, 0x90
+; CONTROL2-NEXT:  .LBB1_2: # %while.body
+; CONTROL2-NEXT:    # =>This Inner Loop Header: Depth=1
+; CONTROL2-NEXT:    callq _Z5gfuncv@PLT
+; CONTROL2-NEXT:    movl %eax, %ebp
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    rex64
+; CONTROL2-NEXT:    callq __tls_get_addr@PLT
+; CONTROL2-NEXT:    addl %ebp, (%rax)
+; CONTROL2-NEXT:    callq _Z5gfuncv@PLT
+; CONTROL2-NEXT:    movl %eax, %ebp
+; CONTROL2-NEXT:    leaq _ZZ2f2iE2st.0@TLSLD(%rip), %rdi
+; CONTROL2-NEXT:    callq __tls_get_addr@PLT
+; CONTROL2-NEXT:    movq %rax, %r14
+; CONTROL2-NEXT:    addb %bpl, _ZZ2f2iE2st.0@DTPOFF(%rax)
+; CONTROL2-NEXT:    callq _Z5gfuncv@PLT
+; CONTROL2-NEXT:    movl %eax, %ecx
+; CONTROL2-NEXT:    movq %r14, %rax
+; CONTROL2-NEXT:    addl %ecx, _ZZ2f2iE2st.1@DTPOFF(%r14)
+; CONTROL2-NEXT:    decl %ebx
+; CONTROL2-NEXT:    jne .LBB1_2
+; CONTROL2-NEXT:  .LBB1_3: # %while.end
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    rex64
+; CONTROL2-NEXT:    callq __tls_get_addr@PLT
+; CONTROL2-NEXT:    movl (%rax), %eax
+; CONTROL2-NEXT:    popq %rbx
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 24
+; CONTROL2-NEXT:    popq %r14
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL2-NEXT:    popq %rbp
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 8
+; CONTROL2-NEXT:    retq
+entry:
+  %tobool.not9 = icmp eq i32 %c, 0
+  br i1 %tobool.not9, label %while.end, label %while.body
+
+while.body:                                       ; preds = %entry, %while.body
+  %c.addr.010 = phi i32 [ %dec, %while.body ], [ %c, %entry ]
+  %dec = add nsw i32 %c.addr.010, -1
+  %call = tail call i32 @_Z5gfuncv()
+  %0 = load i32, i32* @thl_x, align 4, !tbaa !4
+  %add = add nsw i32 %0, %call
+  store i32 %add, i32* @thl_x, align 4, !tbaa !4
+  %call1 = tail call i32 @_Z5gfuncv()
+  %1 = load i8, i8* @_ZZ2f2iE2st.0, align 4, !tbaa !10
+  %2 = trunc i32 %call1 to i8
+  %conv5 = add i8 %1, %2
+  store i8 %conv5, i8* @_ZZ2f2iE2st.0, align 4, !tbaa !10
+  %call6 = tail call i32 @_Z5gfuncv()
+  %3 = load i32, i32* @_ZZ2f2iE2st.1, align 4, !tbaa !12
+  %add7 = add nsw i32 %3, %call6
+  store i32 %add7, i32* @_ZZ2f2iE2st.1, align 4, !tbaa !12
+  %tobool.not = icmp eq i32 %dec, 0
+  br i1 %tobool.not, label %while.end, label %while.body, !llvm.loop !13
+
+while.end:                                        ; preds = %while.body, %entry
+  %4 = load i32, i32* @thl_x, align 4, !tbaa !4
+  ret i32 %4
+}
+
+declare i32 @_Z5gfuncv() local_unnamed_addr #1
+
+; Function Attrs: mustprogress uwtable
+define i32 @_Z2f3i(i32 %c) local_unnamed_addr #0 {
+; CONTROL0-LABEL: _Z2f3i:
+; CONTROL0:       # %bb.0: # %entry
+; CONTROL0-NEXT:    pushq %rbx
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL0-NEXT:    .cfi_offset %rbx, -16
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    data16
+; CONTROL0-NEXT:    rex64
+; CONTROL0-NEXT:    callq __tls_get_addr@PLT
+; CONTROL0-NEXT:    movq %rax, %rbx
+; CONTROL0-NEXT:    movl (%rax), %edi
+; CONTROL0-NEXT:    callq _Z6gfunc2i@PLT
+; CONTROL0-NEXT:    movl (%rbx), %edi
+; CONTROL0-NEXT:    callq _Z6gfunc2i@PLT
+; CONTROL0-NEXT:    movl $1, %eax
+; CONTROL0-NEXT:    popq %rbx
+; CONTROL0-NEXT:    .cfi_def_cfa_offset 8
+; CONTROL0-NEXT:    retq
+;
+; CONTROL2-LABEL: _Z2f3i:
+; CONTROL2:       # %bb.0: # %entry
+; CONTROL2-NEXT:    pushq %rbx
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 16
+; CONTROL2-NEXT:    .cfi_offset %rbx, -16
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    leaq thl_x@TLSGD(%rip), %rdi
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    data16
+; CONTROL2-NEXT:    rex64
+; CONTROL2-NEXT:    callq __tls_get_addr@PLT
+; CONTROL2-NEXT:    movq %rax, %rbx
+; CONTROL2-NEXT:    movl (%rax), %edi
+; CONTROL2-NEXT:    callq _Z6gfunc2i@PLT
+; CONTROL2-NEXT:    movl (%rbx), %edi
+; CONTROL2-NEXT:    callq _Z6gfunc2i@PLT
+; CONTROL2-NEXT:    movl $1, %eax
+; CONTROL2-NEXT:    popq %rbx
+; CONTROL2-NEXT:    .cfi_def_cfa_offset 8
+; CONTROL2-NEXT:    retq
+entry:
+  %0 = load i32, i32* @thl_x, align 4, !tbaa !4
+  %call = tail call i32 @_Z6gfunc2i(i32 %0)
+  %1 = load i32, i32* @thl_x, align 4, !tbaa !4
+  %call1 = tail call i32 @_Z6gfunc2i(i32 %1)
+  ret i32 1
+}
+
+attributes #0 = { mustprogress uwtable "frame-pointer"="none" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #1 = { "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #2 = { uwtable "frame-pointer"="none" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+
+!llvm.module.flags = !{!0, !1, !2}
+!llvm.ident = !{!3}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"PIC Level", i32 2}
+!2 = !{i32 7, !"uwtable", i32 1}
+!3 = !{!"Intel(R) oneAPI DPC++/C++ Compiler 2022.1.0 (2022.x.0.YYYYMMDD)"}
+!4 = !{!5, !5, i64 0}
+!5 = !{!"int", !6, i64 0}
+!6 = !{!"omnipotent char", !7, i64 0}
+!7 = !{!"Simple C++ TBAA"}
+!8 = distinct !{!8, !9}
+!9 = !{!"llvm.loop.mustprogress"}
+!10 = !{!11, !6, i64 0}
+!11 = !{!"_ZTS2SS", !6, i64 0, !5, i64 4}
+!12 = !{!11, !5, i64 4}
+!13 = distinct !{!13, !9}

llvm/tools/llc/llc.cpp

int main(int argc, char **argv) {
   initializeScalarOpts(*Registry);
   initializeVectorization(*Registry);
   initializeScalarizeMaskedMemIntrinLegacyPassPass(*Registry);
   initializeExpandReductionsPass(*Registry);
   initializeExpandVectorPredicationPass(*Registry);
   initializeHardwareLoopsPass(*Registry);
   initializeTransformUtils(*Registry);
   initializeReplaceWithVeclibLegacyPass(*Registry);
+  initializeTLSVariableControlLegacyPassPass(*Registry);
 
   // Initialize debugging passes.
   initializeScavengerTestPass(*Registry);
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");