LCOV - code coverage report
Current view: top level - lib/Target - TargetMachine.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 69 72 95.8 %
Date: 2018-10-20 13:21:21 Functions: 13 14 92.9 %
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/IR/Function.h"
      17             : #include "llvm/IR/GlobalAlias.h"
      18             : #include "llvm/IR/GlobalValue.h"
      19             : #include "llvm/IR/GlobalVariable.h"
      20             : #include "llvm/IR/LegacyPassManager.h"
      21             : #include "llvm/IR/Mangler.h"
      22             : #include "llvm/MC/MCAsmInfo.h"
      23             : #include "llvm/MC/MCContext.h"
      24             : #include "llvm/MC/MCInstrInfo.h"
      25             : #include "llvm/MC/MCSectionMachO.h"
      26             : #include "llvm/MC/MCTargetOptions.h"
      27             : #include "llvm/MC/SectionKind.h"
      28             : #include "llvm/Target/TargetLoweringObjectFile.h"
      29             : using namespace llvm;
      30             : 
      31             : //---------------------------------------------------------------------------
      32             : // TargetMachine Class
      33             : //
      34             : 
      35       40979 : TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString,
      36             :                              const Triple &TT, StringRef CPU, StringRef FS,
      37       40979 :                              const TargetOptions &Options)
      38             :     : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), TargetCPU(CPU),
      39             :       TargetFS(FS), AsmInfo(nullptr), MRI(nullptr), MII(nullptr), STI(nullptr),
      40      122937 :       RequireStructuredCFG(false), DefaultOptions(Options), Options(Options) {
      41       40979 : }
      42             : 
      43             : TargetMachine::~TargetMachine() = default;
      44             : 
      45     6843164 : bool TargetMachine::isPositionIndependent() const {
      46     6843164 :   return getRelocationModel() == Reloc::PIC_;
      47             : }
      48             : 
      49             : /// Reset the target options based on the function's attributes.
      50             : // FIXME: This function needs to go away for a number of reasons:
      51             : // a) global state on the TargetMachine is terrible in general,
      52             : // b) these target options should be passed only on the function
      53             : //    and not on the TargetMachine (via TargetOptions) at all.
      54      434128 : void TargetMachine::resetTargetOptions(const Function &F) const {
      55             : #define RESET_OPTION(X, Y)                                                     \
      56             :   do {                                                                         \
      57             :     if (F.hasFnAttribute(Y))                                                   \
      58             :       Options.X = (F.getFnAttribute(Y).getValueAsString() == "true");          \
      59             :     else                                                                       \
      60             :       Options.X = DefaultOptions.X;                                            \
      61             :   } while (0)
      62             : 
      63      867328 :   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
      64      865134 :   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
      65      865632 :   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
      66      861864 :   RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math");
      67      861242 :   RESET_OPTION(NoTrappingFPMath, "no-trapping-math");
      68             : 
      69             :   StringRef Denormal =
      70      434128 :     F.getFnAttribute("denormal-fp-math").getValueAsString();
      71             :   if (Denormal == "ieee")
      72          12 :     Options.FPDenormalMode = FPDenormal::IEEE;
      73             :   else if (Denormal == "preserve-sign")
      74          10 :     Options.FPDenormalMode = FPDenormal::PreserveSign;
      75             :   else if (Denormal == "positive-zero")
      76           3 :     Options.FPDenormalMode = FPDenormal::PositiveZero;
      77             :   else
      78      434103 :     Options.FPDenormalMode = DefaultOptions.FPDenormalMode;
      79      434128 : }
      80             : 
      81             : /// Returns the code generation relocation model. The choices are static, PIC,
      82             : /// and dynamic-no-pic.
      83     7637468 : Reloc::Model TargetMachine::getRelocationModel() const { return RM; }
      84             : 
      85             : /// Returns the code model. The choices are small, kernel, medium, large, and
      86             : /// target default.
      87    20239974 : CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; }
      88             : 
      89             : /// Get the IR-specified TLS model for Var.
      90             : static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
      91         653 :   switch (GV->getThreadLocalMode()) {
      92             :   case GlobalVariable::NotThreadLocal:
      93             :     llvm_unreachable("getSelectedTLSModel for non-TLS variable");
      94             :     break;
      95             :   case GlobalVariable::GeneralDynamicTLSModel:
      96             :     return TLSModel::GeneralDynamic;
      97             :   case GlobalVariable::LocalDynamicTLSModel:
      98             :     return TLSModel::LocalDynamic;
      99             :   case GlobalVariable::InitialExecTLSModel:
     100             :     return TLSModel::InitialExec;
     101             :   case GlobalVariable::LocalExecTLSModel:
     102             :     return TLSModel::LocalExec;
     103             :   }
     104           0 :   llvm_unreachable("invalid TLS model");
     105             : }
     106             : 
     107     5724599 : bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
     108             :                                          const GlobalValue *GV) const {
     109             :   // If the IR producer requested that this GV be treated as dso local, obey.
     110     5724599 :   if (GV && GV->isDSOLocal())
     111             :     return true;
     112             : 
     113             :   // If we are not supossed to use a PLT, we cannot assume that intrinsics are
     114             :   // local since the linker can convert some direct access to access via plt.
     115      241404 :   if (M.getRtLibUseGOT() && !GV)
     116             :     return false;
     117             : 
     118             :   // According to the llvm language reference, we should be able to
     119             :   // just return false in here if we have a GV, as we know it is
     120             :   // dso_preemptable.  At this point in time, the various IR producers
     121             :   // have not been transitioned to always produce a dso_local when it
     122             :   // is possible to do so.
     123             :   // In the case of intrinsics, GV is null and there is nowhere to put
     124             :   // dso_local. Returning false for those will produce worse code in some
     125             :   // architectures. For example, on x86 the caller has to set ebx before calling
     126             :   // a plt.
     127             :   // As a result we still have some logic in here to improve the quality of the
     128             :   // generated code.
     129             :   // FIXME: Add a module level metadata for whether intrinsics should be assumed
     130             :   // local.
     131             : 
     132      241400 :   Reloc::Model RM = getRelocationModel();
     133             :   const Triple &TT = getTargetTriple();
     134             : 
     135             :   // DLLImport explicitly marks the GV as external.
     136      241400 :   if (GV && GV->hasDLLImportStorageClass())
     137             :     return false;
     138             : 
     139             :   // On MinGW, variables that haven't been declared with DLLImport may still
     140             :   // end up automatically imported by the linker. To make this feasible,
     141             :   // don't assume the variables to be DSO local unless we actually know
     142             :   // that for sure. This only has to be done for variables; for functions
     143             :   // the linker can insert thunks for calling functions from another DLL.
     144        1007 :   if (TT.isWindowsGNUEnvironment() && GV && GV->isDeclarationForLinker() &&
     145             :       isa<GlobalVariable>(GV))
     146             :     return false;
     147             : 
     148             :   // Every other GV is local on COFF.
     149             :   // Make an exception for windows OS in the triple: Some firmware builds use
     150             :   // *-win32-macho triples. This (accidentally?) produced windows relocations
     151             :   // without GOT tables in older clang versions; Keep this behaviour.
     152      241154 :   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     153             :     return true;
     154             : 
     155             :   // Most PIC code sequences that assume that a symbol is local cannot
     156             :   // produce a 0 if it turns out the symbol is undefined. While this
     157             :   // is ABI and relocation depended, it seems worth it to handle it
     158             :   // here.
     159      238117 :   if (GV && isPositionIndependent() && GV->hasExternalWeakLinkage())
     160             :     return false;
     161             : 
     162      238078 :   if (GV && !GV->hasDefaultVisibility())
     163             :     return true;
     164             : 
     165      238070 :   if (TT.isOSBinFormatMachO()) {
     166       15721 :     if (RM == Reloc::Static)
     167             :       return true;
     168       14793 :     return GV && GV->isStrongDefinitionForLinker();
     169             :   }
     170             : 
     171             :   assert(TT.isOSBinFormatELF());
     172             :   assert(RM != Reloc::DynamicNoPIC);
     173             : 
     174             :   bool IsExecutable =
     175      222349 :       RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
     176             :   if (IsExecutable) {
     177             :     // If the symbol is defined, it cannot be preempted.
     178      240523 :     if (GV && !GV->isDeclarationForLinker())
     179             :       return true;
     180             : 
     181             :     // A symbol marked nonlazybind should not be accessed with a plt. If the
     182             :     // symbol turns out to be external, the linker will convert a direct
     183             :     // access to an access via the plt, so don't assume it is local.
     184             :     const Function *F = dyn_cast_or_null<Function>(GV);
     185       85732 :     if (F && F->hasFnAttribute(Attribute::NonLazyBind))
     186             :       return false;
     187             : 
     188      108500 :     bool IsTLS = GV && GV->isThreadLocal();
     189             :     bool IsAccessViaCopyRelocs =
     190      108500 :         GV && Options.MCOptions.MCPIECopyRelocations && isa<GlobalVariable>(GV);
     191      108500 :     Triple::ArchType Arch = TT.getArch();
     192             :     bool IsPPC =
     193      108500 :         Arch == Triple::ppc || Arch == Triple::ppc64 || Arch == Triple::ppc64le;
     194             :     // Check if we can use copy relocations. PowerPC has no copy relocations.
     195      108500 :     if (!IsTLS && !IsPPC && (RM == Reloc::Static || IsAccessViaCopyRelocs))
     196      107842 :       return true;
     197             :   }
     198             : 
     199             :   // ELF supports preemption of other symbols.
     200             :   return false;
     201             : }
     202             : 
     203      320174 : bool TargetMachine::useEmulatedTLS() const {
     204             :   // Returns Options.EmulatedTLS if the -emulated-tls or -no-emulated-tls
     205             :   // was specified explicitly; otherwise uses target triple to decide default.
     206      320174 :   if (Options.ExplicitEmulatedTLS)
     207        1491 :     return Options.EmulatedTLS;
     208             :   return getTargetTriple().hasDefaultEmulatedTLS();
     209             : }
     210             : 
     211         653 : TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
     212         653 :   bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
     213         653 :   Reloc::Model RM = getRelocationModel();
     214         653 :   bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
     215         653 :   bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
     216             : 
     217             :   TLSModel::Model Model;
     218         653 :   if (IsSharedLibrary) {
     219         289 :     if (IsLocal)
     220             :       Model = TLSModel::LocalDynamic;
     221             :     else
     222             :       Model = TLSModel::GeneralDynamic;
     223             :   } else {
     224         364 :     if (IsLocal)
     225             :       Model = TLSModel::LocalExec;
     226             :     else
     227             :       Model = TLSModel::InitialExec;
     228             :   }
     229             : 
     230             :   // If the user specified a more specific model, use that.
     231             :   TLSModel::Model SelectedModel = getSelectedTLSModel(GV);
     232         653 :   if (SelectedModel > Model)
     233         102 :     return SelectedModel;
     234             : 
     235             :   return Model;
     236             : }
     237             : 
     238             : /// Returns the optimization level: None, Less, Default, or Aggressive.
     239    10078704 : CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; }
     240             : 
     241         372 : void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; }
     242             : 
     243           0 : TargetTransformInfo TargetMachine::getTargetTransformInfo(const Function &F) {
     244           0 :   return TargetTransformInfo(F.getParent()->getDataLayout());
     245             : }
     246             : 
     247     5216125 : void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name,
     248             :                                       const GlobalValue *GV, Mangler &Mang,
     249             :                                       bool MayAlwaysUsePrivate) const {
     250     5216125 :   if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) {
     251             :     // Simple case: If GV is not private, it is not important to find out if
     252             :     // private labels are legal in this case or not.
     253     4055081 :     Mang.getNameWithPrefix(Name, GV, false);
     254     4055081 :     return;
     255             :   }
     256     1161044 :   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
     257     1161044 :   TLOF->getNameWithPrefix(Name, GV, *this);
     258             : }
     259             : 
     260     1505388 : MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const {
     261     1505388 :   const TargetLoweringObjectFile *TLOF = getObjFileLowering();
     262             :   SmallString<128> NameStr;
     263     1505389 :   getNameWithPrefix(NameStr, GV, TLOF->getMangler());
     264     3010778 :   return TLOF->getContext().getOrCreateSymbol(NameStr);
     265             : }
     266             : 
     267       75817 : TargetIRAnalysis TargetMachine::getTargetIRAnalysis() {
     268             :   // Since Analysis can't depend on Target, use a std::function to invert the
     269             :   // dependency.
     270             :   return TargetIRAnalysis(
     271     3135973 :       [this](const Function &F) { return this->getTargetTransformInfo(F); });
     272             : }

Generated by: LCOV version 1.13