LLVM  14.0.0git
PseudoSourceValue.cpp
Go to the documentation of this file.
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 
14 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/IR/DerivedTypes.h"
18 #include "llvm/IR/LLVMContext.h"
21 using namespace llvm;
22 
23 static const char *const PSVNames[] = {
24  "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
25  "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
26 
28  : Kind(Kind) {
29  AddressSpace = TII.getAddressSpaceForPseudoSourceKind(Kind);
30 }
31 
32 
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 
43  if (isStack())
44  return false;
45  if (isGOT() || isConstantPool() || isJumpTable())
46  return true;
47  llvm_unreachable("Unknown PseudoSourceValue!");
48 }
49 
51  if (isStack() || isGOT() || isConstantPool() || isJumpTable())
52  return false;
53  llvm_unreachable("Unknown PseudoSourceValue!");
54 }
55 
57  return !(isGOT() || isConstantPool() || isJumpTable());
58 }
59 
61  const MachineFrameInfo *MFI) const {
62  return MFI && MFI->isImmutableObjectIndex(FI);
63 }
64 
66  if (!MFI)
67  return true;
68  return MFI->isAliasedObjectIndex(FI);
69 }
70 
72  if (!MFI)
73  return true;
74  // Spill slots will not alias any LLVM IR value.
75  return !MFI->isSpillSlotObjectIndex(FI);
76 }
77 
79  OS << "FixedStack" << FI;
80 }
81 
83  unsigned Kind, const TargetInstrInfo &TII)
85 
87  return false;
88 }
89 
91  return false;
92 }
93 
95  return false;
96 }
97 
99  const GlobalValue *GV,
100  const TargetInstrInfo &TII)
101  : CallEntryPseudoSourceValue(GlobalValueCallEntry, TII), GV(GV) {}
103  const char *ES, const TargetInstrInfo &TII)
104  : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TII), ES(ES) {}
105 
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 
115  return &StackPSV;
116 }
117 
119 
121  return &ConstantPoolPSV;
122 }
123 
125  return &JumpTablePSV;
126 }
127 
128 const PseudoSourceValue *
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 *
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 *
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 }
llvm::PseudoSourceValueManager::getGOT
const PseudoSourceValue * getGOT()
Return a pseudo source value referencing the global offset table (or something the like).
Definition: PseudoSourceValue.cpp:118
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::PseudoSourceValue::isAliased
virtual bool isAliased(const MachineFrameInfo *) const
Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an LLVM IR Val...
Definition: PseudoSourceValue.cpp:50
ErrorHandling.h
llvm::ConstantPool
Definition: ConstantPools.h:43
llvm::PseudoSourceValue::mayAlias
virtual bool mayAlias(const MachineFrameInfo *) const
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
Definition: PseudoSourceValue.cpp:56
TargetInstrInfo.h
llvm::FixedStackPseudoSourceValue::mayAlias
bool mayAlias(const MachineFrameInfo *) const override
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
Definition: PseudoSourceValue.cpp:71
STLExtras.h
llvm::PseudoSourceValueManager::getStack
const PseudoSourceValue * getStack()
Return a pseudo source value referencing the area below the stack frame of a function,...
Definition: PseudoSourceValue.cpp:114
llvm::TargetInstrInfo
TargetInstrInfo - Interface to description of machine instruction set.
Definition: TargetInstrInfo.h:97
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::PseudoSourceValue::isStack
bool isStack() const
Definition: PseudoSourceValue.h:68
PseudoSourceValue.h
TII
const HexagonInstrInfo * TII
Definition: HexagonCopyToCombine.cpp:129
llvm::PseudoSourceValueManager::PseudoSourceValueManager
PseudoSourceValueManager(const TargetInstrInfo &TII)
Definition: PseudoSourceValue.cpp:106
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::MachineFrameInfo::isAliasedObjectIndex
bool isAliasedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to an object that might be pointed to by an LLVM IR v...
Definition: MachineFrameInfo.h:662
llvm::PseudoSourceValue
Special value supplied for machine level alias analysis.
Definition: PseudoSourceValue.h:35
llvm::AddressSpace
AddressSpace
Definition: NVPTXBaseInfo.h:21
llvm::PseudoSourceValue::TargetCustom
@ TargetCustom
Definition: PseudoSourceValue.h:45
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::PseudoSourceValue::isGOT
bool isGOT() const
Definition: PseudoSourceValue.h:69
llvm::FixedStackPseudoSourceValue::isConstant
bool isConstant(const MachineFrameInfo *MFI) const override
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
Definition: PseudoSourceValue.cpp:60
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:192
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::CallEntryPseudoSourceValue::isAliased
bool isAliased(const MachineFrameInfo *) const override
Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an LLVM IR Val...
Definition: PseudoSourceValue.cpp:90
llvm::FixedStackPseudoSourceValue::isAliased
bool isAliased(const MachineFrameInfo *MFI) const override
Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an LLVM IR Val...
Definition: PseudoSourceValue.cpp:65
llvm::CallEntryPseudoSourceValue::isConstant
bool isConstant(const MachineFrameInfo *) const override
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
Definition: PseudoSourceValue.cpp:86
llvm::PseudoSourceValue::PseudoSourceValue
PseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII)
Definition: PseudoSourceValue.cpp:27
llvm::PseudoSourceValue::~PseudoSourceValue
virtual ~PseudoSourceValue()
Definition: PseudoSourceValue.cpp:33
llvm::GlobalValuePseudoSourceValue::GlobalValuePseudoSourceValue
GlobalValuePseudoSourceValue(const GlobalValue *GV, const TargetInstrInfo &TII)
Definition: PseudoSourceValue.cpp:98
llvm::CallEntryPseudoSourceValue
Definition: PseudoSourceValue.h:116
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::CallEntryPseudoSourceValue::CallEntryPseudoSourceValue
CallEntryPseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII)
Definition: PseudoSourceValue.cpp:82
llvm::PseudoSourceValueManager::getJumpTable
const PseudoSourceValue * getJumpTable()
Return a pseudo source value referencing a jump table.
Definition: PseudoSourceValue.cpp:124
llvm::PseudoSourceValueManager::getGlobalValueCallEntry
const PseudoSourceValue * getGlobalValueCallEntry(const GlobalValue *GV)
Definition: PseudoSourceValue.cpp:137
llvm::PseudoSourceValueManager::getFixedStack
const PseudoSourceValue * getFixedStack(int FI)
Return a pseudo source value referencing a fixed stack frame entry, e.g., a spill slot.
Definition: PseudoSourceValue.cpp:129
MachineFrameInfo.h
JumpTable
MIPS Relocation Principles In there are several elements of the llvm::ISD::NodeType enum that deal with addresses and or relocations These are defined in include llvm Target TargetSelectionDAG td JumpTable
Definition: Relocation.txt:6
llvm::CallEntryPseudoSourceValue::mayAlias
bool mayAlias(const MachineFrameInfo *) const override
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
Definition: PseudoSourceValue.cpp:94
llvm::MachineFrameInfo::isSpillSlotObjectIndex
bool isSpillSlotObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a spill slot.
Definition: MachineFrameInfo.h:686
llvm::FixedStackPseudoSourceValue::printCustom
void printCustom(raw_ostream &OS) const override
Implement printing for PseudoSourceValue.
Definition: PseudoSourceValue.cpp:78
llvm::PseudoSourceValue::isConstantPool
bool isConstantPool() const
Definition: PseudoSourceValue.h:70
llvm::MachineFrameInfo::isImmutableObjectIndex
bool isImmutableObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to an immutable object.
Definition: MachineFrameInfo.h:669
llvm::MachineFrameInfo
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Definition: MachineFrameInfo.h:107
llvm::PseudoSourceValue::isJumpTable
bool isJumpTable() const
Definition: PseudoSourceValue.h:71
PSVNames
static const char *const PSVNames[]
Definition: PseudoSourceValue.cpp:23
DerivedTypes.h
LLVMContext.h
raw_ostream.h
llvm::PseudoSourceValueManager::getExternalSymbolCallEntry
const PseudoSourceValue * getExternalSymbolCallEntry(const char *ES)
Definition: PseudoSourceValue.cpp:146
llvm::PseudoSourceValue::isConstant
virtual bool isConstant(const MachineFrameInfo *) const
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
Definition: PseudoSourceValue.cpp:42
llvm::PseudoSourceValueManager::getConstantPool
const PseudoSourceValue * getConstantPool()
Return a pseudo source value referencing the constant pool.
Definition: PseudoSourceValue.cpp:120
llvm::ExternalSymbolPseudoSourceValue::ExternalSymbolPseudoSourceValue
ExternalSymbolPseudoSourceValue(const char *ES, const TargetInstrInfo &TII)
Definition: PseudoSourceValue.cpp:102