lib/CodeGen/PseudoSourceValue.cpp

   1 //===-- llvm/CodeGen/PseudoSourceValue.cpp ----------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the PseudoSourceValue class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/CodeGen/PseudoSourceValue.h"
  14 #include "llvm/ADT/STLExtras.h"
  15 #include "llvm/CodeGen/MachineFrameInfo.h"
  16 #include "llvm/CodeGen/TargetInstrInfo.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 PseudoSourceValue::PseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII)
  28     : Kind(Kind) {
  29   AddressSpace = TII.getAddressSpaceForPseudoSourceKind(Kind);
  30 }
  31
  32
  33 PseudoSourceValue::~PseudoSourceValue() {}
  34
  35 void PseudoSourceValue::printCustom(raw_ostream &O) const {
  36   if (Kind < TargetCustom)
  37     O << PSVNames[Kind];
  38   else
  39     O << "TargetCustom" << Kind;
  40 }
  41
  42 bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
  43   if (isStack())
  44     return false;
  45   if (isGOT() || isConstantPool() || isJumpTable())
  46     return true;
  47   llvm_unreachable("Unknown PseudoSourceValue!");
  48 }
  49
  50 bool PseudoSourceValue::isAliased(const MachineFrameInfo *) const {
  51   if (isStack() || isGOT() || isConstantPool() || isJumpTable())
  52     return false;
  53   llvm_unreachable("Unknown PseudoSourceValue!");
  54 }
  55
  56 bool PseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
  57   return !(isGOT() || isConstantPool() || isJumpTable());
  58 }
  59
  60 bool FixedStackPseudoSourceValue::isConstant(
  61     const MachineFrameInfo *MFI) const {
  62   return MFI && MFI->isImmutableObjectIndex(FI);
  63 }
  64
  65 bool FixedStackPseudoSourceValue::isAliased(const MachineFrameInfo *MFI) const {
  66   if (!MFI)
  67     return true;
  68   return MFI->isAliasedObjectIndex(FI);
  69 }
  70
  71 bool FixedStackPseudoSourceValue::mayAlias(const MachineFrameInfo *MFI) const {
  72   if (!MFI)
  73     return true;
  74   // Spill slots will not alias any LLVM IR value.
  75   return !MFI->isSpillSlotObjectIndex(FI);
  76 }
  77
  78 void FixedStackPseudoSourceValue::printCustom(raw_ostream &OS) const {
  79   OS << "FixedStack" << FI;
  80 }
  81
  82 CallEntryPseudoSourceValue::CallEntryPseudoSourceValue(
  83     unsigned Kind, const TargetInstrInfo &TII)
  84     : PseudoSourceValue(Kind, TII) {}
  85
  86 bool CallEntryPseudoSourceValue::isConstant(const MachineFrameInfo *) const {
  87   return false;
  88 }
  89
  90 bool CallEntryPseudoSourceValue::isAliased(const MachineFrameInfo *) const {
  91   return false;
  92 }
  93
  94 bool CallEntryPseudoSourceValue::mayAlias(const MachineFrameInfo *) const {
  95   return false;
  96 }
  97
  98 GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue(
  99     const GlobalValue *GV,
 100     const TargetInstrInfo &TII)
 101     : CallEntryPseudoSourceValue(GlobalValueCallEntry, TII), GV(GV) {}
 102 ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue(
 103     const char *ES, const TargetInstrInfo &TII)
 104     : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TII), ES(ES) {}
 105
 106 PseudoSourceValueManager::PseudoSourceValueManager(
 107     const TargetInstrInfo &TIInfo)
 108     : TII(TIInfo),
 109       StackPSV(PseudoSourceValue::Stack, TII),
 110       GOTPSV(PseudoSourceValue::GOT, TII),
 111       JumpTablePSV(PseudoSourceValue::JumpTable, TII),
 112       ConstantPoolPSV(PseudoSourceValue::ConstantPool, TII) {}
 113
 114 const PseudoSourceValue *PseudoSourceValueManager::getStack() {
 115   return &StackPSV;
 116 }
 117
 118 const PseudoSourceValue *PseudoSourceValueManager::getGOT() { return &GOTPSV; }
 119
 120 const PseudoSourceValue *PseudoSourceValueManager::getConstantPool() {
 121   return &ConstantPoolPSV;
 122 }
 123
 124 const PseudoSourceValue *PseudoSourceValueManager::getJumpTable() {
 125   return &JumpTablePSV;
 126 }
 127
 128 const PseudoSourceValue *
 129 PseudoSourceValueManager::getFixedStack(int FI) {
 130   std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[FI];
 131   if (!V)
 132     V = std::make_unique<FixedStackPseudoSourceValue>(FI, TII);
 133   return V.get();
 134 }
 135
 136 const PseudoSourceValue *
 137 PseudoSourceValueManager::getGlobalValueCallEntry(const GlobalValue *GV) {
 138   std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
 139       GlobalCallEntries[GV];
 140   if (!E)
 141     E = std::make_unique<GlobalValuePseudoSourceValue>(GV, TII);
 142   return E.get();
 143 }
 144
 145 const PseudoSourceValue *
 146 PseudoSourceValueManager::getExternalSymbolCallEntry(const char *ES) {
 147   std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
 148       ExternalCallEntries[ES];
 149   if (!E)
 150     E = std::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);
 151   return E.get();
 152 }