//===- XtensaConstantPoolValue.cpp - Xtensa 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 Xtensa specific constantpool value class.
//
//===----------------------------------------------------------------------===//

#include "XtensaConstantPoolValue.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Type.h"
#include "llvm/Support/raw_ostream.h"
#include <cstdlib>
using namespace llvm;

XtensaConstantPoolValue::XtensaConstantPoolValue(
    Type *Ty, unsigned ID, XtensaCP::XtensaCPKind Kind,
    XtensaCP::XtensaCPModifier modifier)
    : MachineConstantPoolValue(Ty), LabelId(ID), Kind(Kind),
      Modifier(modifier) {}

XtensaConstantPoolValue::XtensaConstantPoolValue(
    LLVMContext &C, unsigned ID, XtensaCP::XtensaCPKind Kind,
    XtensaCP::XtensaCPModifier Modifier)
    : MachineConstantPoolValue((Type *)Type::getInt32Ty(C)), LabelId(ID),
      Kind(Kind), Modifier(Modifier) {}

XtensaConstantPoolValue::~XtensaConstantPoolValue() {}

StringRef XtensaConstantPoolValue::getModifierText() const {
  switch (Modifier) {
  case XtensaCP::no_modifier:
    return "";
  case XtensaCP::TPOFF:
    return "@TPOFF";
  }
  report_fatal_error("Unknown modifier!");
}

int XtensaConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP,
                                                       Align Alignment) {
  report_fatal_error("Shouldn't be calling this directly!");
}

void XtensaConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
  ID.AddInteger(LabelId);
}

bool XtensaConstantPoolValue::hasSameValue(XtensaConstantPoolValue *ACPV) {
  if (ACPV->Kind == Kind) {
    if (ACPV->LabelId == LabelId)
      return true;
  }
  return false;
}

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void XtensaConstantPoolValue::dump() const { errs() << "  " << *this; }
#endif

void XtensaConstantPoolValue::print(raw_ostream &O) const {}

//===----------------------------------------------------------------------===//
// XtensaConstantPoolConstant
//===----------------------------------------------------------------------===//

XtensaConstantPoolConstant::XtensaConstantPoolConstant(
    const Constant *C, unsigned ID, XtensaCP::XtensaCPKind Kind)
    : XtensaConstantPoolValue(C->getType(), ID, Kind), CVal(C) {}

XtensaConstantPoolConstant *
XtensaConstantPoolConstant::Create(const Constant *C, unsigned ID,
                                   XtensaCP::XtensaCPKind Kind) {
  return new XtensaConstantPoolConstant(C, ID, Kind);
}

const BlockAddress *XtensaConstantPoolConstant::getBlockAddress() const {
  return dyn_cast_or_null<BlockAddress>(CVal);
}

int XtensaConstantPoolConstant::getExistingMachineCPValue(
    MachineConstantPool *CP, Align Alignment) {
  return getExistingMachineCPValueImpl<XtensaConstantPoolConstant>(CP,
                                                                   Alignment);
}

bool XtensaConstantPoolConstant::hasSameValue(XtensaConstantPoolValue *ACPV) {
  const XtensaConstantPoolConstant *ACPC =
      dyn_cast<XtensaConstantPoolConstant>(ACPV);
  return ACPC && ACPC->CVal == CVal &&
         XtensaConstantPoolValue::hasSameValue(ACPV);
}

void XtensaConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
  ID.AddPointer(CVal);
  XtensaConstantPoolValue::addSelectionDAGCSEId(ID);
}

void XtensaConstantPoolConstant::print(raw_ostream &O) const {
  O << CVal->getName();
  XtensaConstantPoolValue::print(O);
}

XtensaConstantPoolSymbol::XtensaConstantPoolSymbol(
    LLVMContext &C, const char *Str, unsigned ID, bool PrivLinkage,
    XtensaCP::XtensaCPModifier Modifier)
    : XtensaConstantPoolValue(C, ID, XtensaCP::CPExtSymbol, Modifier), S(Str),
      PrivateLinkage(PrivLinkage) {}

