lib/Target/ARM/ARMConstantPoolValue.cpp

   1 //===-- ARMConstantPoolValue.cpp - ARM constantpool value -----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the ARM specific constantpool value class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARMConstantPoolValue.h"
  15 #include "llvm/ADT/FoldingSet.h"
  16 #include "llvm/CodeGen/MachineBasicBlock.h"
  17 #include "llvm/IR/Constant.h"
  18 #include "llvm/IR/Constants.h"
  19 #include "llvm/IR/GlobalValue.h"
  20 #include "llvm/IR/Type.h"
  21 #include "llvm/Support/raw_ostream.h"
  22 #include <cstdlib>
  23 using namespace llvm;
  24
  25 //===----------------------------------------------------------------------===//
  26 // ARMConstantPoolValue
  27 //===----------------------------------------------------------------------===//
  28
  29 ARMConstantPoolValue::ARMConstantPoolValue(Type *Ty, unsigned id,
  30                                            ARMCP::ARMCPKind kind,
  31                                            unsigned char PCAdj,
  32                                            ARMCP::ARMCPModifier modifier,
  33                                            bool addCurrentAddress)
  34   : MachineConstantPoolValue(Ty), LabelId(id), Kind(kind),
  35     PCAdjust(PCAdj), Modifier(modifier),
  36     AddCurrentAddress(addCurrentAddress) {}
  37
  38 ARMConstantPoolValue::ARMConstantPoolValue(LLVMContext &C, unsigned id,
  39                                            ARMCP::ARMCPKind kind,
  40                                            unsigned char PCAdj,
  41                                            ARMCP::ARMCPModifier modifier,
  42                                            bool addCurrentAddress)
  43   : MachineConstantPoolValue((Type*)Type::getInt32Ty(C)),
  44     LabelId(id), Kind(kind), PCAdjust(PCAdj), Modifier(modifier),
  45     AddCurrentAddress(addCurrentAddress) {}
  46
  47 ARMConstantPoolValue::~ARMConstantPoolValue() {}
  48
  49 const char *ARMConstantPoolValue::getModifierText() const {
  50   switch (Modifier) {
  51     // FIXME: Are these case sensitive? It'd be nice to lower-case all the
  52     // strings if that's legal.
  53   case ARMCP::no_modifier: return "none";
  54   case ARMCP::TLSGD:       return "tlsgd";
  55   case ARMCP::GOT:         return "GOT";
  56   case ARMCP::GOTOFF:      return "GOTOFF";
  57   case ARMCP::GOTTPOFF:    return "gottpoff";
  58   case ARMCP::TPOFF:       return "tpoff";
  59   }
  60   llvm_unreachable("Unknown modifier!");
  61 }
  62
  63 int ARMConstantPoolValue::getExistingMachineCPValue(MachineConstantPool *CP,
  64                                                     unsigned Alignment) {
  65   llvm_unreachable("Shouldn't be calling this directly!");
  66 }
  67
  68 void
  69 ARMConstantPoolValue::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
  70   ID.AddInteger(LabelId);
  71   ID.AddInteger(PCAdjust);
  72 }
  73
  74 bool
  75 ARMConstantPoolValue::hasSameValue(ARMConstantPoolValue *ACPV) {
  76   if (ACPV->Kind == Kind &&
  77       ACPV->PCAdjust == PCAdjust &&
  78       ACPV->Modifier == Modifier) {
  79     if (ACPV->LabelId == LabelId)
  80       return true;
  81     // Two PC relative constpool entries containing the same GV address or
  82     // external symbols. FIXME: What about blockaddress?
  83     if (Kind == ARMCP::CPValue || Kind == ARMCP::CPExtSymbol)
  84       return true;
  85   }
  86   return false;
  87 }
  88
  89 void ARMConstantPoolValue::dump() const {
  90   errs() << "  " << *this;
  91 }
  92
  93 void ARMConstantPoolValue::print(raw_ostream &O) const {
  94   if (Modifier) O << "(" << getModifierText() << ")";
  95   if (PCAdjust != 0) {
  96     O << "-(LPC" << LabelId << "+" << (unsigned)PCAdjust;
  97     if (AddCurrentAddress) O << "-.";
  98     O << ")";
  99   }
 100 }
 101
 102 //===----------------------------------------------------------------------===//
 103 // ARMConstantPoolConstant
 104 //===----------------------------------------------------------------------===//
 105
 106 ARMConstantPoolConstant::ARMConstantPoolConstant(Type *Ty,
 107                                                  const Constant *C,
 108                                                  unsigned ID,
 109                                                  ARMCP::ARMCPKind Kind,
 110                                                  unsigned char PCAdj,
 111                                                  ARMCP::ARMCPModifier Modifier,
 112                                                  bool AddCurrentAddress)
 113   : ARMConstantPoolValue(Ty, ID, Kind, PCAdj, Modifier, AddCurrentAddress),
 114     CVal(C) {}
 115
 116 ARMConstantPoolConstant::ARMConstantPoolConstant(const Constant *C,
 117                                                  unsigned ID,
 118                                                  ARMCP::ARMCPKind Kind,
 119                                                  unsigned char PCAdj,
 120                                                  ARMCP::ARMCPModifier Modifier,
 121                                                  bool AddCurrentAddress)
 122   : ARMConstantPoolValue((Type*)C->getType(), ID, Kind, PCAdj, Modifier,
 123                          AddCurrentAddress),
 124     CVal(C) {}
 125
 126 ARMConstantPoolConstant *
 127 ARMConstantPoolConstant::Create(const Constant *C, unsigned ID) {
 128   return new ARMConstantPoolConstant(C, ID, ARMCP::CPValue, 0,
 129                                      ARMCP::no_modifier, false);
 130 }
 131
 132 ARMConstantPoolConstant *
 133 ARMConstantPoolConstant::Create(const GlobalValue *GV,
 134                                 ARMCP::ARMCPModifier Modifier) {
 135   return new ARMConstantPoolConstant((Type*)Type::getInt32Ty(GV->getContext()),
 136                                      GV, 0, ARMCP::CPValue, 0,
 137                                      Modifier, false);
 138 }
 139
 140 ARMConstantPoolConstant *
 141 ARMConstantPoolConstant::Create(const Constant *C, unsigned ID,
 142                                 ARMCP::ARMCPKind Kind, unsigned char PCAdj) {
 143   return new ARMConstantPoolConstant(C, ID, Kind, PCAdj,
 144                                      ARMCP::no_modifier, false);
 145 }
 146
 147 ARMConstantPoolConstant *
 148 ARMConstantPoolConstant::Create(const Constant *C, unsigned ID,
 149                                 ARMCP::ARMCPKind Kind, unsigned char PCAdj,
 150                                 ARMCP::ARMCPModifier Modifier,
 151                                 bool AddCurrentAddress) {
 152   return new ARMConstantPoolConstant(C, ID, Kind, PCAdj, Modifier,
 153                                      AddCurrentAddress);
 154 }
 155
 156 const GlobalValue *ARMConstantPoolConstant::getGV() const {
 157   return dyn_cast_or_null<GlobalValue>(CVal);
 158 }
 159
 160 const BlockAddress *ARMConstantPoolConstant::getBlockAddress() const {
 161   return dyn_cast_or_null<BlockAddress>(CVal);
 162 }
 163
 164 int ARMConstantPoolConstant::getExistingMachineCPValue(MachineConstantPool *CP,
 165                                                        unsigned Alignment) {
 166   unsigned AlignMask = Alignment - 1;
 167   const std::vector<MachineConstantPoolEntry> Constants = CP->getConstants();
 168   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
 169     if (Constants[i].isMachineConstantPoolEntry() &&
 170         (Constants[i].getAlignment() & AlignMask) == 0) {
 171       ARMConstantPoolValue *CPV =
 172         (ARMConstantPoolValue *)Constants[i].Val.MachineCPVal;
 173       ARMConstantPoolConstant *APC = dyn_cast<ARMConstantPoolConstant>(CPV);
 174       if (!APC) continue;
 175       if (APC->CVal == CVal && equals(APC))
 176         return i;
 177     }
 178   }
 179
 180   return -1;
 181 }
 182
 183 bool ARMConstantPoolConstant::hasSameValue(ARMConstantPoolValue *ACPV) {
 184   const ARMConstantPoolConstant *ACPC = dyn_cast<ARMConstantPoolConstant>(ACPV);
 185   return ACPC && ACPC->CVal == CVal && ARMConstantPoolValue::hasSameValue(ACPV);
 186 }
 187
 188 void ARMConstantPoolConstant::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
 189   ID.AddPointer(CVal);
 190   ARMConstantPoolValue::addSelectionDAGCSEId(ID);
 191 }
 192
 193 void ARMConstantPoolConstant::print(raw_ostream &O) const {
 194   O << CVal->getName();
 195   ARMConstantPoolValue::print(O);
 196 }
 197
 198 //===----------------------------------------------------------------------===//
 199 // ARMConstantPoolSymbol
 200 //===----------------------------------------------------------------------===//
 201
 202 ARMConstantPoolSymbol::ARMConstantPoolSymbol(LLVMContext &C, const char *s,
 203                                              unsigned id,
 204                                              unsigned char PCAdj,
 205                                              ARMCP::ARMCPModifier Modifier,
 206                                              bool AddCurrentAddress)
 207   : ARMConstantPoolValue(C, id, ARMCP::CPExtSymbol, PCAdj, Modifier,
 208                          AddCurrentAddress),
 209     S(s) {}
 210
 211 ARMConstantPoolSymbol *
 212 ARMConstantPoolSymbol::Create(LLVMContext &C, const char *s,
 213                               unsigned ID, unsigned char PCAdj) {
 214   return new ARMConstantPoolSymbol(C, s, ID, PCAdj, ARMCP::no_modifier, false);
 215 }
 216
 217 int ARMConstantPoolSymbol::getExistingMachineCPValue(MachineConstantPool *CP,
 218                                                      unsigned Alignment) {
 219   unsigned AlignMask = Alignment - 1;
 220   const std::vector<MachineConstantPoolEntry> Constants = CP->getConstants();
 221   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
 222     if (Constants[i].isMachineConstantPoolEntry() &&
 223         (Constants[i].getAlignment() & AlignMask) == 0) {
 224       ARMConstantPoolValue *CPV =
 225         (ARMConstantPoolValue *)Constants[i].Val.MachineCPVal;
 226       ARMConstantPoolSymbol *APS = dyn_cast<ARMConstantPoolSymbol>(CPV);
 227       if (!APS) continue;
 228
 229       if (APS->S == S && equals(APS))
 230         return i;
 231     }
 232   }
 233
 234   return -1;
 235 }
 236
 237 bool ARMConstantPoolSymbol::hasSameValue(ARMConstantPoolValue *ACPV) {
 238   const ARMConstantPoolSymbol *ACPS = dyn_cast<ARMConstantPoolSymbol>(ACPV);
 239   return ACPS && ACPS->S == S && ARMConstantPoolValue::hasSameValue(ACPV);
 240 }
 241
 242 void ARMConstantPoolSymbol::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
 243   ID.AddString(S);
 244   ARMConstantPoolValue::addSelectionDAGCSEId(ID);
 245 }
 246
 247 void ARMConstantPoolSymbol::print(raw_ostream &O) const {
 248   O << S;
 249   ARMConstantPoolValue::print(O);
 250 }
 251
 252 //===----------------------------------------------------------------------===//
 253 // ARMConstantPoolMBB
 254 //===----------------------------------------------------------------------===//
 255
 256 ARMConstantPoolMBB::ARMConstantPoolMBB(LLVMContext &C,
 257                                        const MachineBasicBlock *mbb,
 258                                        unsigned id, unsigned char PCAdj,
 259                                        ARMCP::ARMCPModifier Modifier,
 260                                        bool AddCurrentAddress)
 261   : ARMConstantPoolValue(C, id, ARMCP::CPMachineBasicBlock, PCAdj,
 262                          Modifier, AddCurrentAddress),
 263     MBB(mbb) {}
 264
 265 ARMConstantPoolMBB *ARMConstantPoolMBB::Create(LLVMContext &C,
 266                                                const MachineBasicBlock *mbb,
 267                                                unsigned ID,
 268                                                unsigned char PCAdj) {
 269   return new ARMConstantPoolMBB(C, mbb, ID, PCAdj, ARMCP::no_modifier, false);
 270 }
 271
 272 int ARMConstantPoolMBB::getExistingMachineCPValue(MachineConstantPool *CP,
 273                                                   unsigned Alignment) {
 274   unsigned AlignMask = Alignment - 1;
 275   const std::vector<MachineConstantPoolEntry> Constants = CP->getConstants();
 276   for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
 277     if (Constants[i].isMachineConstantPoolEntry() &&
 278         (Constants[i].getAlignment() & AlignMask) == 0) {
 279       ARMConstantPoolValue *CPV =
 280         (ARMConstantPoolValue *)Constants[i].Val.MachineCPVal;
 281       ARMConstantPoolMBB *APMBB = dyn_cast<ARMConstantPoolMBB>(CPV);
 282       if (!APMBB) continue;
 283
 284       if (APMBB->MBB == MBB && equals(APMBB))
 285         return i;
 286     }
 287   }
 288
 289   return -1;
 290 }
 291
 292 bool ARMConstantPoolMBB::hasSameValue(ARMConstantPoolValue *ACPV) {
 293   const ARMConstantPoolMBB *ACPMBB = dyn_cast<ARMConstantPoolMBB>(ACPV);
 294   return ACPMBB && ACPMBB->MBB == MBB &&
 295     ARMConstantPoolValue::hasSameValue(ACPV);
 296 }
 297
 298 void ARMConstantPoolMBB::addSelectionDAGCSEId(FoldingSetNodeID &ID) {
 299   ID.AddPointer(MBB);
 300   ARMConstantPoolValue::addSelectionDAGCSEId(ID);
 301 }
 302
 303 void ARMConstantPoolMBB::print(raw_ostream &O) const {
 304   O << "BB#" << MBB->getNumber();
 305   ARMConstantPoolValue::print(O);
 306 }