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