contrib/llvm/lib/CodeGen/LowerEmuTLS.cpp

   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
  34   explicit LowerEmuTLS() : ModulePass(ID), TM(nullptr) { }
  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);
  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
  61 ModulePass *llvm::createLowerEmuTLSPass(const TargetMachine *TM) {
  62   return new LowerEmuTLS(TM);
  63 }
  64
  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
  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 }