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