LCOV - code coverage report
Current view: top level - lib/CodeGen - PseudoSourceValue.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 65 71 91.5 %
Date: 2018-07-13 00:08:38 Functions: 23 25 92.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     1023995 : PseudoSourceValue::PseudoSourceValue(PSVKind Kind, const TargetInstrInfo &TII)
      29     1023995 :     : Kind(Kind) {
      30     1023995 :   AddressSpace = TII.getAddressSpaceForPseudoSourceKind(Kind);
      31     1023995 : }
      32             : 
      33             : 
      34     1023327 : PseudoSourceValue::~PseudoSourceValue() {}
      35             : 
      36           1 : void PseudoSourceValue::printCustom(raw_ostream &O) const {
      37           1 :   if (Kind < TargetCustom)
      38           0 :     O << PSVNames[Kind];
      39             :   else
      40           1 :     O << "TargetCustom" << Kind;
      41           1 : }
      42             : 
      43      199606 : bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      44      199606 :   if (isStack())
      45             :     return false;
      46      199606 :   if (isGOT() || isConstantPool() || isJumpTable())
      47             :     return true;
      48           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      49             : }
      50             : 
      51      111192 : bool PseudoSourceValue::isAliased(const MachineFrameInfo *) const {
      52      111192 :   if (isStack() || isGOT() || isConstantPool() || isJumpTable())
      53      111192 :     return false;
      54           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      55             : }
      56             : 
      57      113924 : bool PseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
      58      113924 :   return !(isGOT() || isConstantPool() || isJumpTable());
      59             : }
      60             : 
      61      254739 : bool FixedStackPseudoSourceValue::isConstant(
      62             :     const MachineFrameInfo *MFI) const {
      63      506887 :   return MFI && MFI->isImmutableObjectIndex(FI);
      64             : }
      65             : 
      66       57003 : bool FixedStackPseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const {
      67       57003 :   if (!MFI)
      68             :     return true;
      69      114006 :   return MFI->isAliasedObjectIndex(FI);
      70             : }
      71             : 
      72       73928 : bool FixedStackPseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const {
      73       73928 :   if (!MFI)
      74             :     return true;
      75             :   // Spill slots will not alias any LLVM IR value.
      76      147856 :   return !MFI->isSpillSlotObjectIndex(FI);
      77             : }
      78             : 
      79           0 : void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
      80           0 :   OS << "FixedStack" << FI;
      81           0 : }
      82             : 
      83        1320 : CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(
      84        1320 :     PSVKind Kind, const TargetInstrInfo &TII)
      85        1320 :     : PseudoSourceValue(Kind, TII) {}
      86             : 
      87        5540 : bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      88        5540 :   return false;
      89             : }
      90             : 
      91         692 : bool CallEntryPseudoSourceValue::isAliased(const MachineFrameInfo *) const {
      92         692 :   return false;
      93             : }
      94             : 
      95         243 : bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
      96         243 :   return false;
      97             : }
      98             : 
      99         712 : GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue(
     100             :     const GlobalValue *GV,
     101         712 :     const TargetInstrInfo &TII)
     102         712 :     : CallEntryPseudoSourceValue(GlobalValueCallEntry, TII), GV(GV) {}
     103         608 : ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(
     104         608 :     const char *ES, const TargetInstrInfo &TII)
     105         608 :     : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TII), ES(ES) {}
     106             : 
     107      225932 : PseudoSourceValueManager::PseudoSourceValueManager(
     108      225932 :     const TargetInstrInfo &TIInfo)
     109             :     : TII(TIInfo),
     110             :       StackPSV(PseudoSourceValue::Stack, TII),
     111             :       GOTPSV(PseudoSourceValue::GOT, TII),
     112             :       JumpTablePSV(PseudoSourceValue::JumpTable, TII),
     113      451864 :       ConstantPoolPSV(PseudoSourceValue::ConstantPool, TII) {}
     114             : 
     115       77405 : const PseudoSourceValue *PseudoSourceValueManager::getStack() {
     116       77405 :   return &StackPSV;
     117             : }
     118             : 
     119       14175 : const PseudoSourceValue *PseudoSourceValueManager::getGOT() { return &GOTPSV; }
     120             : 
     121       26840 : const PseudoSourceValue *PseudoSourceValueManager::getConstantPool() {
     122       26840 :   return &ConstantPoolPSV;
     123             : }
     124             : 
     125         243 : const PseudoSourceValue *PseudoSourceValueManager::getJumpTable() {
     126         243 :   return &JumpTablePSV;
     127             : }
     128             : 
     129             : const PseudoSourceValue *
     130      222897 : PseudoSourceValueManager::getFixedStack(int FI) {
     131      222897 :   std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
     132      222897 :   if (!V)
     133      235712 :     V = llvm::make_unique<FixedStackPseudoSourceValue>(FI, TII);
     134      222897 :   return V.get();
     135             : }
     136             : 
     137             : const PseudoSourceValue *
     138        1125 : PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) {
     139             :   std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
     140        1125 :       GlobalCallEntries[GV];
     141        1125 :   if (!E)
     142         712 :     E = llvm::make_unique<GlobalValuePseudoSourceValue>(GV, TII);
     143        1125 :   return E.get();
     144             : }
     145             : 
     146             : const PseudoSourceValue *
     147         644 : PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
     148             :   std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
     149         644 :       ExternalCallEntries[ES];
     150         644 :   if (!E)
     151         608 :     E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);
     152         644 :   return E.get();
     153             : }

Generated by: LCOV version 1.13