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