Zi Xuan Wu | d2e91cf | 2022-01-06 17:21:49 +0800 | [diff] [blame] | 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( |
Zi Xuan Wu (Zeson) | 8c1248d | 2022-11-21 09:33:09 +0800 | [diff] [blame] | 80 | const Constant *C, Type *Ty, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust, |
Zi Xuan Wu | d2e91cf | 2022-01-06 17:21:49 +0800 | [diff] [blame] | 81 | CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID) |
Zi Xuan Wu (Zeson) | 8c1248d | 2022-11-21 09:33:09 +0800 | [diff] [blame] | 82 | : CSKYConstantPoolValue(Ty, Kind, PCAdjust, Modifier, AddCurrentAddress, |
| 83 | ID), |
Zi Xuan Wu | d2e91cf | 2022-01-06 17:21:49 +0800 | [diff] [blame] | 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) { |
Zi Xuan Wu (Zeson) | 8c1248d | 2022-11-21 09:33:09 +0800 | [diff] [blame] | 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, |
Zi Xuan Wu | d2e91cf | 2022-01-06 17:21:49 +0800 | [diff] [blame] | 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 | |
Zi Xuan Wu (Zeson) | 8c1248d | 2022-11-21 09:33:09 +0800 | [diff] [blame] | 110 | const Constant *CSKYConstantPoolConstant::getConstantPool() const { |
| 111 | return CVal; |
| 112 | } |
| 113 | |
Zi Xuan Wu | d2e91cf | 2022-01-06 17:21:49 +0800 | [diff] [blame] | 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); |
Kazu Hirata | 4f2f6ab | 2022-01-12 22:11:57 -0800 | [diff] [blame] | 227 | } |