LLVM 18.0.0git
PseudoSourceValue.h
Go to the documentation of this file.
1//===-- llvm/CodeGen/PseudoSourceValue.h ------------------------*- 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 contains the declaration of the PseudoSourceValue class.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CODEGEN_PSEUDOSOURCEVALUE_H
14#define LLVM_CODEGEN_PSEUDOSOURCEVALUE_H
15
16#include "llvm/ADT/StringMap.h"
17#include "llvm/IR/ValueMap.h"
18#include <map>
19
20namespace llvm {
21
22class GlobalValue;
23class MachineFrameInfo;
24class MachineMemOperand;
25class MIRFormatter;
26class PseudoSourceValue;
27class raw_ostream;
28class TargetMachine;
29
30raw_ostream &operator<<(raw_ostream &OS, const PseudoSourceValue* PSV);
31
32/// Special value supplied for machine level alias analysis. It indicates that
33/// a memory access references the functions stack frame (e.g., a spill slot),
34/// below the stack frame (e.g., argument space), or constant pool.
36public:
37 enum PSVKind : unsigned {
46 };
47
48private:
49 unsigned Kind;
50 unsigned AddressSpace;
52 const PseudoSourceValue* PSV);
53
54 friend class MachineMemOperand; // For printCustom().
55 friend class MIRFormatter; // For printCustom().
56
57 /// Implement printing for PseudoSourceValue. This is called from
58 /// Value::print or Value's operator<<.
59 virtual void printCustom(raw_ostream &O) const;
60
61public:
62 explicit PseudoSourceValue(unsigned Kind, const TargetMachine &TM);
63
65
66 unsigned kind() const { return Kind; }
67
68 bool isStack() const { return Kind == Stack; }
69 bool isGOT() const { return Kind == GOT; }
70 bool isConstantPool() const { return Kind == ConstantPool; }
71 bool isJumpTable() const { return Kind == JumpTable; }
72
73 unsigned getAddressSpace() const { return AddressSpace; }
74
75 unsigned getTargetCustom() const {
76 return (Kind >= TargetCustom) ? ((Kind+1) - TargetCustom) : 0;
77 }
78
79 /// Test whether the memory pointed to by this PseudoSourceValue has a
80 /// constant value.
81 virtual bool isConstant(const MachineFrameInfo *) const;
82
83 /// Test whether the memory pointed to by this PseudoSourceValue may also be
84 /// pointed to by an LLVM IR Value.
85 virtual bool isAliased(const MachineFrameInfo *) const;
86
87 /// Return true if the memory pointed to by this PseudoSourceValue can ever
88 /// alias an LLVM IR Value.
89 virtual bool mayAlias(const MachineFrameInfo *) const;
90};
91
92/// A specialized PseudoSourceValue for holding FixedStack values, which must
93/// include a frame index.
95 const int FI;
96
97public:
99 : PseudoSourceValue(FixedStack, TM), FI(FI) {}
100
101 static bool classof(const PseudoSourceValue *V) {
102 return V->kind() == FixedStack;
103 }
104
105 bool isConstant(const MachineFrameInfo *MFI) const override;
106
107 bool isAliased(const MachineFrameInfo *MFI) const override;
108
109 bool mayAlias(const MachineFrameInfo *) const override;
110
111 void printCustom(raw_ostream &OS) const override;
112
113 int getFrameIndex() const { return FI; }
114};
115
117protected:
118 CallEntryPseudoSourceValue(unsigned Kind, const TargetMachine &TM);
119
120public:
121 bool isConstant(const MachineFrameInfo *) const override;
122 bool isAliased(const MachineFrameInfo *) const override;
123 bool mayAlias(const MachineFrameInfo *) const override;
124};
125
126/// A specialized pseudo source value for holding GlobalValue values.
128 const GlobalValue *GV;
129
130public:
132
133 static bool classof(const PseudoSourceValue *V) {
134 return V->kind() == GlobalValueCallEntry;
135 }
136
137 const GlobalValue *getValue() const { return GV; }
138};
139
140/// A specialized pseudo source value for holding external symbol values.
142 const char *ES;
143
144public:
145 ExternalSymbolPseudoSourceValue(const char *ES, const TargetMachine &TM);
146
147 static bool classof(const PseudoSourceValue *V) {
148 return V->kind() == ExternalSymbolCallEntry;
149 }
150
151 const char *getSymbol() const { return ES; }
152};
153
154/// Manages creation of pseudo source values.
156 const TargetMachine &TM;
157 const PseudoSourceValue StackPSV, GOTPSV, JumpTablePSV, ConstantPoolPSV;
158 std::map<int, std::unique_ptr<FixedStackPseudoSourceValue>> FSValues;
160 ExternalCallEntries;
161 ValueMap<const GlobalValue *,
162 std::unique_ptr<const GlobalValuePseudoSourceValue>>
163 GlobalCallEntries;
164
165public:
167
168 /// Return a pseudo source value referencing the area below the stack frame of
169 /// a function, e.g., the argument space.
171
172 /// Return a pseudo source value referencing the global offset table
173 /// (or something the like).
174 const PseudoSourceValue *getGOT();
175
176 /// Return a pseudo source value referencing the constant pool. Since constant
177 /// pools are constant, this doesn't need to identify a specific constant
178 /// pool entry.
180
181 /// Return a pseudo source value referencing a jump table. Since jump tables
182 /// are constant, this doesn't need to identify a specific jump table.
184
185 /// Return a pseudo source value referencing a fixed stack frame entry,
186 /// e.g., a spill slot.
187 const PseudoSourceValue *getFixedStack(int FI);
188
190
191 const PseudoSourceValue *getExternalSymbolCallEntry(const char *ES);
192};
193
194} // end namespace llvm
195
196#endif
This file defines the StringMap class.
const char LLVMTargetMachineRef TM
raw_pwrite_stream & OS
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.
A specialized pseudo source value for holding external symbol values.
static bool classof(const PseudoSourceValue *V)
A specialized PseudoSourceValue for holding FixedStack values, which must include a frame index.
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...
FixedStackPseudoSourceValue(int FI, const TargetMachine &TM)
bool mayAlias(const MachineFrameInfo *) const override
Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR Value.
static bool classof(const PseudoSourceValue *V)
bool isConstant(const MachineFrameInfo *MFI) const override
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
A specialized pseudo source value for holding GlobalValue values.
const GlobalValue * getValue() const
static bool classof(const PseudoSourceValue *V)
MIRFormater - Interface to format MIR operand based on target.
Definition: MIRFormatter.h:32
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
A description of a memory reference used in the backend.
Manages creation of pseudo source values.
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.
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...
unsigned getAddressSpace() const
unsigned getTargetCustom() const
virtual bool isConstant(const MachineFrameInfo *) const
Test whether the memory pointed to by this PseudoSourceValue has a constant value.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:112
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
See the file comment.
Definition: ValueMap.h:84
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
AddressSpace
Definition: NVPTXBaseInfo.h:21
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:292