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