LCOV - code coverage report
Current view: top level - lib/CodeGen - PseudoSourceValue.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 68 71 95.8 %
Date: 2018-02-19 03:08:00 Functions: 24 25 96.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/CodeGen/PseudoSourceValue.cpp ----------------------*- C++ -*-===//
       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 implements the PseudoSourceValue class.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/CodeGen/PseudoSourceValue.h"
      15             : #include "llvm/ADT/STLExtras.h"
      16             : #include "llvm/CodeGen/MachineFrameInfo.h"
      17             : #include "llvm/CodeGen/TargetInstrInfo.h"
      18             : #include "llvm/IR/DerivedTypes.h"
      19             : #include "llvm/IR/LLVMContext.h"
      20             : #include "llvm/Support/ErrorHandling.h"
      21             : #include "llvm/Support/raw_ostream.h"
      22             : using namespace llvm;
      23             : 
      24             : static const char *const PSVNames[] = {
      25             :     "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
      26             :     "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
      27             : 
      28      937059 : PseudoSourceValue::PseudoSourceValue(PSVKind Kind, const TargetInstrInfo &TII)
      29      937059 :     : Kind(Kind) {
      30      937059 :   AddressSpace = TII.getAddressSpaceForPseudoSourceKind(Kind);
      31      937059 : }
      32             : 
      33             : 
      34      936436 : PseudoSourceValue::~PseudoSourceValue() {}
      35             : 
      36        1151 : void PseudoSourceValue::printCustom(raw_ostream &O) const {
      37        1151 :   if (Kind < TargetCustom)
      38        1151 :     O << PSVNames[Kind];
      39             :   else
      40           0 :     O << "TargetCustom" << Kind;
      41        1151 : }
      42             : 
      43      185308 : bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      44      185308 :   if (isStack())
      45             :     return false;
      46      185308 :   if (isGOT() || isConstantPool() || isJumpTable())
      47             :     return true;
      48           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      49             : }
      50             : 
      51      108728 : bool PseudoSourceValue::isAliased(const MachineFrameInfo *) const {
      52      108728 :   if (isStack() || isGOT() || isConstantPool() || isJumpTable())
      53      108728 :     return false;
      54           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      55             : }
      56             : 
      57      111327 : bool PseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
      58      111327 :   return !(isGOT() || isConstantPool() || isJumpTable());
      59             : }
      60             : 
      61      218016 : bool FixedStackPseudoSourceValue::isConstant(
      62             :     const MachineFrameInfo *MFI) const {
      63      433572 :   return MFI && MFI->isImmutableObjectIndex(FI);
      64             : }
      65             : 
      66       57696 : bool FixedStackPseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const {
      67       57696 :   if (!MFI)
      68             :     return true;
      69      115392 :   return MFI->isAliasedObjectIndex(FI);
      70             : }
      71             : 
      72       75870 : bool FixedStackPseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const {
      73       75870 :   if (!MFI)
      74             :     return true;
      75             :   // Spill slots will not alias any LLVM IR value.
      76      151740 :   return !MFI->isSpillSlotObjectIndex(FI);
      77             : }
      78             : 
      79        1034 : void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
      80        1034 :   OS << "FixedStack" << FI;
      81        1034 : }
      82             : 
      83        1303 : CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(
      84        1303 :     PSVKind Kind, const TargetInstrInfo &TII)
      85        1303 :     : PseudoSourceValue(Kind, TII) {}
      86             : 
      87        5494 : bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      88        5494 :   return false;
      89             : }
      90             : 
      91         653 : bool CallEntryPseudoSourceValue::isAliased(const MachineFrameInfo *) const {
      92         653 :   return false;
      93             : }
      94             : 
      95         242 : bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
      96         242 :   return false;
      97             : }
      98             : 
      99         701 : GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue(
     100             :     const GlobalValue *GV,
     101         701 :     const TargetInstrInfo &TII)
     102         701 :     : CallEntryPseudoSourceValue(GlobalValueCallEntry, TII), GV(GV) {}
     103         602 : ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(
     104         602 :     const char *ES, const TargetInstrInfo &TII)
     105         602 :     : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TII), ES(ES) {}
     106             : 
     107      204934 : PseudoSourceValueManager::PseudoSourceValueManager(
     108      204934 :     const TargetInstrInfo &TIInfo)
     109             :     : TII(TIInfo),
     110             :       StackPSV(PseudoSourceValue::Stack, TII),
     111             :       GOTPSV(PseudoSourceValue::GOT, TII),
     112             :       JumpTablePSV(PseudoSourceValue::JumpTable, TII),
     113      409868 :       ConstantPoolPSV(PseudoSourceValue::ConstantPool, TII) {}
     114             : 
     115      147731 : const PseudoSourceValue *PseudoSourceValueManager::getStack() {
     116      147731 :   return &StackPSV;
     117             : }
     118             : 
     119       13459 : const PseudoSourceValue *PseudoSourceValueManager::getGOT() { return &GOTPSV; }
     120             : 
     121       24681 : const PseudoSourceValue *PseudoSourceValueManager::getConstantPool() {
     122       24681 :   return &ConstantPoolPSV;
     123             : }
     124             : 
     125         203 : const PseudoSourceValue *PseudoSourceValueManager::getJumpTable() {
     126         203 :   return &JumpTablePSV;
     127             : }
     128             : 
     129             : const PseudoSourceValue *
     130      222401 : PseudoSourceValueManager::getFixedStack(int FI) {
     131      222401 :   std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
     132      222401 :   if (!V)
     133      230110 :     V = llvm::make_unique<FixedStackPseudoSourceValue>(FI, TII);
     134      222401 :   return V.get();
     135             : }
     136             : 
     137             : const PseudoSourceValue *
     138        1114 : PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) {
     139             :   std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
     140        1114 :       GlobalCallEntries[GV];
     141        1114 :   if (!E)
     142         701 :     E = llvm::make_unique<GlobalValuePseudoSourceValue>(GV, TII);
     143        1114 :   return E.get();
     144             : }
     145             : 
     146             : const PseudoSourceValue *
     147         638 : PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
     148             :   std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
     149         638 :       ExternalCallEntries[ES];
     150         638 :   if (!E)
     151         602 :     E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);
     152         638 :   return E.get();
     153             : }

Generated by: LCOV version 1.13