| //===- ARMConstantPoolValue.cpp - ARM constantpool value ------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the ARM specific constantpool value class. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "ARMConstantPoolValue.h" |
| #include "llvm/ADT/FoldingSet.h" |
| #include "llvm/CodeGen/MachineBasicBlock.h" |
| #include "llvm/Config/llvm-config.h" |
| #include "llvm/IR/Constant.h" |
| #include "llvm/IR/Constants.h" |
| #include "llvm/IR/GlobalValue.h" |
| #include "llvm/IR/GlobalVariable.h" |
| #include "llvm/IR/Type.h" |
| #include "llvm/Support/Casting.h" |
| #include "llvm/Support/Compiler.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| using namespace llvm; |
| |
| //===----------------------------------------------------------------------===// |
| // ARMConstantPoolValue |
| //===----------------------------------------------------------------------===// |
| |
| ARMConstantPoolValue::ARMConstantPoolValue(Type *Ty, unsigned id, |
| ARMCP::ARMCPKind kind, |
| unsigned char PCAdj, |
| ARMCP::ARMCPModifier modifier, |
| bool addCurrentAddress) |
| : MachineConstantPoolValue(Ty), LabelId(id), Kind(kind), |
| PCAdjust(PCAdj), Modifier(modifier), |
| AddCurrentAddress(addCurrentAddress) {} |
| |
| ARMConstantPoolValue::ARMConstantPoolValue(LLVMContext &C, unsigned id, |
| ARMCP::ARMCPKind kind, |
| unsigned char PCAdj, |
| ARMCP::ARMCPModifier modifier, |
| bool addCurrentAddress) |
| : MachineConstantPoolValue((Type*)Type::getInt32Ty(C)), |
| LabelId(id), Kind(kind), PCAdjust(PCAdj), Modifier(modifier), |
| AddCurrentAddress(addCurrentAddress) {} |
| |
| ARMConstantPoolValue::~ARMConstantPoolValue() = default; |
| |
| StringRef ARMConstantPoolValue::getModifierText() const { |
| switch (Modifier) { |
| // FIXME: Are these case sensitive? It'd be nice to lower-case all the |
| // strings if that's legal. |
| case ARMCP::no_modifier: |
| return "none"; |
| case ARMCP::TLSGD: |
| return "tlsgd"; |
| case ARMCP::GOT_PREL: |
| return "GOT_PREL"; |
| case ARMCP::GOTTPOFF: |
| return "gottpoff"; |
| case ARMCP::TPOFF: |
| return "tpoff"; |
| case ARMCP::SBREL: |
| return "SBREL"; |
| case ARMCP::SECREL: |
| return "secrel32"; |
| } |
| llvm_unreachable("Unknown modifier!"); |
| } |
| |
| int ARMConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP, |
| Align Alignment) { |
| llvm_unreachable("Shouldn't be calling this directly!"); |
| } |
| |
| void |
| ARMConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
| ID.AddInteger(LabelId); |
| ID.AddInteger(PCAdjust); |
| } |
| |
| bool |
| ARMConstantPoolValue::hasSameValue(ARMConstantPoolValue *ACPV) { |
| if (ACPV->Kind == Kind && |
| ACPV->PCAdjust == PCAdjust && |
| ACPV->Modifier == Modifier && |
| ACPV->LabelId == LabelId && |
| ACPV->AddCurrentAddress == AddCurrentAddress) { |
| // Two PC relative constpool entries containing the same GV address or |
| // external symbols. FIXME: What about blockaddress? |
| if (Kind == ARMCP::CPValue || Kind == ARMCP::CPExtSymbol) |
| return true; |
| } |
| return false; |
| } |
| |
| #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
| LLVM_DUMP_METHOD void ARMConstantPoolValue::dump() const { |
| errs() << " " << *this; |
| } |
| #endif |
| |
| void ARMConstantPoolValue::print(raw_ostream &O) const { |
| if (Modifier) O << "(" << getModifierText() << ")"; |
| if (PCAdjust != 0) { |
| O << "-(LPC" << LabelId << "+" << (unsigned)PCAdjust; |
| if (AddCurrentAddress) O << "-."; |
| O << ")"; |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // ARMConstantPoolConstant |
| //===----------------------------------------------------------------------===// |
| |
| ARMConstantPoolConstant::ARMConstantPoolConstant(Type *Ty, |
| const Constant *C, |
| unsigned ID, |
| ARMCP::ARMCPKind Kind, |
| unsigned char PCAdj, |
| ARMCP::ARMCPModifier Modifier, |
| bool AddCurrentAddress) |
| : ARMConstantPoolValue(Ty, ID, Kind, PCAdj, Modifier, AddCurrentAddress), |
| CVal(C) {} |
| |
| ARMConstantPoolConstant::ARMConstantPoolConstant(const Constant *C, |
| unsigned ID, |
| ARMCP::ARMCPKind Kind, |
| unsigned char PCAdj, |
| ARMCP::ARMCPModifier Modifier, |
| bool AddCurrentAddress) |
| : ARMConstantPoolValue((Type*)C->getType(), ID, Kind, PCAdj, Modifier, |
| AddCurrentAddress), |
| CVal(C) {} |
| |
| ARMConstantPoolConstant::ARMConstantPoolConstant(const GlobalVariable *GV, |
| const Constant *C) |
| : ARMConstantPoolValue((Type *)C->getType(), 0, ARMCP::CPPromotedGlobal, 0, |
| ARMCP::no_modifier, false), CVal(C) { |
| GVars.insert(GV); |
| } |
| |
| ARMConstantPoolConstant * |
| ARMConstantPoolConstant::Create(const Constant *C, unsigned ID) { |
| return new ARMConstantPoolConstant(C, ID, ARMCP::CPValue, 0, |
| ARMCP::no_modifier, false); |
| } |
| |
| ARMConstantPoolConstant * |
| ARMConstantPoolConstant::Create(const GlobalVariable *GVar, |
| const Constant *Initializer) { |
| return new ARMConstantPoolConstant(GVar, Initializer); |
| } |
| |
| ARMConstantPoolConstant * |
| ARMConstantPoolConstant::Create(const GlobalValue *GV, |
| ARMCP::ARMCPModifier Modifier) { |
| return new ARMConstantPoolConstant((Type*)Type::getInt32Ty(GV->getContext()), |
| GV, 0, ARMCP::CPValue, 0, |
| Modifier, false); |
| } |
| |
| ARMConstantPoolConstant * |
| ARMConstantPoolConstant::Create(const Constant *C, unsigned ID, |
| ARMCP::ARMCPKind Kind, unsigned char PCAdj) { |
| return new ARMConstantPoolConstant(C, ID, Kind, PCAdj, |
| ARMCP::no_modifier, false); |
| } |
| |
| ARMConstantPoolConstant * |
| ARMConstantPoolConstant::Create(const Constant *C, unsigned ID, |
| ARMCP::ARMCPKind Kind, unsigned char PCAdj, |
| ARMCP::ARMCPModifier Modifier, |
| bool AddCurrentAddress) { |
| return new ARMConstantPoolConstant(C, ID, Kind, PCAdj, Modifier, |
| AddCurrentAddress); |
| } |
| |
| const GlobalValue *ARMConstantPoolConstant::getGV() const { |
| return dyn_cast_or_null<GlobalValue>(CVal); |
| } |
| |
| const BlockAddress *ARMConstantPoolConstant::getBlockAddress() const { |
| return dyn_cast_or_null<BlockAddress>(CVal); |
| } |
| |
| int ARMConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP, |
| Align Alignment) { |
| int index = |
| getExistingMachineCPValueImpl<ARMConstantPoolConstant>(CP, Alignment); |
| if (index != -1) { |
| auto *CPV = static_cast<ARMConstantPoolValue*>( |
| CP->getConstants()[index].Val.MachineCPVal); |
| auto *Constant = cast<ARMConstantPoolConstant>(CPV); |
| Constant->GVars.insert(GVars.begin(), GVars.end()); |
| } |
| return index; |
| } |
| |
| bool ARMConstantPoolConstant::hasSameValue(ARMConstantPoolValue *ACPV) { |
| const ARMConstantPoolConstant *ACPC = dyn_cast<ARMConstantPoolConstant>(ACPV); |
| return ACPC && ACPC->CVal == CVal && ARMConstantPoolValue::hasSameValue(ACPV); |
| } |
| |
| void ARMConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
| ID.AddPointer(CVal); |
| for (const auto *GV : GVars) |
| ID.AddPointer(GV); |
| ARMConstantPoolValue::addSelectionDAGCSEId(ID); |
| } |
| |
| void ARMConstantPoolConstant::print(raw_ostream &O) const { |
| O << CVal->getName(); |
| ARMConstantPoolValue::print(O); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // ARMConstantPoolSymbol |
| //===----------------------------------------------------------------------===// |
| |
| ARMConstantPoolSymbol::ARMConstantPoolSymbol(LLVMContext &C, StringRef s, |
| unsigned id, unsigned char PCAdj, |
| ARMCP::ARMCPModifier Modifier, |
| bool AddCurrentAddress) |
| : ARMConstantPoolValue(C, id, ARMCP::CPExtSymbol, PCAdj, Modifier, |
| AddCurrentAddress), |
| S(std::string(s)) {} |
| |
| ARMConstantPoolSymbol *ARMConstantPoolSymbol::Create(LLVMContext &C, |
| StringRef s, unsigned ID, |
| unsigned char PCAdj) { |
| return new ARMConstantPoolSymbol(C, s, ID, PCAdj, ARMCP::no_modifier, false); |
| } |
| |
| int ARMConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP, |
| Align Alignment) { |
| return getExistingMachineCPValueImpl<ARMConstantPoolSymbol>(CP, Alignment); |
| } |
| |
| bool ARMConstantPoolSymbol::hasSameValue(ARMConstantPoolValue *ACPV) { |
| const ARMConstantPoolSymbol *ACPS = dyn_cast<ARMConstantPoolSymbol>(ACPV); |
| return ACPS && ACPS->S == S && ARMConstantPoolValue::hasSameValue(ACPV); |
| } |
| |
| void ARMConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
| ID.AddString(S); |
| ARMConstantPoolValue::addSelectionDAGCSEId(ID); |
| } |
| |
| void ARMConstantPoolSymbol::print(raw_ostream &O) const { |
| O << S; |
| ARMConstantPoolValue::print(O); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // ARMConstantPoolMBB |
| //===----------------------------------------------------------------------===// |
| |
| ARMConstantPoolMBB::ARMConstantPoolMBB(LLVMContext &C, |
| const MachineBasicBlock *mbb, |
| unsigned id, unsigned char PCAdj, |
| ARMCP::ARMCPModifier Modifier, |
| bool AddCurrentAddress) |
| : ARMConstantPoolValue(C, id, ARMCP::CPMachineBasicBlock, PCAdj, |
| Modifier, AddCurrentAddress), |
| MBB(mbb) {} |
| |
| ARMConstantPoolMBB *ARMConstantPoolMBB::Create(LLVMContext &C, |
| const MachineBasicBlock *mbb, |
| unsigned ID, |
| unsigned char PCAdj) { |
| return new ARMConstantPoolMBB(C, mbb, ID, PCAdj, ARMCP::no_modifier, false); |
| } |
| |
| int ARMConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP, |
| Align Alignment) { |
| return getExistingMachineCPValueImpl<ARMConstantPoolMBB>(CP, Alignment); |
| } |
| |
| bool ARMConstantPoolMBB::hasSameValue(ARMConstantPoolValue *ACPV) { |
| const ARMConstantPoolMBB *ACPMBB = dyn_cast<ARMConstantPoolMBB>(ACPV); |
| return ACPMBB && ACPMBB->MBB == MBB && |
| ARMConstantPoolValue::hasSameValue(ACPV); |
| } |
| |
| void ARMConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) { |
| ID.AddPointer(MBB); |
| ARMConstantPoolValue::addSelectionDAGCSEId(ID); |
| } |
| |
| void ARMConstantPoolMBB::print(raw_ostream &O) const { |
| O << printMBBReference(*MBB); |
| ARMConstantPoolValue::print(O); |
| } |