LCOV - code coverage report
Current view: top level - lib/CodeGen - LowerEmuTLS.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 56 56 100.0 %
Date: 2018-07-13 00:08:38 Functions: 7 8 87.5 %
Legend: Lines: hit not hit

          Line data    Source code
       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/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"
      24             : 
      25             : using namespace llvm;
      26             : 
      27             : #define DEBUG_TYPE "loweremutls"
      28             : 
      29             : namespace {
      30             : 
      31         398 : class LowerEmuTLS : public ModulePass {
      32             : public:
      33             :   static char ID; // Pass identification, replacement for typeid
      34         398 :   LowerEmuTLS() : ModulePass(ID) {
      35         398 :     initializeLowerEmuTLSPass(*PassRegistry::getPassRegistry());
      36             :   }
      37             : 
      38             :   bool runOnModule(Module &M) override;
      39             : private:
      40             :   bool addEmuTlsVar(Module &M, const GlobalVariable *GV);
      41         405 :   static void copyLinkageVisibility(Module &M,
      42             :                                     const GlobalVariable *from,
      43             :                                     GlobalVariable *to) {
      44             :     to->setLinkage(from->getLinkage());
      45             :     to->setVisibility(from->getVisibility());
      46         405 :     if (from->hasComdat()) {
      47           6 :       to->setComdat(M.getOrInsertComdat(to->getName()));
      48           6 :       to->getComdat()->setSelectionKind(from->getComdat()->getSelectionKind());
      49             :     }
      50         405 :   }
      51             : };
      52             : }
      53             : 
      54             : char LowerEmuTLS::ID = 0;
      55             : 
      56        1506 : INITIALIZE_PASS(LowerEmuTLS, DEBUG_TYPE,
      57             :                 "Add __emutls_[vt]. variables for emultated TLS model", false,
      58             :                 false)
      59             : 
      60         796 : ModulePass *llvm::createLowerEmuTLSPass() { return new LowerEmuTLS(); }
      61             : 
      62         398 : bool LowerEmuTLS::runOnModule(Module &M) {
      63         398 :   if (skipModule(M))
      64             :     return false;
      65             : 
      66         398 :   auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
      67         398 :   if (!TPC)
      68             :     return false;
      69             : 
      70         398 :   auto &TM = TPC->getTM<TargetMachine>();
      71         398 :   if (!TM.useEmulatedTLS())
      72             :     return false;
      73             : 
      74             :   bool Changed = false;
      75             :   SmallVector<const GlobalVariable*, 8> TlsVars;
      76         872 :   for (const auto &G : M.globals()) {
      77         474 :     if (G.isThreadLocal())
      78         512 :       TlsVars.append({&G});
      79             :   }
      80         910 :   for (const auto G : TlsVars)
      81         256 :     Changed |= addEmuTlsVar(M, G);
      82             :   return Changed;
      83             : }
      84             : 
      85         256 : bool LowerEmuTLS::addEmuTlsVar(Module &M, const GlobalVariable *GV) {
      86         256 :   LLVMContext &C = M.getContext();
      87         256 :   PointerType *VoidPtrType = Type::getInt8PtrTy(C);
      88             : 
      89         512 :   std::string EmuTlsVarName = ("__emutls_v." + GV->getName()).str();
      90             :   GlobalVariable *EmuTlsVar = M.getNamedGlobal(EmuTlsVarName);
      91         256 :   if (EmuTlsVar)
      92             :     return false;  // It has been added before.
      93             : 
      94         256 :   const DataLayout &DL = M.getDataLayout();
      95         256 :   Constant *NullPtr = ConstantPointerNull::get(VoidPtrType);
      96             : 
      97             :   // Get non-zero initializer from GV's initializer.
      98             :   const Constant *InitValue = nullptr;
      99         256 :   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         176 :     if (isa<ConstantAggregateZero>(InitValue) ||
     105         173 :         (InitIntValue && InitIntValue->isZero()))
     106             :       InitValue = nullptr;
     107             :   }
     108             : 
     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         256 :   IntegerType *WordType = DL.getIntPtrType(C);
     116         256 :   PointerType *InitPtrType = InitValue ?
     117         149 :       PointerType::getUnqual(InitValue->getType()) : VoidPtrType;
     118         256 :   Type *ElementTypes[4] = {WordType, WordType, VoidPtrType, InitPtrType};
     119             :   ArrayRef<Type*> ElementTypeArray(ElementTypes, 4);
     120         256 :   StructType *EmuTlsVarType = StructType::create(ElementTypeArray);
     121         256 :   EmuTlsVar = cast<GlobalVariable>(
     122             :       M.getOrInsertGlobal(EmuTlsVarName, EmuTlsVarType));
     123         256 :   copyLinkageVisibility(M, GV, EmuTlsVar);
     124             : 
     125             :   // Define "__emutls_t.*" and "__emutls_v.*" only if GV is defined.
     126         256 :   if (!GV->hasInitializer())
     127             :     return true;
     128             : 
     129         176 :   Type *GVType = GV->getValueType();
     130             :   unsigned GVAlignment = GV->getAlignment();
     131         176 :   if (!GVAlignment) {
     132             :     // When LLVM IL declares a variable without alignment, use
     133             :     // the ABI default alignment for the type.
     134         100 :     GVAlignment = DL.getABITypeAlignment(GVType);
     135             :   }
     136             : 
     137             :   // Define "__emutls_t.*" if there is InitValue
     138             :   GlobalVariable *EmuTlsTmplVar = nullptr;
     139         176 :   if (InitValue) {
     140         298 :     std::string EmuTlsTmplName = ("__emutls_t." + GV->getName()).str();
     141         298 :     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         149 :     EmuTlsTmplVar->setInitializer(const_cast<Constant*>(InitValue));
     146         149 :     EmuTlsTmplVar->setAlignment(GVAlignment);
     147         149 :     copyLinkageVisibility(M, GV, EmuTlsTmplVar);
     148             :   }
     149             : 
     150             :   // Define "__emutls_v.*" with initializer and alignment.
     151             :   Constant *ElementValues[4] = {
     152         176 :       ConstantInt::get(WordType, DL.getTypeStoreSize(GVType)),
     153         176 :       ConstantInt::get(WordType, GVAlignment),
     154         176 :       NullPtr, EmuTlsTmplVar ? EmuTlsTmplVar : NullPtr
     155         528 :   };
     156             :   ArrayRef<Constant*> ElementValueArray(ElementValues, 4);
     157         176 :   EmuTlsVar->setInitializer(
     158             :       ConstantStruct::get(EmuTlsVarType, ElementValueArray));
     159             :   unsigned MaxAlignment = std::max(
     160         352 :       DL.getABITypeAlignment(WordType),
     161         528 :       DL.getABITypeAlignment(VoidPtrType));
     162         176 :   EmuTlsVar->setAlignment(MaxAlignment);
     163             :   return true;
     164             : }

Generated by: LCOV version 1.13