LLVM 19.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
16#include "llvm/IR/GlobalValue.h"
20
21using namespace llvm;
22
23static const char *const PSVNames[] = {
24 "Stack", "GOT", "JumpTable", "ConstantPool", "FixedStack",
25 "GlobalValueCallEntry", "ExternalSymbolCallEntry"};
26
28 : Kind(Kind) {
29 AddressSpace = TM.getAddressSpaceForPseudoSourceKind(Kind);
30}
31
33
34void PseudoSourceValue::printCustom(raw_ostream &O) const {
35 if (Kind < TargetCustom)
36 O << PSVNames[Kind];
37 else
38 O << "TargetCustom" << Kind;
39}
40
42 if (isStack())
43 return false;
44 if (isGOT() || isConstantPool() || isJumpTable())
45 return true;
46 llvm_unreachable("Unknown PseudoSourceValue!");
47}
48
50 if (isStack() || isGOT() || isConstantPool() || isJumpTable())
51 return false;
52 llvm_unreachable("Unknown PseudoSourceValue!");
53}
54
56 return !(isGOT() || isConstantPool() || isJumpTable());
57}
58
60 const MachineFrameInfo *MFI) const {
61 return MFI && MFI->isImmutableObjectIndex(FI);
62}
63
65 if (!MFI)
66 return true;
67 return MFI->isAliasedObjectIndex(FI);
68}
69
71 if (!MFI)
72 return true;
73 // Spill slots will not alias any LLVM IR value.
74 return !MFI->isSpillSlotObjectIndex(FI);
75}
76
78 OS << "FixedStack" << FI;
79}
80
82 const TargetMachine &TM)
83 : PseudoSourceValue(Kind, TM) {}
84
86 return false;
87}
88
90 return false;
91}
92
94 return false;
95}
96
98 const GlobalValue *GV, const TargetMachine &TM)
99 : CallEntryPseudoSourceValue(GlobalValueCallEntry, TM), GV(GV) {}
101 const char *ES, const TargetMachine &TM)
102 : CallEntryPseudoSourceValue(ExternalSymbolCallEntry, TM), ES(ES) {}
103
105 : TM(TMInfo), StackPSV(PseudoSourceValue::Stack, TM),
106 GOTPSV(PseudoSourceValue::GOT, TM),
107 JumpTablePSV(PseudoSourceValue::JumpTable, TM),
108 ConstantPoolPSV(PseudoSourceValue::ConstantPool, TM) {}
109
111 return &StackPSV;
112}
113
115
117 return &ConstantPoolPSV;
118}
119
121 return &JumpTablePSV;
122}
123
124const PseudoSourceValue *
126 // Frame index is often continuously positive, but can be negative. Use
127 // zig-zag encoding for dense index into FSValues vector.
128 unsigned Idx = (2 * unsigned(FI)) ^ (FI >> (sizeof(FI) * 8 - 1));
129 if (FSValues.size() <= Idx)
130 FSValues.resize(Idx + 1);
131 std::unique_ptr<FixedStackPseudoSourceValue> &V = FSValues[Idx];
132 if (!V)
133 V = std::make_unique<FixedStackPseudoSourceValue>(FI, TM);
134 return V.get();
135}
136
137const PseudoSourceValue *
139 std::unique_ptr<const GlobalValuePseudoSourceValue> &E =
140 GlobalCallEntries[GV];
141 if (!E)
142 E = std::make_unique<GlobalValuePseudoSourceValue>(GV, TM);
143 return E.get();
144}
145
146const PseudoSourceValue *
148 std::unique_ptr<const ExternalSymbolPseudoSourceValue> &E =
149 ExternalCallEntries[ES];
150 if (!E)
151 E = std::make_unique<ExternalSymbolPseudoSourceValue>(ES, TM);
152 return E.get();
153}
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
const char LLVMTargetMachineRef TM
static const char *const PSVNames[]
raw_pwrite_stream & OS
CallEntryPseudoSourceValue(unsigned Kind, const TargetMachine &TM)
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...
bool mayAlias(const MachineFrameInfo *) const override
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
bool isConstant(const MachineFrameInfo *) const override
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
ExternalSymbolPseudoSourceValue(const char *ES, const TargetMachine &TM)
void printCustom(raw_ostream &OS) const override
Implement printing for PseudoSourceValue.
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...
bool mayAlias(const MachineFrameInfo *) const override
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
bool isConstant(const MachineFrameInfo *MFI) const override
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
GlobalValuePseudoSourceValue(const GlobalValue *GV, const TargetMachine &TM)
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool isImmutableObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to an immutable object.
bool isSpillSlotObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a spill slot.
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...
const PseudoSourceValue * getJumpTable()
Return a pseudo source value referencing a jump table.
const PseudoSourceValue * getExternalSymbolCallEntry(const char *ES)
const PseudoSourceValue * getFixedStack(int FI)
Return a pseudo source value referencing a fixed stack frame entry, e.g., a spill slot.
const PseudoSourceValue * getGOT()
Return a pseudo source value referencing the global offset table (or something the like).
const PseudoSourceValue * getGlobalValueCallEntry(const GlobalValue *GV)
const PseudoSourceValue * getStack()
Return a pseudo source value referencing the area below the stack frame of a function,...
const PseudoSourceValue * getConstantPool()
Return a pseudo source value referencing the constant pool.
PseudoSourceValueManager(const TargetMachine &TM)
Special value supplied for machine level alias analysis.
virtual bool mayAlias(const MachineFrameInfo *) const
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
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...
PseudoSourceValue(unsigned Kind, const TargetMachine &TM)
virtual bool isConstant(const MachineFrameInfo *) const
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
AddressSpace
Definition: NVPTXBaseInfo.h:21