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
24namespace llvm {
25
26class Constant;
27class DataLayout;
28class FoldingSetNodeID;
29class MachineConstantPool;
30class raw_ostream;
31class Type;
32
33/// Abstract base class for all machine specific constantpool value subclasses.
34///
35class MachineConstantPoolValue {
36 virtual void anchor();
37
38 Type *Ty;
39
40public:
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
57inline raw_ostream &operator<<(raw_ostream &OS,
58 const MachineConstantPoolValue &V) {
59 V.print(O&: 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
67class MachineConstantPoolEntry {
68public:
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.
117class 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
126public:
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

source code of llvm/include/llvm/CodeGen/MachineConstantPool.h