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(LabelId);
64   ID.AddInteger(PCAdjust);
65   ID.AddInteger(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, 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 
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 
93 const GlobalValue *CSKYConstantPoolConstant::getGV() const {
94   assert(isa<GlobalValue>(CVal) && "CVal should be GlobalValue");
95   return cast<GlobalValue>(CVal);
96 }
97 
98 const BlockAddress *CSKYConstantPoolConstant::getBlockAddress() const {
99   assert(isa<BlockAddress>(CVal) && "CVal should be BlockAddress");
100   return cast<BlockAddress>(CVal);
101 }
102 
103 int CSKYConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP,
104                                                         Align Alignment) {
105   return getExistingMachineCPValueImpl<CSKYConstantPoolConstant>(CP, Alignment);
106 }
107 
108 void CSKYConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
109   ID.AddPointer(CVal);
110 
111   CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
112 }
113 
114 void CSKYConstantPoolConstant::print(raw_ostream &O) const {
115   O << CVal->getName();
116   CSKYConstantPoolValue::print(O);
117 }
118 
119 //===----------------------------------------------------------------------===//
120 // CSKYConstantPoolSymbol
121 //===----------------------------------------------------------------------===//
122 
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 *
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 
137 int CSKYConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP,
138                                                       Align Alignment) {
139 
140   return getExistingMachineCPValueImpl<CSKYConstantPoolSymbol>(CP, Alignment);
141 }
142 
143 void CSKYConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
144   ID.AddString(S);
145   CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
146 }
147 
148 void CSKYConstantPoolSymbol::print(raw_ostream &O) const {
149   O << S;
150   CSKYConstantPoolValue::print(O);
151 }
152 
153 //===----------------------------------------------------------------------===//
154 // CSKYConstantPoolMBB
155 //===----------------------------------------------------------------------===//
156 
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 
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 
171 int CSKYConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP,
172                                                    Align Alignment) {
173   return getExistingMachineCPValueImpl<CSKYConstantPoolMBB>(CP, Alignment);
174 }
175 
176 void CSKYConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
177   ID.AddPointer(MBB);
178   CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
179 }
180 
181 void CSKYConstantPoolMBB::print(raw_ostream &O) const {
182   O << "BB#" << MBB->getNumber();
183   CSKYConstantPoolValue::print(O);
184 }
185 
186 //===----------------------------------------------------------------------===//
187 // CSKYConstantPoolJT
188 //===----------------------------------------------------------------------===//
189 
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 *
198 CSKYConstantPoolJT::Create(Type *Ty, int JTI, unsigned PCAdj,
199                            CSKYCP::CSKYCPModifier Modifier) {
200   return new CSKYConstantPoolJT(Ty, JTI, PCAdj, Modifier, false);
201 }
202 
203 int CSKYConstantPoolJT::getExistingMachineCPValue(MachineConstantPool *CP,
204                                                   Align Alignment) {
205   return getExistingMachineCPValueImpl<CSKYConstantPoolJT>(CP, Alignment);
206 }
207 
208 void CSKYConstantPoolJT::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
209   ID.AddInteger(JTI);
210   CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
211 }
212 
213 void CSKYConstantPoolJT::print(raw_ostream &O) const {
214   O << "JTI#" << JTI;
215   CSKYConstantPoolValue::print(O);
216 }
217