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