XtensaConstantPoolSymbol *
XtensaConstantPoolSymbol::Create(LLVMContext &C, const char *Str, unsigned ID,
                                 bool PrivLinkage,
                                 XtensaCP::XtensaCPModifier Modifier)

{
  return new XtensaConstantPoolSymbol(C, Str, ID, PrivLinkage, Modifier);
}

int XtensaConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP,
                                                        Align Alignment) {
  return getExistingMachineCPValueImpl<XtensaConstantPoolSymbol>(CP, Alignment);
}

bool XtensaConstantPoolSymbol::hasSameValue(XtensaConstantPoolValue *ACPV) {
  const XtensaConstantPoolSymbol *ACPS =
      dyn_cast<XtensaConstantPoolSymbol>(ACPV);
  return ACPS && ACPS->S == S && XtensaConstantPoolValue::hasSameValue(ACPV);
}

void XtensaConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
  ID.AddString(S);
  XtensaConstantPoolValue::addSelectionDAGCSEId(ID);
}

void XtensaConstantPoolSymbol::print(raw_ostream &O) const {
  O << S;
  XtensaConstantPoolValue::print(O);
}

XtensaConstantPoolMBB::XtensaConstantPoolMBB(LLVMContext &C,
                                             const MachineBasicBlock *M,
                                             unsigned Id)
    : XtensaConstantPoolValue(C, 0, XtensaCP::CPMachineBasicBlock), MBB(M) {}

XtensaConstantPoolMBB *XtensaConstantPoolMBB::Create(LLVMContext &C,
                                                     const MachineBasicBlock *M,
                                                     unsigned Idx) {
  return new XtensaConstantPoolMBB(C, M, Idx);
}

int XtensaConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP,
                                                     Align Alignment) {
  return getExistingMachineCPValueImpl<XtensaConstantPoolMBB>(CP, Alignment);
}

bool XtensaConstantPoolMBB::hasSameValue(XtensaConstantPoolValue *ACPV) {
  const XtensaConstantPoolMBB *ACPMBB = dyn_cast<XtensaConstantPoolMBB>(ACPV);
  return ACPMBB && ACPMBB->MBB == MBB &&
         XtensaConstantPoolValue::hasSameValue(ACPV);
}

void XtensaConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
  ID.AddPointer(MBB);
  XtensaConstantPoolValue::addSelectionDAGCSEId(ID);
}

void XtensaConstantPoolMBB::print(raw_ostream &O) const {
  O << "BB#" << MBB->getNumber();
  XtensaConstantPoolValue::print(O);
}

XtensaConstantPoolJumpTable::XtensaConstantPoolJumpTable(LLVMContext &C,
                                                         unsigned Index)
    : XtensaConstantPoolValue(C, 0, XtensaCP::CPJumpTable), Idx(Index) {}

XtensaConstantPoolJumpTable *XtensaConstantPoolJumpTable::Create(LLVMContext &C,
                                                                 unsigned Idx) {
  return new XtensaConstantPoolJumpTable(C, Idx);
}

int XtensaConstantPoolJumpTable::getExistingMachineCPValue(
    MachineConstantPool *CP, Align Alignment) {
  return getExistingMachineCPValueImpl<XtensaConstantPoolJumpTable>(CP,
                                                                    Alignment);
}

bool XtensaConstantPoolJumpTable::hasSameValue(XtensaConstantPoolValue *ACPV) {
  const XtensaConstantPoolJumpTable *ACPJT =
      dyn_cast<XtensaConstantPoolJumpTable>(ACPV);
  return ACPJT && ACPJT->Idx == Idx &&
         XtensaConstantPoolValue::hasSameValue(ACPV);
}

void XtensaConstantPoolJumpTable::addSelectionDAGCSEId(FoldingSetNodeID &ID) {}

void XtensaConstantPoolJumpTable::print(raw_ostream &O) const {
  O << "JT" << Idx;
  XtensaConstantPoolValue::print(O);
}