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
CSKYConstantPoolValue(Type * Ty,CSKYCP::CSKYCPKind Kind,unsigned PCAdjust,CSKYCP::CSKYCPModifier Modifier,bool AddCurrentAddress,unsigned ID)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
getModifierText() const35 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
getExistingMachineCPValue(MachineConstantPool * CP,Align Alignment)57 int CSKYConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP,
58 Align Alignment) {
59 llvm_unreachable("Shouldn't be calling this directly!");
60 }
61
addSelectionDAGCSEId(FoldingSetNodeID & ID)62 void CSKYConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
63 ID.AddInteger(LabelId);
64 ID.AddInteger(PCAdjust);
65 ID.AddInteger(Modifier);
66 }
67
print(raw_ostream & O) const68 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
CSKYConstantPoolConstant(const Constant * C,CSKYCP::CSKYCPKind Kind,unsigned PCAdjust,CSKYCP::CSKYCPModifier Modifier,bool AddCurrentAddress,unsigned ID)79 CSKYConstantPoolConstant::CSKYConstantPoolConstant(
80 const Constant *C, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust,
81 CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID)
82 : CSKYConstantPoolValue(C->getType(), Kind, PCAdjust, Modifier,
83 AddCurrentAddress, ID),
84 CVal(C) {}
85
Create(const Constant * C,CSKYCP::CSKYCPKind Kind,unsigned PCAdjust,CSKYCP::CSKYCPModifier Modifier,bool AddCurrentAddress,unsigned ID)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, Kind, PCAdjust, Modifier,
90 AddCurrentAddress, ID);
91 }
92
getGV() const93 const GlobalValue *CSKYConstantPoolConstant::getGV() const {
94 assert(isa<GlobalValue>(CVal) && "CVal should be GlobalValue");
95 return cast<GlobalValue>(CVal);
96 }
97
getBlockAddress() const98 const BlockAddress *CSKYConstantPoolConstant::getBlockAddress() const {
99 assert(isa<BlockAddress>(CVal) && "CVal should be BlockAddress");
100 return cast<BlockAddress>(CVal);
101 }
102
getExistingMachineCPValue(MachineConstantPool * CP,Align Alignment)103 int CSKYConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP,
104 Align Alignment) {
105 return getExistingMachineCPValueImpl<CSKYConstantPoolConstant>(CP, Alignment);
106 }
107
addSelectionDAGCSEId(FoldingSetNodeID & ID)108 void CSKYConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
109 ID.AddPointer(CVal);
110
111 CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
112 }
113
print(raw_ostream & O) const114 void CSKYConstantPoolConstant::print(raw_ostream &O) const {
115 O << CVal->getName();
116 CSKYConstantPoolValue::print(O);
117 }
118
119 //===----------------------------------------------------------------------===//
120 // CSKYConstantPoolSymbol
121 //===----------------------------------------------------------------------===//
122
CSKYConstantPoolSymbol(Type * Ty,const char * S,unsigned PCAdjust,CSKYCP::CSKYCPModifier Modifier,bool AddCurrentAddress)123 CSKYConstantPoolSymbol::CSKYConstantPoolSymbol(Type *Ty, const char *S,
124 unsigned PCAdjust,
125 CSKYCP::CSKYCPModifier Modifier,
126 bool AddCurrentAddress)
127 : CSKYConstantPoolValue(Ty, CSKYCP::CPExtSymbol, PCAdjust, Modifier,
128 AddCurrentAddress),
129 S(strdup(S)) {}
130
131 CSKYConstantPoolSymbol *
Create(Type * Ty,const char * S,unsigned PCAdjust,CSKYCP::CSKYCPModifier Modifier)132 CSKYConstantPoolSymbol::Create(Type *Ty, const char *S, unsigned PCAdjust,
133 CSKYCP::CSKYCPModifier Modifier) {
134 return new CSKYConstantPoolSymbol(Ty, S, PCAdjust, Modifier, false);
135 }
136
getExistingMachineCPValue(MachineConstantPool * CP,Align Alignment)137 int CSKYConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP,
138 Align Alignment) {
139
140 return getExistingMachineCPValueImpl<CSKYConstantPoolSymbol>(CP, Alignment);
141 }
142
addSelectionDAGCSEId(FoldingSetNodeID & ID)143 void CSKYConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
144 ID.AddString(S);
145 CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
146 }
147
print(raw_ostream & O) const148 void CSKYConstantPoolSymbol::print(raw_ostream &O) const {
149 O << S;
150 CSKYConstantPoolValue::print(O);
151 }
152
153 //===----------------------------------------------------------------------===//
154 // CSKYConstantPoolMBB
155 //===----------------------------------------------------------------------===//
156
CSKYConstantPoolMBB(Type * Ty,const MachineBasicBlock * Mbb,unsigned PCAdjust,CSKYCP::CSKYCPModifier Modifier,bool AddCurrentAddress)157 CSKYConstantPoolMBB::CSKYConstantPoolMBB(Type *Ty, const MachineBasicBlock *Mbb,
158 unsigned PCAdjust,
159 CSKYCP::CSKYCPModifier Modifier,
160 bool AddCurrentAddress)
161 : CSKYConstantPoolValue(Ty, CSKYCP::CPMachineBasicBlock, PCAdjust, Modifier,
162 AddCurrentAddress),
163 MBB(Mbb) {}
164
Create(Type * Ty,const MachineBasicBlock * Mbb,unsigned PCAdjust)165 CSKYConstantPoolMBB *CSKYConstantPoolMBB::Create(Type *Ty,
166 const MachineBasicBlock *Mbb,
167 unsigned PCAdjust) {
168 return new CSKYConstantPoolMBB(Ty, Mbb, PCAdjust, CSKYCP::ADDR, false);
169 }
170
getExistingMachineCPValue(MachineConstantPool * CP,Align Alignment)171 int CSKYConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP,
172 Align Alignment) {
173 return getExistingMachineCPValueImpl<CSKYConstantPoolMBB>(CP, Alignment);
174 }
175
addSelectionDAGCSEId(FoldingSetNodeID & ID)176 void CSKYConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
177 ID.AddPointer(MBB);
178 CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
179 }
180
print(raw_ostream & O) const181 void CSKYConstantPoolMBB::print(raw_ostream &O) const {
182 O << "BB#" << MBB->getNumber();
183 CSKYConstantPoolValue::print(O);
184 }
185
186 //===----------------------------------------------------------------------===//
187 // CSKYConstantPoolJT
188 //===----------------------------------------------------------------------===//
189
CSKYConstantPoolJT(Type * Ty,int JTIndex,unsigned PCAdj,CSKYCP::CSKYCPModifier Modifier,bool AddCurrentAddress)190 CSKYConstantPoolJT::CSKYConstantPoolJT(Type *Ty, int JTIndex, unsigned PCAdj,
191 CSKYCP::CSKYCPModifier Modifier,
192 bool AddCurrentAddress)
193 : CSKYConstantPoolValue(Ty, CSKYCP::CPJT, PCAdj, Modifier,
194 AddCurrentAddress),
195 JTI(JTIndex) {}
196
197 CSKYConstantPoolJT *
Create(Type * Ty,int JTI,unsigned PCAdj,CSKYCP::CSKYCPModifier Modifier)198 CSKYConstantPoolJT::Create(Type *Ty, int JTI, unsigned PCAdj,
199 CSKYCP::CSKYCPModifier Modifier) {
200 return new CSKYConstantPoolJT(Ty, JTI, PCAdj, Modifier, false);
201 }
202
getExistingMachineCPValue(MachineConstantPool * CP,Align Alignment)203 int CSKYConstantPoolJT::getExistingMachineCPValue(MachineConstantPool *CP,
204 Align Alignment) {
205 return getExistingMachineCPValueImpl<CSKYConstantPoolJT>(CP, Alignment);
206 }
207
addSelectionDAGCSEId(FoldingSetNodeID & ID)208 void CSKYConstantPoolJT::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
209 ID.AddInteger(JTI);
210 CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
211 }
212
print(raw_ostream & O) const213 void CSKYConstantPoolJT::print(raw_ostream &O) const {
214 O << "JTI#" << JTI;
215 CSKYConstantPoolValue::print(O);
216 }
217