lib/CodeGen/LowerEmuTLS.cpp

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