1 | //===-- CSKYConstantPoolValue.cpp - CSKY constantpool value ---------------===// |
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 | // This file implements the CSKY specific constantpool value class. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "CSKYConstantPoolValue.h" |
14 | #include "llvm/ADT/FoldingSet.h" |
15 | #include "llvm/CodeGen/MachineBasicBlock.h" |
16 | #include "llvm/IR/Constant.h" |
17 | #include "llvm/IR/Constants.h" |
18 | #include "llvm/IR/GlobalValue.h" |
19 | #include "llvm/IR/Type.h" |
20 | #include "llvm/Support/raw_ostream.h" |
21 | using namespace llvm; |
22 | |
23 | //===----------------------------------------------------------------------===// |
24 | // CSKYConstantPoolValue |
25 | //===----------------------------------------------------------------------===// |
26 | |
27 | CSKYConstantPoolValue::CSKYConstantPoolValue(Type *Ty, CSKYCP::CSKYCPKind Kind, |
28 | unsigned PCAdjust, |
29 | CSKYCP::CSKYCPModifier Modifier, |
30 | bool AddCurrentAddress, |
31 | unsigned ID) |
32 | : MachineConstantPoolValue(Ty), Kind(Kind), PCAdjust(PCAdjust), |
33 | Modifier(Modifier), AddCurrentAddress(AddCurrentAddress), LabelId(ID) {} |
34 | |
35 | const char *CSKYConstantPoolValue::getModifierText() const { |
36 | switch (Modifier) { |
37 | case CSKYCP::ADDR: |
38 | return "ADDR" ; |
39 | case CSKYCP::GOT: |
40 | return "GOT" ; |
41 | case CSKYCP::GOTOFF: |
42 | return "GOTOFF" ; |
43 | case CSKYCP::PLT: |
44 | return "PLT" ; |
45 | case CSKYCP::TLSIE: |
46 | return "TLSIE" ; |
47 | case CSKYCP::TLSLE: |
48 | return "TLSLE" ; |
49 | case CSKYCP::TLSGD: |
50 | return "TLSGD" ; |
51 | case CSKYCP::NO_MOD: |
52 | return "" ; |
53 | } |
54 | llvm_unreachable("Unknown modifier!" ); |
55 | } |
56 | |
57 | int CSKYConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP, |
58 | Align Alignment) { |
59 | llvm_unreachable("Shouldn't be calling this directly!" ); |
60 | } |
61 | |
62 | void CSKYConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
63 | ID.AddInteger(I: LabelId); |
64 | ID.AddInteger(I: PCAdjust); |
65 | ID.AddInteger(I: Modifier); |
66 | } |
67 | |
68 | void CSKYConstantPoolValue::print(raw_ostream &O) const { |
69 | if (Modifier) |
70 | O << "(" << getModifierText() << ")" ; |
71 | if (PCAdjust) |
72 | O << " + " << PCAdjust; |
73 | } |
74 | |
75 | //===----------------------------------------------------------------------===// |
76 | // CSKYConstantPoolConstant |
77 | //===----------------------------------------------------------------------===// |
78 | |
79 | CSKYConstantPoolConstant::CSKYConstantPoolConstant( |
80 | const Constant *C, Type *Ty, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust, |
81 | CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID) |
82 | : CSKYConstantPoolValue(Ty, Kind, PCAdjust, Modifier, AddCurrentAddress, |
83 | ID), |
84 | CVal(C) {} |
85 | |
86 | CSKYConstantPoolConstant *CSKYConstantPoolConstant::Create( |
87 | const Constant *C, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust, |
88 | CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID) { |
89 | return new CSKYConstantPoolConstant(C, C->getType(), Kind, PCAdjust, Modifier, |
90 | AddCurrentAddress, ID); |
91 | } |
92 | |
93 | CSKYConstantPoolConstant *CSKYConstantPoolConstant::Create( |
94 | const Constant *C, Type *Ty, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust, |
95 | CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID) { |
96 | return new CSKYConstantPoolConstant(C, Ty, Kind, PCAdjust, Modifier, |
97 | AddCurrentAddress, ID); |
98 | } |
99 | |
100 | const GlobalValue *CSKYConstantPoolConstant::getGV() const { |
101 | assert(isa<GlobalValue>(CVal) && "CVal should be GlobalValue" ); |
102 | return cast<GlobalValue>(Val: CVal); |
103 | } |
104 | |
105 | const BlockAddress *CSKYConstantPoolConstant::getBlockAddress() const { |
106 | assert(isa<BlockAddress>(CVal) && "CVal should be BlockAddress" ); |
107 | return cast<BlockAddress>(Val: CVal); |
108 | } |
109 | |
110 | const Constant *CSKYConstantPoolConstant::getConstantPool() const { |
111 | return CVal; |
112 | } |
113 | |
114 | int CSKYConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP, |
115 | Align Alignment) { |
116 | return getExistingMachineCPValueImpl<CSKYConstantPoolConstant>(CP, Alignment); |
117 | } |
118 | |
119 | void CSKYConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
120 | ID.AddPointer(Ptr: CVal); |
121 | |
122 | CSKYConstantPoolValue::addSelectionDAGCSEId(ID); |
123 | } |
124 | |
125 | void CSKYConstantPoolConstant::print(raw_ostream &O) const { |
126 | O << CVal->getName(); |
127 | CSKYConstantPoolValue::print(O); |
128 | } |
129 | |
130 | //===----------------------------------------------------------------------===// |
131 | // CSKYConstantPoolSymbol |
132 | //===----------------------------------------------------------------------===// |
133 | |
134 | CSKYConstantPoolSymbol::CSKYConstantPoolSymbol(Type *Ty, const char *S, |
135 | unsigned PCAdjust, |
136 | CSKYCP::CSKYCPModifier Modifier, |
137 | bool AddCurrentAddress) |
138 | : CSKYConstantPoolValue(Ty, CSKYCP::CPExtSymbol, PCAdjust, Modifier, |
139 | AddCurrentAddress), |
140 | S(strdup(s: S)) {} |
141 | |
142 | CSKYConstantPoolSymbol * |
143 | CSKYConstantPoolSymbol::Create(Type *Ty, const char *S, unsigned PCAdjust, |
144 | CSKYCP::CSKYCPModifier Modifier) { |
145 | return new CSKYConstantPoolSymbol(Ty, S, PCAdjust, Modifier, false); |
146 | } |
147 | |
148 | int CSKYConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP, |
149 | Align Alignment) { |
150 | |
151 | return getExistingMachineCPValueImpl<CSKYConstantPoolSymbol>(CP, Alignment); |
152 | } |
153 | |
154 | void CSKYConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
155 | ID.AddString(String: S); |
156 | CSKYConstantPoolValue::addSelectionDAGCSEId(ID); |
157 | } |
158 | |
159 | void CSKYConstantPoolSymbol::print(raw_ostream &O) const { |
160 | O << S; |
161 | CSKYConstantPoolValue::print(O); |
162 | } |
163 | |
164 | //===----------------------------------------------------------------------===// |
165 | // CSKYConstantPoolMBB |
166 | //===----------------------------------------------------------------------===// |
167 | |
168 | CSKYConstantPoolMBB::CSKYConstantPoolMBB(Type *Ty, const MachineBasicBlock *Mbb, |
169 | unsigned PCAdjust, |
170 | CSKYCP::CSKYCPModifier Modifier, |
171 | bool AddCurrentAddress) |
172 | : CSKYConstantPoolValue(Ty, CSKYCP::CPMachineBasicBlock, PCAdjust, Modifier, |
173 | AddCurrentAddress), |
174 | MBB(Mbb) {} |
175 | |
176 | CSKYConstantPoolMBB *CSKYConstantPoolMBB::Create(Type *Ty, |
177 | const MachineBasicBlock *Mbb, |
178 | unsigned PCAdjust) { |
179 | return new CSKYConstantPoolMBB(Ty, Mbb, PCAdjust, CSKYCP::ADDR, false); |
180 | } |
181 | |
182 | int CSKYConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP, |
183 | Align Alignment) { |
184 | return getExistingMachineCPValueImpl<CSKYConstantPoolMBB>(CP, Alignment); |
185 | } |
186 | |
187 | void CSKYConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
188 | ID.AddPointer(Ptr: MBB); |
189 | CSKYConstantPoolValue::addSelectionDAGCSEId(ID); |
190 | } |
191 | |
192 | void CSKYConstantPoolMBB::print(raw_ostream &O) const { |
193 | O << "BB#" << MBB->getNumber(); |
194 | CSKYConstantPoolValue::print(O); |
195 | } |
196 | |
197 | //===----------------------------------------------------------------------===// |
198 | // CSKYConstantPoolJT |
199 | //===----------------------------------------------------------------------===// |
200 | |
201 | CSKYConstantPoolJT::CSKYConstantPoolJT(Type *Ty, int JTIndex, unsigned PCAdj, |
202 | CSKYCP::CSKYCPModifier Modifier, |
203 | bool AddCurrentAddress) |
204 | : CSKYConstantPoolValue(Ty, CSKYCP::CPJT, PCAdj, Modifier, |
205 | AddCurrentAddress), |
206 | JTI(JTIndex) {} |
207 | |
208 | CSKYConstantPoolJT * |
209 | CSKYConstantPoolJT::Create(Type *Ty, int JTI, unsigned PCAdj, |
210 | CSKYCP::CSKYCPModifier Modifier) { |
211 | return new CSKYConstantPoolJT(Ty, JTI, PCAdj, Modifier, false); |
212 | } |
213 | |
214 | int CSKYConstantPoolJT::getExistingMachineCPValue(MachineConstantPool *CP, |
215 | Align Alignment) { |
216 | return getExistingMachineCPValueImpl<CSKYConstantPoolJT>(CP, Alignment); |
217 | } |
218 | |
219 | void CSKYConstantPoolJT::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
220 | ID.AddInteger(I: JTI); |
221 | CSKYConstantPoolValue::addSelectionDAGCSEId(ID); |
222 | } |
223 | |
224 | void CSKYConstantPoolJT::print(raw_ostream &O) const { |
225 | O << "JTI#" << JTI; |
226 | CSKYConstantPoolValue::print(O); |
227 | } |
228 | |