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     3118330 : PseudoSourceValue::PseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII)
      29     3118330 :     : Kind(Kind) {
      30     3118330 :   AddressSpace = TII.getAddressSpaceForPseudoSourceKind(Kind);
      31     3118330 : }
      32             : 
      33             : 
      34     3117618 : 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      234353 : bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      44      234353 :   if (isStack())
      45             :     return false;
      46      234353 :   if (isGOT() || isConstantPool() || isJumpTable())
      47             :     return true;
      48           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      49             : }
      50             : 
      51      135721 : bool PseudoSourceValue::isAliased(const MachineFrameInfo *) const {
      52      135721 :   if (isStack() || isGOT() || isConstantPool() || isJumpTable())
      53      135721 :     return false;
      54           0 :   llvm_unreachable("Unknown PseudoSourceValue!");
      55             : }
      56             : 
      57      141396 : bool PseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
      58      141396 :   return !(isGOT() || isConstantPool() || isJumpTable());
      59             : }
      60             : 
      61      265633 : bool FixedStackPseudoSourceValue::isConstant(
      62             :     const MachineFrameInfo *MFI) const {
      63      265633 :   return MFI && MFI->isImmutableObjectIndex(FI);
      64             : }
      65             : 
      66       54629 : bool FixedStackPseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const {
      67       54629 :   if (!MFI)
      68             :     return true;
      69      109258 :   return MFI->isAliasedObjectIndex(FI);
      70             : }
      71             : 
      72       69353 : bool FixedStackPseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const {
      73       69353 :   if (!MFI)
      74             :     return true;
      75             :   // Spill slots will not alias any LLVM IR value.
      76      138706 :   return !MFI->isSpillSlotObjectIndex(FI);
      77             : }
      78             : 
      79           0 : void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
      80           0 :   OS << "FixedStack" << FI;
      81           0 : }
      82             : 
      83        1326 : CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(
      84        1326 :     unsigned Kind, const TargetInstrInfo &TII)
      85        1326 :     : PseudoSourceValue(Kind, TII) {}
      86             : 
      87        5558 : bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
      88        5558 :   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         614 : ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(
     104         614 :     const char *ES, const TargetInstrInfo &TII)
     105         614 :     : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TII), ES(ES) {}
     106             : 
     107      411211 : PseudoSourceValueManager::PseudoSourceValueManager(
     108      411211 :     const TargetInstrInfo &TIInfo)
     109             :     : TII(TIInfo),
     110             :       StackPSV(PseudoSourceValue::Stack, TII),
     111             :       GOTPSV(PseudoSourceValue::GOT, TII),
     112             :       JumpTablePSV(PseudoSourceValue::JumpTable, TII),
     113      411211 :       ConstantPoolPSV(PseudoSourceValue::ConstantPool, TII) {}
     114             : 
     115      173722 : const PseudoSourceValue *PseudoSourceValueManager::getStack() {
     116      173722 :   return &StackPSV;
     117             : }
     118             : 
     119       16313 : const PseudoSourceValue *PseudoSourceValueManager::getGOT() { return &GOTPSV; }
     120             : 
     121       36069 : const PseudoSourceValue *PseudoSourceValueManager::getConstantPool() {
     122       36069 :   return &ConstantPoolPSV;
     123             : }
     124             : 
     125        3202 : const PseudoSourceValue *PseudoSourceValueManager::getJumpTable() {
     126        3202 :   return &JumpTablePSV;
     127             : }
     128             : 
     129             : const PseudoSourceValue *
     130     3240015 : PseudoSourceValueManager::getFixedStack(int FI) {
     131     3240015 :   std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
     132     3240015 :   if (!V)
     133     2940668 :     V = llvm::make_unique<FixedStackPseudoSourceValue>(FI, TII);
     134     3240015 :   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         650 : PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
     148             :   std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
     149         650 :       ExternalCallEntries[ES];
     150             :   if (!E)
     151         614 :     E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);
     152         650 :   return E.get();
     153             : }