1 //===- LowerEmuTLS.cpp - Add __emutls_[vt].* variables --------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This transformation is required for targets depending on libgcc style
11 // emulated thread local storage variables. For every defined TLS variable xyz,
12 // an __emutls_v.xyz is generated. If there is non-zero initialized value
13 // an __emutls_t.xyz is also generated.
14 //
15 //===----------------------------------------------------------------------===//
16
17 #include "llvm/Transforms/Scalar.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/Module.h"
21 #include "llvm/Pass.h"
22 #include "llvm/Target/TargetLowering.h"
23
24 using namespace llvm;
25
26 #define DEBUG_TYPE "loweremutls"
27
28 namespace {
29
30 class LowerEmuTLS : public ModulePass {
31 const TargetMachine *TM;
32 public:
33 static char ID; // Pass identification, replacement for typeid
LowerEmuTLS()34 explicit LowerEmuTLS() : ModulePass(ID), TM(nullptr) { }
LowerEmuTLS(const TargetMachine * TM)35 explicit LowerEmuTLS(const TargetMachine *TM)
36 : ModulePass(ID), TM(TM) {
37 initializeLowerEmuTLSPass(*PassRegistry::getPassRegistry());
38 }
39 bool runOnModule(Module &M) override;
40 private:
41 bool addEmuTlsVar(Module &M, const GlobalVariable *GV);
copyLinkageVisibility(Module & M,const GlobalVariable * from,GlobalVariable * to)42 static void copyLinkageVisibility(Module &M,
43 const GlobalVariable *from,
44 GlobalVariable *to) {
45 to->setLinkage(from->getLinkage());
46 to->setVisibility(from->getVisibility());
47 if (from->hasComdat()) {
48 to->setComdat(M.getOrInsertComdat(to->getName()));
49 to->getComdat()->setSelectionKind(from->getComdat()->getSelectionKind());
50 }
51 }
52 };
53 }
54
55 char LowerEmuTLS::ID = 0;
56
57 INITIALIZE_PASS(LowerEmuTLS, "loweremutls",
58 "Add __emutls_[vt]. variables for emultated TLS model",
59 false, false)
60
createLowerEmuTLSPass(const TargetMachine * TM)61 ModulePass *llvm::createLowerEmuTLSPass(const TargetMachine *TM) {
62 return new LowerEmuTLS(TM);
63 }
64
runOnModule(Module & M)65 bool LowerEmuTLS::runOnModule(Module &M) {
66 if (!TM || !TM->Options.EmulatedTLS)
67 return false;
68
69 bool Changed = false;
70 SmallVector<const GlobalVariable*, 8> TlsVars;
71 for (const auto &G : M.globals()) {
72 if (G.isThreadLocal())
73 TlsVars.append({&G});
74 }
75 for (const auto G : TlsVars)
76 Changed |= addEmuTlsVar(M, G);
77 return Changed;
78 }
79
addEmuTlsVar(Module & M,const GlobalVariable * GV)80 bool LowerEmuTLS::addEmuTlsVar(Module &M, const GlobalVariable *GV) {
81 LLVMContext &C = M.getContext();
82 PointerType *VoidPtrType = Type::getInt8PtrTy(C);
83
84 std::string EmuTlsVarName = ("__emutls_v." + GV->getName()).str();
85 GlobalVariable *EmuTlsVar = M.getNamedGlobal(EmuTlsVarName);
86 if (EmuTlsVar)
87 return false; // It has been added before.
88
89 const DataLayout &DL = M.getDataLayout();
90 Constant *NullPtr = ConstantPointerNull::get(VoidPtrType);
91
92 // Get non-zero initializer from GV's initializer.
93 const Constant *InitValue = nullptr;
94 if (GV->hasInitializer()) {
95 InitValue = GV->getInitializer();
96 const ConstantInt *InitIntValue = dyn_cast<ConstantInt>(InitValue);
97 // When GV's init value is all 0, omit the EmuTlsTmplVar and let
98 // the emutls library function to reset newly allocated TLS variables.
99 if (isa<ConstantAggregateZero>(InitValue) ||
100 (InitIntValue && InitIntValue->isZero()))
101 InitValue = nullptr;
102 }
103
104 // Create the __emutls_v. symbol, whose type has 4 fields:
105 // word size; // size of GV in bytes
106 // word align; // alignment of GV
107 // void *ptr; // initialized to 0; set at run time per thread.
108 // void *templ; // 0 or point to __emutls_t.*
109 // sizeof(word) should be the same as sizeof(void*) on target.
110 IntegerType *WordType = DL.getIntPtrType(C);
111 PointerType *InitPtrType = InitValue ?
112 PointerType::getUnqual(InitValue->getType()) : VoidPtrType;
113 Type *ElementTypes[4] = {WordType, WordType, VoidPtrType, InitPtrType};
114 ArrayRef<Type*> ElementTypeArray(ElementTypes, 4);
115 StructType *EmuTlsVarType = StructType::create(ElementTypeArray);
116 EmuTlsVar = cast<GlobalVariable>(
117 M.getOrInsertGlobal(EmuTlsVarName, EmuTlsVarType));
118 copyLinkageVisibility(M, GV, EmuTlsVar);
119
120 // Define "__emutls_t.*" and "__emutls_v.*" only if GV is defined.
121 if (!GV->hasInitializer())
122 return true;
123
124 Type *GVType = GV->getValueType();
125 unsigned GVAlignment = GV->getAlignment();
126 if (!GVAlignment) {
127 // When LLVM IL declares a variable without alignment, use
128 // the ABI default alignment for the type.
129 GVAlignment = DL.getABITypeAlignment(GVType);
130 }
131
132 // Define "__emutls_t.*" if there is InitValue
133 GlobalVariable *EmuTlsTmplVar = nullptr;
134 if (InitValue) {
135 std::string EmuTlsTmplName = ("__emutls_t." + GV->getName()).str();
136 EmuTlsTmplVar = dyn_cast_or_null<GlobalVariable>(
137 M.getOrInsertGlobal(EmuTlsTmplName, GVType));
138 assert(EmuTlsTmplVar && "Failed to create emualted TLS initializer");
139 EmuTlsTmplVar->setConstant(true);
140 EmuTlsTmplVar->setInitializer(const_cast<Constant*>(InitValue));
141 EmuTlsTmplVar->setAlignment(GVAlignment);
142 copyLinkageVisibility(M, GV, EmuTlsTmplVar);
143 }
144
145 // Define "__emutls_v.*" with initializer and alignment.
146 Constant *ElementValues[4] = {
147 ConstantInt::get(WordType, DL.getTypeStoreSize(GVType)),
148 ConstantInt::get(WordType, GVAlignment),
149 NullPtr, EmuTlsTmplVar ? EmuTlsTmplVar : NullPtr
150 };
151 ArrayRef<Constant*> ElementValueArray(ElementValues, 4);
152 EmuTlsVar->setInitializer(
153 ConstantStruct::get(EmuTlsVarType, ElementValueArray));
154 unsigned MaxAlignment = std::max(
155 DL.getABITypeAlignment(WordType),
156 DL.getABITypeAlignment(VoidPtrType));
157 EmuTlsVar->setAlignment(MaxAlignment);
158 return true;
159 }
160