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"
21using namespace llvm;
22
23//===----------------------------------------------------------------------===//
24// CSKYConstantPoolValue
25//===----------------------------------------------------------------------===//
26
27CSKYConstantPoolValue::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
35const 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
57int CSKYConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP,
58                                                     Align Alignment) {
59  llvm_unreachable("Shouldn't be calling this directly!");
60}
61
62void CSKYConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
63  ID.AddInteger(LabelId);
64  ID.AddInteger(PCAdjust);
65  ID.AddInteger(Modifier);
66}
67
68void 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
79CSKYConstantPoolConstant::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
86CSKYConstantPoolConstant *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
93CSKYConstantPoolConstant *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
100const GlobalValue *CSKYConstantPoolConstant::getGV() const {
101  assert(isa<GlobalValue>(CVal) && "CVal should be GlobalValue");
102  return cast<GlobalValue>(CVal);
103}
104
105const BlockAddress *CSKYConstantPoolConstant::getBlockAddress() const {
106  assert(isa<BlockAddress>(CVal) && "CVal should be BlockAddress");
107  return cast<BlockAddress>(CVal);
108}
109
110const Constant *CSKYConstantPoolConstant::getConstantPool() const {
111  return CVal;
112}
113
114int CSKYConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP,
115                                                        Align Alignment) {
116  return getExistingMachineCPValueImpl<CSKYConstantPoolConstant>(CP, Alignment);
117}
118
119void CSKYConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
120  ID.AddPointer(CVal);
121
122  CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
123}
124
125void CSKYConstantPoolConstant::print(raw_ostream &O) const {
126  O << CVal->getName();
127  CSKYConstantPoolValue::print(O);
128}
129
130//===----------------------------------------------------------------------===//
131// CSKYConstantPoolSymbol
132//===----------------------------------------------------------------------===//
133
134CSKYConstantPoolSymbol::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)) {}
141
142CSKYConstantPoolSymbol *
143CSKYConstantPoolSymbol::Create(Type *Ty, const char *S, unsigned PCAdjust,
144                               CSKYCP::CSKYCPModifier Modifier) {
145  return new CSKYConstantPoolSymbol(Ty, S, PCAdjust, Modifier, false);
146}
147
148int CSKYConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP,
149                                                      Align Alignment) {
150
151  return getExistingMachineCPValueImpl<CSKYConstantPoolSymbol>(CP, Alignment);
152}
153
154void CSKYConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
155  ID.AddString(S);
156  CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
157}
158
159void CSKYConstantPoolSymbol::print(raw_ostream &O) const {
160  O << S;
161  CSKYConstantPoolValue::print(O);
162}
163
164//===----------------------------------------------------------------------===//
165// CSKYConstantPoolMBB
166//===----------------------------------------------------------------------===//
167
168CSKYConstantPoolMBB::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
176CSKYConstantPoolMBB *CSKYConstantPoolMBB::Create(Type *Ty,
177                                                 const MachineBasicBlock *Mbb,
178                                                 unsigned PCAdjust) {
179  return new CSKYConstantPoolMBB(Ty, Mbb, PCAdjust, CSKYCP::ADDR, false);
180}
181
182int CSKYConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP,
183                                                   Align Alignment) {
184  return getExistingMachineCPValueImpl<CSKYConstantPoolMBB>(CP, Alignment);
185}
186
187void CSKYConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
188  ID.AddPointer(MBB);
189  CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
190}
191
192void CSKYConstantPoolMBB::print(raw_ostream &O) const {
193  O << "BB#" << MBB->getNumber();
194  CSKYConstantPoolValue::print(O);
195}
196
197//===----------------------------------------------------------------------===//
198// CSKYConstantPoolJT
199//===----------------------------------------------------------------------===//
200
201CSKYConstantPoolJT::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
208CSKYConstantPoolJT *
209CSKYConstantPoolJT::Create(Type *Ty, int JTI, unsigned PCAdj,
210                           CSKYCP::CSKYCPModifier Modifier) {
211  return new CSKYConstantPoolJT(Ty, JTI, PCAdj, Modifier, false);
212}
213
214int CSKYConstantPoolJT::getExistingMachineCPValue(MachineConstantPool *CP,
215                                                  Align Alignment) {
216  return getExistingMachineCPValueImpl<CSKYConstantPoolJT>(CP, Alignment);
217}
218
219void CSKYConstantPoolJT::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
220  ID.AddInteger(JTI);
221  CSKYConstantPoolValue::addSelectionDAGCSEId(ID);
222}
223
224void CSKYConstantPoolJT::print(raw_ostream &O) const {
225  O << "JTI#" << JTI;
226  CSKYConstantPoolValue::print(O);
227}
228