include/llvm/CodeGen/PseudoSourceValue.h

   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/GlobalValue.h"
  18 #include "llvm/IR/ValueMap.h"
  19 #include <map>
  20
  21 namespace llvm {
  22
  23 class MachineFrameInfo;
  24 class MachineMemOperand;
  25 class raw_ostream;
  26 class TargetInstrInfo;
  27
  28 raw_ostream &operator<<(raw_ostream &OS, const MachineMemOperand &MMO);
  29 class PseudoSourceValue;
  30 raw_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.
  35 class PseudoSourceValue {
  36 public:
  37   enum PSVKind : unsigned {
  38     Stack,
  39     GOT,
  40     JumpTable,
  41     ConstantPool,
  42     FixedStack,
  43     GlobalValueCallEntry,
  44     ExternalSymbolCallEntry,
  45     TargetCustom
  46   };
  47
  48 private:
  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
  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
  60 public:
  61   explicit PseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII);
  62
  63   virtual ~PseudoSourceValue();
  64
  65   unsigned 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
  72   unsigned getAddressSpace() const { return AddressSpace; }
  73
  74   unsigned getTargetCustom() const {
  75     return (Kind >= TargetCustom) ? ((Kind+1) - TargetCustom) : 0;
  76   }
  77
  78   /// Test whether the memory pointed to by this PseudoSourceValue has a
  79   /// constant value.
  80   virtual bool isConstant(const MachineFrameInfo *) const;
  81
  82   /// Test whether the memory pointed to by this PseudoSourceValue may also be
  83   /// pointed to by an LLVM IR Value.
  84   virtual bool isAliased(const MachineFrameInfo *) const;
  85
  86   /// Return true if the memory pointed to by this PseudoSourceValue can ever
  87   /// alias an LLVM IR Value.
  88   virtual bool mayAlias(const MachineFrameInfo *) const;
  89 };
  90
  91 /// A specialized PseudoSourceValue for holding FixedStack values, which must
  92 /// include a frame index.
  93 class FixedStackPseudoSourceValue : public PseudoSourceValue {
  94   const int FI;
  95
  96 public:
  97   explicit FixedStackPseudoSourceValue(int FI, const TargetInstrInfo &TII)
  98       : PseudoSourceValue(FixedStack, TII), FI(FI) {}
  99
 100   static bool classof(const PseudoSourceValue *V) {
 101     return V->kind() == FixedStack;
 102   }
 103
 104   bool isConstant(const MachineFrameInfo *MFI) const override;
 105
 106   bool isAliased(const MachineFrameInfo *MFI) const override;
 107
 108   bool mayAlias(const MachineFrameInfo *) const override;
 109
 110   void printCustom(raw_ostream &OS) const override;
 111
 112   int getFrameIndex() const { return FI; }
 113 };
 114
 115 class CallEntryPseudoSourceValue : public PseudoSourceValue {
 116 protected:
 117   CallEntryPseudoSourceValue(unsigned Kind, const TargetInstrInfo &TII);
 118
 119 public:
 120   bool isConstant(const MachineFrameInfo *) const override;
 121   bool isAliased(const MachineFrameInfo *) const override;
 122   bool mayAlias(const MachineFrameInfo *) const override;
 123 };
 124
 125 /// A specialized pseudo source value for holding GlobalValue values.
 126 class GlobalValuePseudoSourceValue : public CallEntryPseudoSourceValue {
 127   const GlobalValue *GV;
 128
 129 public:
 130   GlobalValuePseudoSourceValue(const GlobalValue *GV,
 131                                const TargetInstrInfo &TII);
 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.
 141 class ExternalSymbolPseudoSourceValue : public CallEntryPseudoSourceValue {
 142   const char *ES;
 143
 144 public:
 145   ExternalSymbolPseudoSourceValue(const char *ES, const TargetInstrInfo &TII);
 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.
 155 class PseudoSourceValueManager {
 156   const TargetInstrInfo &TII;
 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
 165 public:
 166   PseudoSourceValueManager(const TargetInstrInfo &TII);
 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