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