1 //===-- CodeGen/MachineConstantPool.h - Abstract Constant Pool --*- 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 /// @file 11 /// This file declares the MachineConstantPool class which is an abstract 12 /// constant pool to keep track of constants referenced by a function. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_CODEGEN_MACHINECONSTANTPOOL_H 17 #define LLVM_CODEGEN_MACHINECONSTANTPOOL_H 18 19 #include "llvm/ADT/DenseSet.h" 20 #include "llvm/MC/SectionKind.h" 21 #include <cassert> 22 #include <climits> 23 #include <vector> 24 25 namespace llvm { 26 27 class Constant; 28 class FoldingSetNodeID; 29 class DataLayout; 30 class TargetMachine; 31 class Type; 32 class MachineConstantPool; 33 class raw_ostream; 34 35 /// Abstract base class for all machine specific constantpool value subclasses. 36 /// 37 class MachineConstantPoolValue { 38 virtual void anchor(); 39 Type *Ty; 40 41 public: MachineConstantPoolValue(Type * ty)42 explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {} ~MachineConstantPoolValue()43 virtual ~MachineConstantPoolValue() {} 44 45 /// getType - get type of this MachineConstantPoolValue. 46 /// getType()47 Type *getType() const { return Ty; } 48 49 virtual int getExistingMachineCPValue(MachineConstantPool *CP, 50 unsigned Alignment) = 0; 51 52 virtual void addSelectionDAGCSEId(FoldingSetNodeID &ID) = 0; 53 54 /// print - Implement operator<< 55 virtual void print(raw_ostream &O) const = 0; 56 }; 57 58 inline raw_ostream &operator<<(raw_ostream &OS, 59 const MachineConstantPoolValue &V) { 60 V.print(OS); 61 return OS; 62 } 63 64 /// This class is a data container for one entry in a MachineConstantPool. 65 /// It contains a pointer to the value and an offset from the start of 66 /// the constant pool. 67 /// @brief An entry in a MachineConstantPool 68 class MachineConstantPoolEntry { 69 public: 70 /// The constant itself. 71 union { 72 const Constant *ConstVal; 73 MachineConstantPoolValue *MachineCPVal; 74 } Val; 75 76 /// The required alignment for this entry. The top bit is set when Val is 77 /// a target specific MachineConstantPoolValue. 78 unsigned Alignment; 79 MachineConstantPoolEntry(const Constant * V,unsigned A)80 MachineConstantPoolEntry(const Constant *V, unsigned A) 81 : Alignment(A) { 82 Val.ConstVal = V; 83 } MachineConstantPoolEntry(MachineConstantPoolValue * V,unsigned A)84 MachineConstantPoolEntry(MachineConstantPoolValue *V, unsigned A) 85 : Alignment(A) { 86 Val.MachineCPVal = V; 87 Alignment |= 1U << (sizeof(unsigned) * CHAR_BIT - 1); 88 } 89 90 /// isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry 91 /// is indeed a target specific constantpool entry, not a wrapper over a 92 /// Constant. isMachineConstantPoolEntry()93 bool isMachineConstantPoolEntry() const { 94 return (int)Alignment < 0; 95 } 96 getAlignment()97 int getAlignment() const { 98 return Alignment & ~(1 << (sizeof(unsigned) * CHAR_BIT - 1)); 99 } 100 101 Type *getType() const; 102 103 /// This method classifies the entry according to whether or not it may 104 /// generate a relocation entry. This must be conservative, so if it might 105 /// codegen to a relocatable entry, it should say so. 106 bool needsRelocation() const; 107 108 SectionKind getSectionKind(const DataLayout *DL) const; 109 }; 110 111 /// The MachineConstantPool class keeps track of constants referenced by a 112 /// function which must be spilled to memory. This is used for constants which 113 /// are unable to be used directly as operands to instructions, which typically 114 /// include floating point and large integer constants. 115 /// 116 /// Instructions reference the address of these constant pool constants through 117 /// the use of MO_ConstantPoolIndex values. When emitting assembly or machine 118 /// code, these virtual address references are converted to refer to the 119 /// address of the function constant pool values. 120 /// @brief The machine constant pool. 121 class MachineConstantPool { 122 unsigned PoolAlignment; ///< The alignment for the pool. 123 std::vector<MachineConstantPoolEntry> Constants; ///< The pool of constants. 124 /// MachineConstantPoolValues that use an existing MachineConstantPoolEntry. 125 DenseSet<MachineConstantPoolValue*> MachineCPVsSharingEntries; 126 const DataLayout &DL; 127 getDataLayout()128 const DataLayout &getDataLayout() const { return DL; } 129 130 public: 131 /// @brief The only constructor. MachineConstantPool(const DataLayout & DL)132 explicit MachineConstantPool(const DataLayout &DL) 133 : PoolAlignment(1), DL(DL) {} 134 ~MachineConstantPool(); 135 136 /// getConstantPoolAlignment - Return the alignment required by 137 /// the whole constant pool, of which the first element must be aligned. getConstantPoolAlignment()138 unsigned getConstantPoolAlignment() const { return PoolAlignment; } 139 140 /// getConstantPoolIndex - Create a new entry in the constant pool or return 141 /// an existing one. User must specify the minimum required alignment for 142 /// the object. 143 unsigned getConstantPoolIndex(const Constant *C, unsigned Alignment); 144 unsigned getConstantPoolIndex(MachineConstantPoolValue *V, 145 unsigned Alignment); 146 147 /// isEmpty - Return true if this constant pool contains no constants. isEmpty()148 bool isEmpty() const { return Constants.empty(); } 149 getConstants()150 const std::vector<MachineConstantPoolEntry> &getConstants() const { 151 return Constants; 152 } 153 154 /// print - Used by the MachineFunction printer to print information about 155 /// constant pool objects. Implemented in MachineFunction.cpp 156 /// 157 void print(raw_ostream &OS) const; 158 159 /// dump - Call print(cerr) to be called from the debugger. 160 void dump() const; 161 }; 162 163 } // End llvm namespace 164 165 #endif 166