Home | History | Annotate | Download | only in ARM 
      1 //===- ARMConstantPoolValue.h - ARM constantpool value ----------*- C++ -*-===//
      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 #ifndef LLVM_TARGET_ARM_CONSTANTPOOLVALUE_H
     15 #define LLVM_TARGET_ARM_CONSTANTPOOLVALUE_H
     16 
     17 #include "llvm/CodeGen/MachineConstantPool.h"
     18 #include "llvm/Support/ErrorHandling.h"
     19 #include <cstddef>
     20 
     21 namespace llvm {
     22 
     23 class Constant;
     24 class BlockAddress;
     25 class GlobalValue;
     26 class LLVMContext;
     27 
     28 namespace ARMCP {
     29   enum ARMCPKind {
     30     CPValue,
     31     CPExtSymbol,
     32     CPBlockAddress,
     33     CPLSDA
     34   };
     35 
     36   enum ARMCPModifier {
     37     no_modifier,
     38     TLSGD,
     39     GOT,
     40     GOTOFF,
     41     GOTTPOFF,
     42     TPOFF
     43   };
     44 }
     45 
     46 /// ARMConstantPoolValue - ARM specific constantpool value. This is used to
     47 /// represent PC-relative displacement between the address of the load
     48 /// instruction and the constant being loaded, i.e. (&GV-(LPIC+8)).
     49 class ARMConstantPoolValue : public MachineConstantPoolValue {
     50   const Constant *CVal;    // Constant being loaded.
     51   const char *S;           // ExtSymbol being loaded.
     52   unsigned LabelId;        // Label id of the load.
     53   ARMCP::ARMCPKind Kind;   // Kind of constant.
     54   unsigned char PCAdjust;  // Extra adjustment if constantpool is pc-relative.
     55                            // 8 for ARM, 4 for Thumb.
     56   ARMCP::ARMCPModifier Modifier;   // GV modifier i.e. (&GV(modifier)-(LPIC+8))
     57   bool AddCurrentAddress;
     58 
     59 public:
     60   ARMConstantPoolValue(const Constant *cval, unsigned id,
     61                        ARMCP::ARMCPKind Kind = ARMCP::CPValue,
     62                        unsigned char PCAdj = 0,
     63                        ARMCP::ARMCPModifier Modifier = ARMCP::no_modifier,
     64                        bool AddCurrentAddress = false);
     65   ARMConstantPoolValue(LLVMContext &C, const char *s, unsigned id,
     66                        unsigned char PCAdj = 0,
     67                        ARMCP::ARMCPModifier Modifier = ARMCP::no_modifier,
     68                        bool AddCurrentAddress = false);
     69   ARMConstantPoolValue(const GlobalValue *GV, ARMCP::ARMCPModifier Modifier);
     70   ARMConstantPoolValue();
     71   ~ARMConstantPoolValue();
     72 
     73   const GlobalValue *getGV() const;
     74   const char *getSymbol() const { return S; }
     75   const BlockAddress *getBlockAddress() const;
     76   ARMCP::ARMCPModifier getModifier() const { return Modifier; }
     77   const char *getModifierText() const {
     78     switch (Modifier) {
     79     default: llvm_unreachable("Unknown modifier!");
     80     // FIXME: Are these case sensitive? It'd be nice to lower-case all the
     81     // strings if that's legal.
     82     case ARMCP::no_modifier: return "none";
     83     case ARMCP::TLSGD:       return "tlsgd";
     84     case ARMCP::GOT:         return "GOT";
     85     case ARMCP::GOTOFF:      return "GOTOFF";
     86     case ARMCP::GOTTPOFF:    return "gottpoff";
     87     case ARMCP::TPOFF:       return "tpoff";
     88     }
     89   }
     90   bool hasModifier() const { return Modifier != ARMCP::no_modifier; }
     91   bool mustAddCurrentAddress() const { return AddCurrentAddress; }
     92   unsigned getLabelId() const { return LabelId; }
     93   unsigned char getPCAdjustment() const { return PCAdjust; }
     94   bool isGlobalValue() const { return Kind == ARMCP::CPValue; }
     95   bool isExtSymbol() const { return Kind == ARMCP::CPExtSymbol; }
     96   bool isBlockAddress() { return Kind == ARMCP::CPBlockAddress; }
     97   bool isLSDA() { return Kind == ARMCP::CPLSDA; }
     98 
     99   virtual unsigned getRelocationInfo() const { return 2; }
    100 
    101   virtual int getExistingMachineCPValue(MachineConstantPool *CP,
    102                                         unsigned Alignment);
    103 
    104   virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID);
    105 
    106   /// hasSameValue - Return true if this ARM constpool value
    107   /// can share the same constantpool entry as another ARM constpool value.
    108   bool hasSameValue(ARMConstantPoolValue *ACPV);
    109 
    110   void print(raw_ostream *O) const { if (O) print(*O); }
    111   void print(raw_ostream &O) const;
    112   void dump() const;
    113 };
    114 
    115 inline raw_ostream &operator<<(raw_ostream &O, const ARMConstantPoolValue &V) {
    116   V.print(O);
    117   return O;
    118 }
    119 
    120 } // End llvm namespace
    121 
    122 #endif
    123