Home | History | Annotate | Download | only in CodeGen 
      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/ADT/STLExtras.h"
     15 #include "llvm/CodeGen/PseudoSourceValue.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/ManagedStatic.h"
     21 #include "llvm/Support/Mutex.h"
     22 #include "llvm/Support/raw_ostream.h"
     23 #include <map>
     24 using namespace llvm;
     25 
     26 static const char *const PSVNames[] = {
     27     "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
     28     "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
     29 
     30 PseudoSourceValue::PseudoSourceValue(PSVKind Kind) : Kind(Kind) {}
     31 
     32 PseudoSourceValue::~PseudoSourceValue() {}
     33 
     34 void PseudoSourceValue::printCustom(raw_ostream &O) const {
     35   O << PSVNames[Kind];
     36 }
     37 
     38 bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
     39   if (isStack())
     40     return false;
     41   if (isGOT() || isConstantPool() || isJumpTable())
     42     return true;
     43   llvm_unreachable("Unknown PseudoSourceValue!");
     44 }
     45 
     46 bool PseudoSourceValue::isAliased(const MachineFrameInfo *) const {
     47   if (isStack() || isGOT() || isConstantPool() || isJumpTable())
     48     return false;
     49   llvm_unreachable("Unknown PseudoSourceValue!");
     50 }
     51 
     52 bool PseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
     53   return !(isGOT() || isConstantPool() || isJumpTable());
     54 }
     55 
     56 bool FixedStackPseudoSourceValue::isConstant(
     57     const MachineFrameInfo *MFI) const {
     58   return MFI && MFI->isImmutableObjectIndex(FI);
     59 }
     60 
     61 bool FixedStackPseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const {
     62   if (!MFI)
     63     return true;
     64   return MFI->isAliasedObjectIndex(FI);
     65 }
     66 
     67 bool FixedStackPseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const {
     68   if (!MFI)
     69     return true;
     70   // Spill slots will not alias any LLVM IR value.
     71   return !MFI->isSpillSlotObjectIndex(FI);
     72 }
     73 
     74 void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
     75   OS << "FixedStack" << FI;
     76 }
     77 
     78 CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(PSVKind Kind)
     79     : PseudoSourceValue(Kind) {}
     80 
     81 bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
     82   return false;
     83 }
     84 
     85 bool CallEntryPseudoSourceValue::isAliased(const MachineFrameInfo *) const {
     86   return false;
     87 }
     88 
     89 bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
     90   return false;
     91 }
     92 
     93 GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue(
     94     const GlobalValue *GV)
     95     : CallEntryPseudoSourceValue(GlobalValueCallEntry), GV(GV) {}
     96 
     97 ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(const char *ES)
     98     : CallEntryPseudoSourceValue(ExternalSymbolCallEntry), ES(ES) {}
     99 
    100 PseudoSourceValueManager::PseudoSourceValueManager()
    101     : StackPSV(PseudoSourceValue::Stack), GOTPSV(PseudoSourceValue::GOT),
    102       JumpTablePSV(PseudoSourceValue::JumpTable),
    103       ConstantPoolPSV(PseudoSourceValue::ConstantPool) {}
    104 
    105 const PseudoSourceValue *PseudoSourceValueManager::getStack() {
    106   return &StackPSV;
    107 }
    108 
    109 const PseudoSourceValue *PseudoSourceValueManager::getGOT() { return &GOTPSV; }
    110 
    111 const PseudoSourceValue *PseudoSourceValueManager::getConstantPool() {
    112   return &ConstantPoolPSV;
    113 }
    114 
    115 const PseudoSourceValue *PseudoSourceValueManager::getJumpTable() {
    116   return &JumpTablePSV;
    117 }
    118 
    119 const PseudoSourceValue *PseudoSourceValueManager::getFixedStack(int FI) {
    120   std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
    121   if (!V)
    122     V = llvm::make_unique<FixedStackPseudoSourceValue>(FI);
    123   return V.get();
    124 }
    125 
    126 const PseudoSourceValue *
    127 PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) {
    128   std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
    129       GlobalCallEntries[GV];
    130   if (!E)
    131     E = llvm::make_unique<GlobalValuePseudoSourceValue>(GV);
    132   return E.get();
    133 }
    134 
    135 const PseudoSourceValue *
    136 PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
    137   std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
    138       ExternalCallEntries[ES];
    139   if (!E)
    140     E = llvm::make_unique<ExternalSymbolPseudoSourceValue>(ES);
    141   return E.get();
    142 }
    143