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.
35class PseudoSourceValue {
36public:
37 enum PSVKind : unsigned {
38 Stack,
39 GOT,
40 JumpTable,
41 ConstantPool,
42 FixedStack,
43 GlobalValueCallEntry,
44 ExternalSymbolCallEntry,
45 TargetCustom
46 };
47
48private:
49 unsigned Kind;
50 unsigned AddressSpace;
51 friend raw_ostream &llvm::operator<<(raw_ostream &OS,
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
64 virtual ~PseudoSourceValue();
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.
94class FixedStackPseudoSourceValue : public PseudoSourceValue {
95 const int FI;
96
97public:
98 explicit FixedStackPseudoSourceValue(int FI, const TargetMachine &TM)
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
116class CallEntryPseudoSourceValue : public PseudoSourceValue {
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.
127class GlobalValuePseudoSourceValue : public CallEntryPseudoSourceValue {
128 const GlobalValue *GV;
129
130public:
131 GlobalValuePseudoSourceValue(const GlobalValue *GV, const TargetMachine &TM);
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.
141class ExternalSymbolPseudoSourceValue : public CallEntryPseudoSourceValue {
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.
155class PseudoSourceValueManager {
156 const TargetMachine &TM;
157 const PseudoSourceValue StackPSV, GOTPSV, JumpTablePSV, ConstantPoolPSV;
158 std::map<int, std::unique_ptr<FixedStackPseudoSourceValue>> FSValues;
159 StringMap<std::unique_ptr<const ExternalSymbolPseudoSourceValue>>
160 ExternalCallEntries;
161 ValueMap<const GlobalValue *,
162 std::unique_ptr<const GlobalValuePseudoSourceValue>>
163 GlobalCallEntries;
164
165public:
166 PseudoSourceValueManager(const TargetMachine &TM);
167
168 /// Return a pseudo source value referencing the area below the stack frame of
169 /// a function, e.g., the argument space.
170 const PseudoSourceValue *getStack();
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.
179 const PseudoSourceValue *getConstantPool();
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.
183 const PseudoSourceValue *getJumpTable();
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
189 const PseudoSourceValue *getGlobalValueCallEntry(const GlobalValue *GV);
190
191 const PseudoSourceValue *getExternalSymbolCallEntry(const char *ES);
192};
193
194} // end namespace llvm
195
196#endif
197

source code of llvm/include/llvm/CodeGen/PseudoSourceValue.h