1//===-- llvm/CodeGen/PseudoSourceValue.h ------------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file contains the declaration of the PseudoSourceValue class. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CODEGEN_PSEUDOSOURCEVALUE_H 15#define LLVM_CODEGEN_PSEUDOSOURCEVALUE_H 16 17#include "llvm/ADT/StringMap.h" 18#include "llvm/IR/GlobalValue.h" 19#include "llvm/IR/Value.h" 20#include "llvm/IR/ValueMap.h" 21#include <map> 22 23namespace llvm { 24 25class MachineFrameInfo; 26class MachineMemOperand; 27class raw_ostream; 28 29raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MMO); 30class PseudoSourceValue; 31raw_ostream &operator<<(raw_ostream &OS, const PseudoSourceValue* PSV); 32 33/// Special value supplied for machine level alias analysis. It indicates that 34/// a memory access references the functions stack frame (e.g., a spill slot), 35/// below the stack frame (e.g., argument space), or constant pool. 36class PseudoSourceValue { 37public: 38 enum PSVKind { 39 Stack, 40 GOT, 41 JumpTable, 42 ConstantPool, 43 FixedStack, 44 GlobalValueCallEntry, 45 ExternalSymbolCallEntry, 46 TargetCustom 47 }; 48 49private: 50 PSVKind Kind; 51 friend raw_ostream &llvm::operator<<(raw_ostream &OS, 52 const PseudoSourceValue* PSV); 53 54 friend class MachineMemOperand; // For printCustom(). 55 56 /// Implement printing for PseudoSourceValue. This is called from 57 /// Value::print or Value's operator<<. 58 virtual void printCustom(raw_ostream &O) const; 59 60public: 61 explicit PseudoSourceValue(PSVKind Kind); 62 63 virtual ~PseudoSourceValue(); 64 65 PSVKind kind() const { return Kind; } 66 67 bool isStack() const { return Kind == Stack; } 68 bool isGOT() const { return Kind == GOT; } 69 bool isConstantPool() const { return Kind == ConstantPool; } 70 bool isJumpTable() const { return Kind == JumpTable; } 71 unsigned getTargetCustom() const { 72 return (Kind >= TargetCustom) ? ((Kind+1) - TargetCustom) : 0; 73 } 74 75 /// Test whether the memory pointed to by this PseudoSourceValue has a 76 /// constant value. 77 virtual bool isConstant(const MachineFrameInfo *) const; 78 79 /// Test whether the memory pointed to by this PseudoSourceValue may also be 80 /// pointed to by an LLVM IR Value. 81 virtual bool isAliased(const MachineFrameInfo *) const; 82 83 /// Return true if the memory pointed to by this PseudoSourceValue can ever 84 /// alias an LLVM IR Value. 85 virtual bool mayAlias(const MachineFrameInfo *) const; 86}; 87 88/// A specialized PseudoSourceValue for holding FixedStack values, which must 89/// include a frame index. 90class FixedStackPseudoSourceValue : public PseudoSourceValue { 91 const int FI; 92 93public: 94 explicit FixedStackPseudoSourceValue(int FI) 95 : PseudoSourceValue(FixedStack), FI(FI) {} 96 97 static inline bool classof(const PseudoSourceValue *V) { 98 return V->kind() == FixedStack; 99 } 100 101 bool isConstant(const MachineFrameInfo *MFI) const override; 102 103 bool isAliased(const MachineFrameInfo *MFI) const override; 104 105 bool mayAlias(const MachineFrameInfo *) const override; 106 107 void printCustom(raw_ostream &OS) const override; 108 109 int getFrameIndex() const { return FI; } 110}; 111 112class CallEntryPseudoSourceValue : public PseudoSourceValue { 113protected: 114 CallEntryPseudoSourceValue(PSVKind Kind); 115 116public: 117 bool isConstant(const MachineFrameInfo *) const override; 118 bool isAliased(const MachineFrameInfo *) const override; 119 bool mayAlias(const MachineFrameInfo *) const override; 120}; 121 122/// A specialized pseudo soruce value for holding GlobalValue values. 123class GlobalValuePseudoSourceValue : public CallEntryPseudoSourceValue { 124 const GlobalValue *GV; 125 126public: 127 GlobalValuePseudoSourceValue(const GlobalValue *GV); 128 129 static inline bool classof(const PseudoSourceValue *V) { 130 return V->kind() == GlobalValueCallEntry; 131 } 132 133 const GlobalValue *getValue() const { return GV; } 134}; 135 136/// A specialized pseudo source value for holding external symbol values. 137class ExternalSymbolPseudoSourceValue : public CallEntryPseudoSourceValue { 138 const char *ES; 139 140public: 141 ExternalSymbolPseudoSourceValue(const char *ES); 142 143 static inline bool classof(const PseudoSourceValue *V) { 144 return V->kind() == ExternalSymbolCallEntry; 145 } 146 147 const char *getSymbol() const { return ES; } 148}; 149 150/// Manages creation of pseudo source values. 151class PseudoSourceValueManager { 152 const PseudoSourceValue StackPSV, GOTPSV, JumpTablePSV, ConstantPoolPSV; 153 std::map<int, std::unique_ptr<FixedStackPseudoSourceValue>> FSValues; 154 StringMap<std::unique_ptr<const ExternalSymbolPseudoSourceValue>> 155 ExternalCallEntries; 156 ValueMap<const GlobalValue *, 157 std::unique_ptr<const GlobalValuePseudoSourceValue>> 158 GlobalCallEntries; 159 160public: 161 PseudoSourceValueManager(); 162 163 /// Return a pseudo source value referencing the area below the stack frame of 164 /// a function, e.g., the argument space. 165 const PseudoSourceValue *getStack(); 166 167 /// Return a pseudo source value referencing the global offset table 168 /// (or something the like). 169 const PseudoSourceValue *getGOT(); 170 171 /// Return a pseudo source value referencing the constant pool. Since constant 172 /// pools are constant, this doesn't need to identify a specific constant 173 /// pool entry. 174 const PseudoSourceValue *getConstantPool(); 175 176 /// Return a pseudo source value referencing a jump table. Since jump tables 177 /// are constant, this doesn't need to identify a specific jump table. 178 const PseudoSourceValue *getJumpTable(); 179 180 /// Return a pseudo source value referencing a fixed stack frame entry, 181 /// e.g., a spill slot. 182 const PseudoSourceValue *getFixedStack(int FI); 183 184 const PseudoSourceValue *getGlobalValueCallEntry(const GlobalValue *GV); 185 186 const PseudoSourceValue *getExternalSymbolCallEntry(const char *ES); 187}; 188 189} // end namespace llvm 190 191#endif 192