llvm/lib/Target/CSKY/CSKYConstantPoolValue.cpp

   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(
  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
  86 CSKYConstantPoolConstant *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
  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,
  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
 110 const Constant *CSKYConstantPoolConstant::getConstantPool() const {
 111   return CVal;
 112 }
 113
 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);
 227 }