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