LCOV - code coverage report
Current view: top level - lib/CodeGen - PseudoSourceValue.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 62 65 95.4 %
Date: 2017-09-14 15:23:50 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/IR/DerivedTypes.h"
      18             : #include "llvm/IR/LLVMContext.h"
      19             : #include "llvm/Support/ErrorHandling.h"
      20             : #include "llvm/Support/raw_ostream.h"
      21             : using namespace llvm;
      22             : 
      23             : static const char *const PSVNames[] = {
      24             :     "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
      25             :     "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
      26             : 
      27      682410 : PseudoSourceValue::PseudoSourceValue(PSVKind Kind) : Kind(Kind) {}
      28             : 
      29      681887 : PseudoSourceValue::~PseudoSourceValue() {}
      30             : 
      31        1043 : void PseudoSourceValue::printCustom(raw_ostream &O) const {
      32        1043 :   if (Kind < TargetCustom)
      33        1043 :     O << PSVNames[Kind];
      34             :   else
      35           0 :     O << "TargetCustom" << Kind;
      36        1043 : }
      37             : 
      38      161991 : bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      39      161991 :   if (isStack())
      40             :     return false;
      41      161991 :   if (isGOT() || isConstantPool() || isJumpTable())
      42             :     return true;
      43           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      44             : }
      45             : 
      46      109220 : bool PseudoSourceValue::isAliased(const MachineFrameInfo *) const {
      47      109220 :   if (isStack() || isGOT() || isConstantPool() || isJumpTable())
      48      109220 :     return false;
      49           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      50             : }
      51             : 
      52      111369 : bool PseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
      53      111369 :   return !(isGOT() || isConstantPool() || isJumpTable());
      54             : }
      55             : 
      56      226900 : bool FixedStackPseudoSourceValue::isConstant(
      57             :     const MachineFrameInfo *MFI) const {
      58      451395 :   return MFI && MFI->isImmutableObjectIndex(FI);
      59             : }
      60             : 
      61       66207 : bool FixedStackPseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const {
      62       66207 :   if (!MFI)
      63             :     return true;
      64      132414 :   return MFI->isAliasedObjectIndex(FI);
      65             : }
      66             : 
      67      105720 : bool FixedStackPseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const {
      68      105720 :   if (!MFI)
      69             :     return true;
      70             :   // Spill slots will not alias any LLVM IR value.
      71      211440 :   return !MFI->isSpillSlotObjectIndex(FI);
      72             : }
      73             : 
      74         962 : void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
      75        1924 :   OS << "FixedStack" << FI;
      76         962 : }
      77             : 
      78        1293 : CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(PSVKind Kind)
      79        1293 :     : PseudoSourceValue(Kind) {}
      80             : 
      81        5435 : bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      82        5435 :   return false;
      83             : }
      84             : 
      85         636 : bool CallEntryPseudoSourceValue::isAliased(const MachineFrameInfo *) const {
      86         636 :   return false;
      87             : }
      88             : 
      89         232 : bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
      90         232 :   return false;
      91             : }
      92             : 
      93         688 : GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue(
      94         688 :     const GlobalValue *GV)
      95         688 :     : CallEntryPseudoSourceValue(GlobalValueCallEntry), GV(GV) {}
      96             : 
      97         605 : ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(const char *ES)
      98         605 :     : CallEntryPseudoSourceValue(ExternalSymbolCallEntry), ES(ES) {}
      99             : 
     100      145510 : PseudoSourceValueManager::PseudoSourceValueManager()
     101             :     : StackPSV(PseudoSourceValue::Stack), GOTPSV(PseudoSourceValue::GOT),
     102             :       JumpTablePSV(PseudoSourceValue::JumpTable),
     103      582040 :       ConstantPoolPSV(PseudoSourceValue::ConstantPool) {}
     104             : 
     105      144539 : const PseudoSourceValue *PseudoSourceValueManager::getStack() {
     106      144539 :   return &StackPSV;
     107             : }
     108             : 
     109       12654 : const PseudoSourceValue *PseudoSourceValueManager::getGOT() { return &GOTPSV; }
     110             : 
     111       20637 : const PseudoSourceValue *PseudoSourceValueManager::getConstantPool() {
     112       20637 :   return &ConstantPoolPSV;
     113             : }
     114             : 
     115         195 : const PseudoSourceValue *PseudoSourceValueManager::getJumpTable() {
     116         195 :   return &JumpTablePSV;
     117             : }
     118             : 
     119      139350 : const PseudoSourceValue *PseudoSourceValueManager::getFixedStack(int FI) {
     120      139350 :   std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
     121      139350 :   if (!V)
     122      206583 :     V = llvm::make_unique<FixedStackPseudoSourceValue>(FI);
     123      139350 :   return V.get();
     124             : }
     125             : 
     126             : const PseudoSourceValue *
     127        1091 : PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) {
     128             :   std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
     129        1091 :       GlobalCallEntries[GV];
     130        1091 :   if (!E)
     131        1376 :     E = llvm::make_unique<GlobalValuePseudoSourceValue>(GV);
     132        1091 :   return E.get();
     133             : }
     134             : 
     135             : const PseudoSourceValue *
     136         637 : PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
     137             :   std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
     138        1911 :       ExternalCallEntries[ES];
     139         637 :   if (!E)
     140        1210 :     E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES);
     141         637 :   return E.get();
     142             : }

Generated by: LCOV version 1.13