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