include/llvm/CodeGen/PseudoSourceValue.h

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