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 namespace llvm { 17 18 class GlobalValue; 19 class MachineFrameInfo; 20 class MachineMemOperand; 21 class MIRFormatter; 22 class PseudoSourceValue; 23 class raw_ostream; 24 class TargetMachine; 25 26 raw_ostream &operator<<(raw_ostream &OS, const PseudoSourceValue* PSV); 27 28 /// Special value supplied for machine level alias analysis. It indicates that 29 /// a memory access references the functions stack frame (e.g., a spill slot), 30 /// below the stack frame (e.g., argument space), or constant pool. 31 class PseudoSourceValue { 32 public: 33 enum PSVKind : unsigned { 34 Stack, 35 GOT, 36 JumpTable, 37 ConstantPool, 38 FixedStack, 39 GlobalValueCallEntry, 40 ExternalSymbolCallEntry, 41 TargetCustom 42 }; 43 44 private: 45 unsigned Kind; 46 unsigned AddressSpace; 47 friend raw_ostream &llvm::operator<<(raw_ostream &OS, 48 const PseudoSourceValue* PSV); 49 50 friend class MachineMemOperand; // For printCustom(). 51 friend class MIRFormatter; // For printCustom(). 52 53 /// Implement printing for PseudoSourceValue. This is called from 54 /// Value::print or Value's operator<<. 55 virtual void printCustom(raw_ostream &O) const; 56 57 public: 58 explicit PseudoSourceValue(unsigned Kind, const TargetMachine &TM); 59 60 virtual ~PseudoSourceValue(); 61 62 unsigned kind() const { return Kind; } 63 64 bool isStack() const { return Kind == Stack; } 65 bool isGOT() const { return Kind == GOT; } 66 bool isConstantPool() const { return Kind == ConstantPool; } 67 bool isJumpTable() const { return Kind == JumpTable; } 68 69 unsigned getAddressSpace() const { return AddressSpace; } 70 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. 90 class FixedStackPseudoSourceValue : public PseudoSourceValue { 91 const int FI; 92 93 public: 94 explicit FixedStackPseudoSourceValue(int FI, const TargetMachine &TM) 95 : PseudoSourceValue(FixedStack, TM), FI(FI) {} 96 97 static 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 112 class CallEntryPseudoSourceValue : public PseudoSourceValue { 113 protected: 114 CallEntryPseudoSourceValue(unsigned Kind, const TargetMachine &TM); 115 116 public: 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 source value for holding GlobalValue values. 123 class GlobalValuePseudoSourceValue : public CallEntryPseudoSourceValue { 124 const GlobalValue *GV; 125 126 public: 127 GlobalValuePseudoSourceValue(const GlobalValue *GV, const TargetMachine &TM); 128 129 static 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. 137 class ExternalSymbolPseudoSourceValue : public CallEntryPseudoSourceValue { 138 const char *ES; 139 140 public: 141 ExternalSymbolPseudoSourceValue(const char *ES, const TargetMachine &TM); 142 143 static bool classof(const PseudoSourceValue *V) { 144 return V->kind() == ExternalSymbolCallEntry; 145 } 146 147 const char *getSymbol() const { return ES; } 148 }; 149 150 } // end namespace llvm 151 152 #endif 153