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, 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>(CVal); 103 } 104 105 const BlockAddress *CSKYConstantPoolConstant::getBlockAddress() const { 106 assert(isa<BlockAddress>(CVal) && "CVal should be BlockAddress"); 107 return cast<BlockAddress>(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(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)) {} 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(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(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(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