LCOV - code coverage report
Current view: top level - lib/Target - TargetMachine.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 78 83 94.0 %
Date: 2017-09-14 15:23:50 Functions: 12 14 85.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- TargetMachine.cpp - General Target Information ---------------------==//
       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 file describes the general parts of a Target machine.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/Target/TargetMachine.h"
      15             : #include "llvm/Analysis/TargetTransformInfo.h"
      16             : #include "llvm/CodeGen/MachineFunction.h"
      17             : #include "llvm/IR/Function.h"
      18             : #include "llvm/IR/GlobalAlias.h"
      19             : #include "llvm/IR/GlobalValue.h"
      20             : #include "llvm/IR/GlobalVariable.h"
      21             : #include "llvm/IR/LegacyPassManager.h"
      22             : #include "llvm/IR/Mangler.h"
      23             : #include "llvm/MC/MCAsmInfo.h"
      24             : #include "llvm/MC/MCContext.h"
      25             : #include "llvm/MC/MCInstrInfo.h"
      26             : #include "llvm/MC/MCSectionMachO.h"
      27             : #include "llvm/MC/MCTargetOptions.h"
      28             : #include "llvm/MC/SectionKind.h"
      29             : #include "llvm/Target/TargetLowering.h"
      30             : #include "llvm/Target/TargetLoweringObjectFile.h"
      31             : #include "llvm/Target/TargetSubtargetInfo.h"
      32             : using namespace llvm;
      33             : 
      34             : //---------------------------------------------------------------------------
      35             : // TargetMachine Class
      36             : //
      37             : 
      38       25740 : TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString,
      39             :                              const Triple &TT, StringRef CPU, StringRef FS,
      40       25740 :                              const TargetOptions &Options)
      41             :     : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), TargetCPU(CPU),
      42             :       TargetFS(FS), AsmInfo(nullptr), MRI(nullptr), MII(nullptr), STI(nullptr),
      43       77220 :       RequireStructuredCFG(false), DefaultOptions(Options), Options(Options) {
      44       25739 : }
      45             : 
      46      175573 : TargetMachine::~TargetMachine() {
      47       25081 :   delete AsmInfo;
      48       50164 :   delete MRI;
      49       25082 :   delete MII;
      50       25082 :   delete STI;
      51       25082 : }
      52             : 
      53     2626350 : bool TargetMachine::isPositionIndependent() const {
      54     2626350 :   return getRelocationModel() == Reloc::PIC_;
      55             : }
      56             : 
      57             : /// \brief Reset the target options based on the function's attributes.
      58             : // FIXME: This function needs to go away for a number of reasons:
      59             : // a) global state on the TargetMachine is terrible in general,
      60             : // b) these target options should be passed only on the function
      61             : //    and not on the TargetMachine (via TargetOptions) at all.
      62      160094 : void TargetMachine::resetTargetOptions(const Function &F) const {
      63             : #define RESET_OPTION(X, Y)                                                     \
      64             :   do {                                                                         \
      65             :     if (F.hasFnAttribute(Y))                                                   \
      66             :       Options.X = (F.getFnAttribute(Y).getValueAsString() == "true");          \
      67             :     else                                                                       \
      68             :       Options.X = DefaultOptions.X;                                            \
      69             :   } while (0)
      70             : 
      71      339122 :   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
      72      336904 :   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
      73      337576 :   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
      74      333688 :   RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math");
      75      333322 :   RESET_OPTION(NoTrappingFPMath, "no-trapping-math");
      76             : 
      77             :   StringRef Denormal =
      78      320188 :     F.getFnAttribute("denormal-fp-math").getValueAsString();
      79      160096 :   if (Denormal == "ieee")
      80           2 :     Options.FPDenormalMode = FPDenormal::IEEE;
      81      160100 :   else if (Denormal == "preserve-sign")
      82           8 :     Options.FPDenormalMode = FPDenormal::PreserveSign;
      83      160087 :   else if (Denormal == "positive-zero")
      84           3 :     Options.FPDenormalMode = FPDenormal::PositiveZero;
      85             :   else
      86      160081 :     Options.FPDenormalMode = DefaultOptions.FPDenormalMode;
      87      160094 : }
      88             : 
      89             : /// Returns the code generation relocation model. The choices are static, PIC,
      90             : /// and dynamic-no-pic.
      91     5191753 : Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
      92             : 
      93             : /// Returns the code model. The choices are small, kernel, medium, large, and
      94             : /// target default.
      95     6714627 : CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; }
      96             : 
      97             : /// Get the IR-specified TLS model for Var.
      98             : static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
      99         448 :   switch (GV->getThreadLocalMode()) {
     100           0 :   case GlobalVariable::NotThreadLocal:
     101           0 :     llvm_unreachable("getSelectedTLSModel for non-TLS variable");
     102             :     break;
     103             :   case GlobalVariable::GeneralDynamicTLSModel:
     104             :     return TLSModel::GeneralDynamic;
     105          77 :   case GlobalVariable::LocalDynamicTLSModel:
     106             :     return TLSModel::LocalDynamic;
     107          52 :   case GlobalVariable::InitialExecTLSModel:
     108             :     return TLSModel::InitialExec;
     109          30 :   case GlobalVariable::LocalExecTLSModel:
     110             :     return TLSModel::LocalExec;
     111             :   }
     112           0 :   llvm_unreachable("invalid TLS model");
     113             : }
     114             : 
     115     2303083 : bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
     116             :                                          const GlobalValue *GV) const {
     117     2303083 :   Reloc::Model RM = getRelocationModel();
     118     2303083 :   const Triple &TT = getTargetTriple();
     119             : 
     120             :   // DLLImport explicitly marks the GV as external.
     121     4600507 :   if (GV && GV->hasDLLImportStorageClass())
     122             :     return false;
     123             : 
     124             :   // Every other GV is local on COFF.
     125             :   // Make an exception for windows OS in the triple: Some firmwares builds use
     126             :   // *-win32-macho triples. This (accidentally?) produced windows relocations
     127             :   // without GOT tables in older clang versions; Keep this behaviour.
     128     4603611 :   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     129             :     return true;
     130             : 
     131     2646951 :   if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
     132             :     return true;
     133             : 
     134      157267 :   if (TT.isOSBinFormatMachO()) {
     135       15230 :     if (RM == Reloc::Static)
     136             :       return true;
     137       14315 :     return GV && GV->isStrongDefinitionForLinker();
     138             :   }
     139             : 
     140             :   assert(TT.isOSBinFormatELF());
     141             :   assert(RM != Reloc::DynamicNoPIC);
     142             : 
     143             :   bool IsExecutable =
     144      142037 :       RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
     145             :   if (IsExecutable) {
     146             :     // If the symbol is defined, it cannot be preempted.
     147       66757 :     if (GV && !GV->isDeclarationForLinker())
     148             :       return true;
     149             : 
     150       43629 :     bool IsTLS = GV && GV->isThreadLocal();
     151       23548 :     bool IsAccessViaCopyRelocs = Options.MCOptions.MCPIECopyRelocations && GV &&
     152       23542 :                                  isa<GlobalVariable>(GV) &&
     153       23536 :                                  !GV->hasExternalWeakLinkage();
     154       23516 :     Triple::ArchType Arch = TT.getArch();
     155       23516 :     bool IsPPC =
     156       23516 :         Arch == Triple::ppc || Arch == Triple::ppc64 || Arch == Triple::ppc64le;
     157             :     // Check if we can use copy relocations. PowerPC has no copy relocations.
     158       23516 :     if (!IsTLS && !IsPPC && (RM == Reloc::Static || IsAccessViaCopyRelocs))
     159             :       return true;
     160             :   }
     161             : 
     162             :   // ELF supports preemption of other symbols.
     163             :   return false;
     164             : }
     165             : 
     166         448 : TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
     167         448 :   bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
     168         448 :   Reloc::Model RM = getRelocationModel();
     169         448 :   bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
     170         448 :   bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
     171             : 
     172             :   TLSModel::Model Model;
     173         448 :   if (IsSharedLibrary) {
     174         244 :     if (IsLocal)
     175             :       Model = TLSModel::LocalDynamic;
     176             :     else
     177         191 :       Model = TLSModel::GeneralDynamic;
     178             :   } else {
     179         204 :     if (IsLocal)
     180             :       Model = TLSModel::LocalExec;
     181             :     else
     182          85 :       Model = TLSModel::InitialExec;
     183             :   }
     184             : 
     185             :   // If the user specified a more specific model, use that.
     186         448 :   TLSModel::Model SelectedModel = getSelectedTLSModel(GV);
     187         448 :   if (SelectedModel > Model)
     188             :     return SelectedModel;
     189             : 
     190         358 :   return Model;
     191             : }
     192             : 
     193             : /// Returns the optimization level: None, Less, Default, or Aggressive.
     194     1160410 : CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; }
     195             : 
     196         114 : void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; }
     197             : 
     198           0 : TargetIRAnalysis TargetMachine::getTargetIRAnalysis() {
     199             :   return TargetIRAnalysis([](const Function &F) {
     200             :     return TargetTransformInfo(F.getParent()->getDataLayout());
     201           0 :   });
     202             : }
     203             : 
     204     1088544 : void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name,
     205             :                                       const GlobalValue *GV, Mangler &Mang,
     206             :                                       bool MayAlwaysUsePrivate) const {
     207     2143811 :   if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) {
     208             :     // Simple case: If GV is not private, it is not important to find out if
     209             :     // private labels are legal in this case or not.
     210      991092 :     Mang.getNameWithPrefix(Name, GV, false);
     211      991092 :     return;
     212             :   }
     213       97452 :   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
     214       97452 :   TLOF->getNameWithPrefix(Name, GV, *this);
     215             : }
     216             : 
     217      372289 : MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const {
     218      372289 :   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
     219      744578 :   SmallString<128> NameStr;
     220      372289 :   getNameWithPrefix(NameStr, GV, TLOF->getMangler());
     221     1116867 :   return TLOF->getContext().getOrCreateSymbol(NameStr);
     222             : }

Generated by: LCOV version 1.13