1 | //===-- AArch64CleanupLocalDynamicTLSPass.cpp ---------------------*- C++ -*-=// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // Local-dynamic access to thread-local variables proceeds in three stages. |
10 | // |
11 | // 1. The offset of this Module's thread-local area from TPIDR_EL0 is calculated |
12 | // in much the same way as a general-dynamic TLS-descriptor access against |
13 | // the special symbol _TLS_MODULE_BASE. |
14 | // 2. The variable's offset from _TLS_MODULE_BASE_ is calculated using |
15 | // instructions with "dtprel" modifiers. |
16 | // 3. These two are added, together with TPIDR_EL0, to obtain the variable's |
17 | // true address. |
18 | // |
19 | // This is only better than general-dynamic access to the variable if two or |
20 | // more of the first stage TLS-descriptor calculations can be combined. This |
21 | // pass looks through a function and performs such combinations. |
22 | // |
23 | //===----------------------------------------------------------------------===// |
24 | #include "AArch64.h" |
25 | #include "AArch64InstrInfo.h" |
26 | #include "AArch64MachineFunctionInfo.h" |
27 | #include "llvm/CodeGen/MachineDominators.h" |
28 | #include "llvm/CodeGen/MachineFunction.h" |
29 | #include "llvm/CodeGen/MachineFunctionPass.h" |
30 | #include "llvm/CodeGen/MachineInstrBuilder.h" |
31 | #include "llvm/CodeGen/MachineRegisterInfo.h" |
32 | using namespace llvm; |
33 | |
34 | #define TLSCLEANUP_PASS_NAME "AArch64 Local Dynamic TLS Access Clean-up" |
35 | |
36 | namespace { |
37 | struct LDTLSCleanup : public MachineFunctionPass { |
38 | static char ID; |
39 | LDTLSCleanup() : MachineFunctionPass(ID) { |
40 | initializeLDTLSCleanupPass(*PassRegistry::getPassRegistry()); |
41 | } |
42 | |
43 | bool runOnMachineFunction(MachineFunction &MF) override { |
44 | if (skipFunction(F: MF.getFunction())) |
45 | return false; |
46 | |
47 | AArch64FunctionInfo *AFI = MF.getInfo<AArch64FunctionInfo>(); |
48 | if (AFI->getNumLocalDynamicTLSAccesses() < 2) { |
49 | // No point folding accesses if there isn't at least two. |
50 | return false; |
51 | } |
52 | |
53 | MachineDominatorTree *DT = &getAnalysis<MachineDominatorTree>(); |
54 | return VisitNode(Node: DT->getRootNode(), TLSBaseAddrReg: 0); |
55 | } |
56 | |
57 | // Visit the dominator subtree rooted at Node in pre-order. |
58 | // If TLSBaseAddrReg is non-null, then use that to replace any |
59 | // TLS_base_addr instructions. Otherwise, create the register |
60 | // when the first such instruction is seen, and then use it |
61 | // as we encounter more instructions. |
62 | bool VisitNode(MachineDomTreeNode *Node, unsigned TLSBaseAddrReg) { |
63 | MachineBasicBlock *BB = Node->getBlock(); |
64 | bool Changed = false; |
65 | |
66 | // Traverse the current block. |
67 | for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; |
68 | ++I) { |
69 | switch (I->getOpcode()) { |
70 | case AArch64::TLSDESC_CALLSEQ: |
71 | // Make sure it's a local dynamic access. |
72 | if (!I->getOperand(i: 0).isSymbol() || |
73 | strcmp(s1: I->getOperand(i: 0).getSymbolName(), s2: "_TLS_MODULE_BASE_" )) |
74 | break; |
75 | |
76 | if (TLSBaseAddrReg) |
77 | I = replaceTLSBaseAddrCall(I&: *I, TLSBaseAddrReg); |
78 | else |
79 | I = setRegister(I&: *I, TLSBaseAddrReg: &TLSBaseAddrReg); |
80 | Changed = true; |
81 | break; |
82 | default: |
83 | break; |
84 | } |
85 | } |
86 | |
87 | // Visit the children of this block in the dominator tree. |
88 | for (MachineDomTreeNode *N : *Node) { |
89 | Changed |= VisitNode(Node: N, TLSBaseAddrReg); |
90 | } |
91 | |
92 | return Changed; |
93 | } |
94 | |
95 | // Replace the TLS_base_addr instruction I with a copy from |
96 | // TLSBaseAddrReg, returning the new instruction. |
97 | MachineInstr *replaceTLSBaseAddrCall(MachineInstr &I, |
98 | unsigned TLSBaseAddrReg) { |
99 | MachineFunction *MF = I.getParent()->getParent(); |
100 | const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo(); |
101 | |
102 | // Insert a Copy from TLSBaseAddrReg to x0, which is where the rest of the |
103 | // code sequence assumes the address will be. |
104 | MachineInstr *Copy = BuildMI(*I.getParent(), I, I.getDebugLoc(), |
105 | TII->get(Opcode: TargetOpcode::COPY), AArch64::X0) |
106 | .addReg(TLSBaseAddrReg); |
107 | |
108 | // Update the call site info. |
109 | if (I.shouldUpdateCallSiteInfo()) |
110 | I.getMF()->eraseCallSiteInfo(MI: &I); |
111 | |
112 | // Erase the TLS_base_addr instruction. |
113 | I.eraseFromParent(); |
114 | |
115 | return Copy; |
116 | } |
117 | |
118 | // Create a virtual register in *TLSBaseAddrReg, and populate it by |
119 | // inserting a copy instruction after I. Returns the new instruction. |
120 | MachineInstr *setRegister(MachineInstr &I, unsigned *TLSBaseAddrReg) { |
121 | MachineFunction *MF = I.getParent()->getParent(); |
122 | const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo(); |
123 | |
124 | // Create a virtual register for the TLS base address. |
125 | MachineRegisterInfo &RegInfo = MF->getRegInfo(); |
126 | *TLSBaseAddrReg = RegInfo.createVirtualRegister(&AArch64::GPR64RegClass); |
127 | |
128 | // Insert a copy from X0 to TLSBaseAddrReg for later. |
129 | MachineInstr *Copy = |
130 | BuildMI(BB&: *I.getParent(), I: ++I.getIterator(), MIMD: I.getDebugLoc(), |
131 | MCID: TII->get(Opcode: TargetOpcode::COPY), DestReg: *TLSBaseAddrReg) |
132 | .addReg(AArch64::RegNo: X0); |
133 | |
134 | return Copy; |
135 | } |
136 | |
137 | StringRef getPassName() const override { return TLSCLEANUP_PASS_NAME; } |
138 | |
139 | void getAnalysisUsage(AnalysisUsage &AU) const override { |
140 | AU.setPreservesCFG(); |
141 | AU.addRequired<MachineDominatorTree>(); |
142 | MachineFunctionPass::getAnalysisUsage(AU); |
143 | } |
144 | }; |
145 | } |
146 | |
147 | INITIALIZE_PASS(LDTLSCleanup, "aarch64-local-dynamic-tls-cleanup" , |
148 | TLSCLEANUP_PASS_NAME, false, false) |
149 | |
150 | char LDTLSCleanup::ID = 0; |
151 | FunctionPass *llvm::createAArch64CleanupLocalDynamicTLSPass() { |
152 | return new LDTLSCleanup(); |
153 | } |
154 | |