LCOV - code coverage report
Current view: top level - lib/Target/ARM - ARMConstantPoolValue.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 87 116 75.0 %
Date: 2018-02-23 15:42:53 Functions: 26 33 78.8 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13