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

Generated by: LCOV version 1.13