• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/ADT/SmallVector.h"
18 #include "llvm/CodeGen/Passes.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 (skipModule(M))
67     return false;
68 
69   if (!TM || !TM->Options.EmulatedTLS)
70     return false;
71 
72   bool Changed = false;
73   SmallVector<const GlobalVariable*, 8> TlsVars;
74   for (const auto &G : M.globals()) {
75     if (G.isThreadLocal())
76       TlsVars.append({&G});
77   }
78   for (const auto G : TlsVars)
79     Changed |= addEmuTlsVar(M, G);
80   return Changed;
81 }
82 
addEmuTlsVar(Module & M,const GlobalVariable * GV)83 bool LowerEmuTLS::addEmuTlsVar(Module &M, const GlobalVariable *GV) {
84   LLVMContext &C = M.getContext();
85   PointerType *VoidPtrType = Type::getInt8PtrTy(C);
86 
87   std::string EmuTlsVarName = ("__emutls_v." + GV->getName()).str();
88   GlobalVariable *EmuTlsVar = M.getNamedGlobal(EmuTlsVarName);
89   if (EmuTlsVar)
90     return false;  // It has been added before.
91 
92   const DataLayout &DL = M.getDataLayout();
93   Constant *NullPtr = ConstantPointerNull::get(VoidPtrType);
94 
95   // Get non-zero initializer from GV's initializer.
96   const Constant *InitValue = nullptr;
97   if (GV->hasInitializer()) {
98     InitValue = GV->getInitializer();
99     const ConstantInt *InitIntValue = dyn_cast<ConstantInt>(InitValue);
100     // When GV's init value is all 0, omit the EmuTlsTmplVar and let
101     // the emutls library function to reset newly allocated TLS variables.
102     if (isa<ConstantAggregateZero>(InitValue) ||
103         (InitIntValue && InitIntValue->isZero()))
104       InitValue = nullptr;
105   }
106 
107   // Create the __emutls_v. symbol, whose type has 4 fields:
108   //     word size;   // size of GV in bytes
109   //     word align;  // alignment of GV
110   //     void *ptr;   // initialized to 0; set at run time per thread.
111   //     void *templ; // 0 or point to __emutls_t.*
112   // sizeof(word) should be the same as sizeof(void*) on target.
113   IntegerType *WordType = DL.getIntPtrType(C);
114   PointerType *InitPtrType = InitValue ?
115       PointerType::getUnqual(InitValue->getType()) : VoidPtrType;
116   Type *ElementTypes[4] = {WordType, WordType, VoidPtrType, InitPtrType};
117   ArrayRef<Type*> ElementTypeArray(ElementTypes, 4);
118   StructType *EmuTlsVarType = StructType::create(ElementTypeArray);
119   EmuTlsVar = cast<GlobalVariable>(
120       M.getOrInsertGlobal(EmuTlsVarName, EmuTlsVarType));
121   copyLinkageVisibility(M, GV, EmuTlsVar);
122 
123   // Define "__emutls_t.*" and "__emutls_v.*" only if GV is defined.
124   if (!GV->hasInitializer())
125     return true;
126 
127   Type *GVType = GV->getValueType();
128   unsigned GVAlignment = GV->getAlignment();
129   if (!GVAlignment) {
130     // When LLVM IL declares a variable without alignment, use
131     // the ABI default alignment for the type.
132     GVAlignment = DL.getABITypeAlignment(GVType);
133   }
134 
135   // Define "__emutls_t.*" if there is InitValue
136   GlobalVariable *EmuTlsTmplVar = nullptr;
137   if (InitValue) {
138     std::string EmuTlsTmplName = ("__emutls_t." + GV->getName()).str();
139     EmuTlsTmplVar = dyn_cast_or_null<GlobalVariable>(
140         M.getOrInsertGlobal(EmuTlsTmplName, GVType));
141     assert(EmuTlsTmplVar && "Failed to create emualted TLS initializer");
142     EmuTlsTmplVar->setConstant(true);
143     EmuTlsTmplVar->setInitializer(const_cast<Constant*>(InitValue));
144     EmuTlsTmplVar->setAlignment(GVAlignment);
145     copyLinkageVisibility(M, GV, EmuTlsTmplVar);
146   }
147 
148   // Define "__emutls_v.*" with initializer and alignment.
149   Constant *ElementValues[4] = {
150       ConstantInt::get(WordType, DL.getTypeStoreSize(GVType)),
151       ConstantInt::get(WordType, GVAlignment),
152       NullPtr, EmuTlsTmplVar ? EmuTlsTmplVar : NullPtr
153   };
154   ArrayRef<Constant*> ElementValueArray(ElementValues, 4);
155   EmuTlsVar->setInitializer(
156       ConstantStruct::get(EmuTlsVarType, ElementValueArray));
157   unsigned MaxAlignment = std::max(
158       DL.getABITypeAlignment(WordType),
159       DL.getABITypeAlignment(VoidPtrType));
160   EmuTlsVar->setAlignment(MaxAlignment);
161   return true;
162 }
163