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:
41   explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
42   virtual ~MachineConstantPoolValue() = default;
43 
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 
80   MachineConstantPoolEntry(const Constant *V, Align A)
81       : Alignment(A), IsMachineConstantPoolEntry(false) {
82     Val.ConstVal = V;
83   }
84 
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.
93   bool isMachineConstantPoolEntry() const { return IsMachineConstantPoolEntry; }
94 
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 
124   const DataLayout &getDataLayout() const { return DL; }
125 
126 public:
127   /// The only constructor.
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.
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.
143   bool isEmpty() const { return Constants.empty(); }
144 
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