1 //===- XtensaConstantPoolValue.cpp - Xtensa 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 Xtensa specific constantpool value class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "XtensaConstantPoolValue.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 #include <cstdlib> 22 using namespace llvm; 23 24 XtensaConstantPoolValue::XtensaConstantPoolValue( 25 Type *Ty, unsigned ID, XtensaCP::XtensaCPKind Kind, 26 XtensaCP::XtensaCPModifier modifier) 27 : MachineConstantPoolValue(Ty), LabelId(ID), Kind(Kind), 28 Modifier(modifier) {} 29 30 XtensaConstantPoolValue::XtensaConstantPoolValue( 31 LLVMContext &C, unsigned ID, XtensaCP::XtensaCPKind Kind, 32 XtensaCP::XtensaCPModifier Modifier) 33 : MachineConstantPoolValue((Type *)Type::getInt32Ty(C)), LabelId(ID), 34 Kind(Kind), Modifier(Modifier) {} 35 36 XtensaConstantPoolValue::~XtensaConstantPoolValue() {} 37 38 StringRef XtensaConstantPoolValue::getModifierText() const { 39 switch (Modifier) { 40 case XtensaCP::no_modifier: 41 return ""; 42 case XtensaCP::TPOFF: 43 return "@TPOFF"; 44 } 45 report_fatal_error("Unknown modifier!"); 46 } 47 48 int XtensaConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP, 49 Align Alignment) { 50 report_fatal_error("Shouldn't be calling this directly!"); 51 } 52 53 void XtensaConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) { 54 ID.AddInteger(LabelId); 55 } 56 57 bool XtensaConstantPoolValue::hasSameValue(XtensaConstantPoolValue *ACPV) { 58 if (ACPV->Kind == Kind) { 59 if (ACPV->LabelId == LabelId) 60 return true; 61 } 62 return false; 63 } 64 65 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 66 void XtensaConstantPoolValue::dump() const { errs() << " " << *this; } 67 #endif 68 69 void XtensaConstantPoolValue::print(raw_ostream &O) const {} 70 71 //===----------------------------------------------------------------------===// 72 // XtensaConstantPoolConstant 73 //===----------------------------------------------------------------------===// 74 75 XtensaConstantPoolConstant::XtensaConstantPoolConstant( 76 const Constant *C, unsigned ID, XtensaCP::XtensaCPKind Kind) 77 : XtensaConstantPoolValue(C->getType(), ID, Kind), CVal(C) {} 78 79 XtensaConstantPoolConstant * 80 XtensaConstantPoolConstant::Create(const Constant *C, unsigned ID, 81 XtensaCP::XtensaCPKind Kind) { 82 return new XtensaConstantPoolConstant(C, ID, Kind); 83 } 84 85 const BlockAddress *XtensaConstantPoolConstant::getBlockAddress() const { 86 return dyn_cast_or_null<BlockAddress>(CVal); 87 } 88 89 int XtensaConstantPoolConstant::getExistingMachineCPValue( 90 MachineConstantPool *CP, Align Alignment) { 91 return getExistingMachineCPValueImpl<XtensaConstantPoolConstant>(CP, 92 Alignment); 93 } 94 95 bool XtensaConstantPoolConstant::hasSameValue(XtensaConstantPoolValue *ACPV) { 96 const XtensaConstantPoolConstant *ACPC = 97 dyn_cast<XtensaConstantPoolConstant>(ACPV); 98 return ACPC && ACPC->CVal == CVal && 99 XtensaConstantPoolValue::hasSameValue(ACPV); 100 } 101 102 void XtensaConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) { 103 ID.AddPointer(CVal); 104 XtensaConstantPoolValue::addSelectionDAGCSEId(ID); 105 } 106 107 void XtensaConstantPoolConstant::print(raw_ostream &O) const { 108 O << CVal->getName(); 109 XtensaConstantPoolValue::print(O); 110 } 111 112 XtensaConstantPoolSymbol::XtensaConstantPoolSymbol( 113 LLVMContext &C, const char *Str, unsigned ID, bool PrivLinkage, 114 XtensaCP::XtensaCPModifier Modifier) 115 : XtensaConstantPoolValue(C, ID, XtensaCP::CPExtSymbol, Modifier), S(Str), 116 PrivateLinkage(PrivLinkage) {} 117 118 XtensaConstantPoolSymbol * 119 XtensaConstantPoolSymbol::Create(LLVMContext &C, const char *Str, unsigned ID, 120 bool PrivLinkage, 121 XtensaCP::XtensaCPModifier Modifier) 122 123 { 124 return new XtensaConstantPoolSymbol(C, Str, ID, PrivLinkage, Modifier); 125 } 126 127 int XtensaConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP, 128 Align Alignment) { 129 return getExistingMachineCPValueImpl<XtensaConstantPoolSymbol>(CP, Alignment); 130 } 131 132 bool XtensaConstantPoolSymbol::hasSameValue(XtensaConstantPoolValue *ACPV) { 133 const XtensaConstantPoolSymbol *ACPS = 134 dyn_cast<XtensaConstantPoolSymbol>(ACPV); 135 return ACPS && ACPS->S == S && XtensaConstantPoolValue::hasSameValue(ACPV); 136 } 137 138 void XtensaConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) { 139 ID.AddString(S); 140 XtensaConstantPoolValue::addSelectionDAGCSEId(ID); 141 } 142 143 void XtensaConstantPoolSymbol::print(raw_ostream &O) const { 144 O << S; 145 XtensaConstantPoolValue::print(O); 146 } 147 148 XtensaConstantPoolMBB::XtensaConstantPoolMBB(LLVMContext &C, 149 const MachineBasicBlock *M, 150 unsigned Id) 151 : XtensaConstantPoolValue(C, 0, XtensaCP::CPMachineBasicBlock), MBB(M) {} 152 153 XtensaConstantPoolMBB *XtensaConstantPoolMBB::Create(LLVMContext &C, 154 const MachineBasicBlock *M, 155 unsigned Idx) { 156 return new XtensaConstantPoolMBB(C, M, Idx); 157 } 158 159 int XtensaConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP, 160 Align Alignment) { 161 return getExistingMachineCPValueImpl<XtensaConstantPoolMBB>(CP, Alignment); 162 } 163 164 bool XtensaConstantPoolMBB::hasSameValue(XtensaConstantPoolValue *ACPV) { 165 const XtensaConstantPoolMBB *ACPMBB = dyn_cast<XtensaConstantPoolMBB>(ACPV); 166 return ACPMBB && ACPMBB->MBB == MBB && 167 XtensaConstantPoolValue::hasSameValue(ACPV); 168 } 169 170 void XtensaConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) { 171 ID.AddPointer(MBB); 172 XtensaConstantPoolValue::addSelectionDAGCSEId(ID); 173 } 174 175 void XtensaConstantPoolMBB::print(raw_ostream &O) const { 176 O << "BB#" << MBB->getNumber(); 177 XtensaConstantPoolValue::print(O); 178 } 179 180 XtensaConstantPoolJumpTable::XtensaConstantPoolJumpTable(LLVMContext &C, 181 unsigned Index) 182 : XtensaConstantPoolValue(C, 0, XtensaCP::CPJumpTable), Idx(Index) {} 183 184 XtensaConstantPoolJumpTable *XtensaConstantPoolJumpTable::Create(LLVMContext &C, 185 unsigned Idx) { 186 return new XtensaConstantPoolJumpTable(C, Idx); 187 } 188 189 int XtensaConstantPoolJumpTable::getExistingMachineCPValue( 190 MachineConstantPool *CP, Align Alignment) { 191 return getExistingMachineCPValueImpl<XtensaConstantPoolJumpTable>(CP, 192 Alignment); 193 } 194 195 bool XtensaConstantPoolJumpTable::hasSameValue(XtensaConstantPoolValue *ACPV) { 196 const XtensaConstantPoolJumpTable *ACPJT = 197 dyn_cast<XtensaConstantPoolJumpTable>(ACPV); 198 return ACPJT && ACPJT->Idx == Idx && 199 XtensaConstantPoolValue::hasSameValue(ACPV); 200 } 201 202 void XtensaConstantPoolJumpTable::addSelectionDAGCSEId(FoldingSetNodeID &ID) {} 203 204 void XtensaConstantPoolJumpTable::print(raw_ostream &O) const { 205 O << "JT" << Idx; 206 XtensaConstantPoolValue::print(O); 207 } 208