contrib/llvm/lib/Target/ARM/ARMConstantPoolValue.h

   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_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H
  15 #define LLVM_LIB_TARGET_ARM_ARMCONSTANTPOOLVALUE_H
  16
  17 #include "llvm/CodeGen/MachineConstantPool.h"
  18 #include "llvm/Support/Casting.h"
  19 #include "llvm/Support/ErrorHandling.h"
  20 #include <cstddef>
  21
  22 namespace llvm {
  23
  24 class BlockAddress;
  25 class Constant;
  26 class GlobalValue;
  27 class LLVMContext;
  28 class MachineBasicBlock;
  29
  30 namespace ARMCP {
  31   enum ARMCPKind {
  32     CPValue,
  33     CPExtSymbol,
  34     CPBlockAddress,
  35     CPLSDA,
  36     CPMachineBasicBlock
  37   };
  38
  39   enum ARMCPModifier {
  40     no_modifier, /// None
  41     TLSGD,       /// Thread Local Storage (General Dynamic Mode)
  42     GOT_PREL,    /// Global Offset Table, PC Relative
  43     GOTTPOFF,    /// Global Offset Table, Thread Pointer Offset
  44     TPOFF,       /// Thread Pointer Offset
  45     SECREL,      /// Section Relative (Windows TLS)
  46   };
  47 }
  48
  49 /// ARMConstantPoolValue - ARM specific constantpool value. This is used to
  50 /// represent PC-relative displacement between the address of the load
  51 /// instruction and the constant being loaded, i.e. (&GV-(LPIC+8)).
  52 class ARMConstantPoolValue : public MachineConstantPoolValue {
  53   unsigned LabelId;        // Label id of the load.
  54   ARMCP::ARMCPKind Kind;   // Kind of constant.
  55   unsigned char PCAdjust;  // Extra adjustment if constantpool is pc-relative.
  56                            // 8 for ARM, 4 for Thumb.
  57   ARMCP::ARMCPModifier Modifier;   // GV modifier i.e. (&GV(modifier)-(LPIC+8))
  58   bool AddCurrentAddress;
  59
  60 protected:
  61   ARMConstantPoolValue(Type *Ty, unsigned id, ARMCP::ARMCPKind Kind,
  62                        unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
  63                        bool AddCurrentAddress);
  64
  65   ARMConstantPoolValue(LLVMContext &C, unsigned id, ARMCP::ARMCPKind Kind,
  66                        unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
  67                        bool AddCurrentAddress);
  68
  69   template <typename Derived>
  70   int getExistingMachineCPValueImpl(MachineConstantPool *CP,
  71                                     unsigned Alignment) {
  72     unsigned AlignMask = Alignment - 1;
  73     const std::vector<MachineConstantPoolEntry> &Constants = CP->getConstants();
  74     for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
  75       if (Constants[i].isMachineConstantPoolEntry() &&
  76           (Constants[i].getAlignment() & AlignMask) == 0) {
  77         ARMConstantPoolValue *CPV =
  78             (ARMConstantPoolValue *)Constants[i].Val.MachineCPVal;
  79         if (Derived *APC = dyn_cast<Derived>(CPV))
  80           if (cast<Derived>(this)->equals(APC))
  81             return i;
  82       }
  83     }
  84
  85     return -1;
  86   }
  87
  88 public:
  89   ~ARMConstantPoolValue() override;
  90
  91   ARMCP::ARMCPModifier getModifier() const { return Modifier; }
  92   const char *getModifierText() const;
  93   bool hasModifier() const { return Modifier != ARMCP::no_modifier; }
  94
  95   bool mustAddCurrentAddress() const { return AddCurrentAddress; }
  96
  97   unsigned getLabelId() const { return LabelId; }
  98   unsigned char getPCAdjustment() const { return PCAdjust; }
  99
 100   bool isGlobalValue() const { return Kind == ARMCP::CPValue; }
 101   bool isExtSymbol() const { return Kind == ARMCP::CPExtSymbol; }
 102   bool isBlockAddress() const { return Kind == ARMCP::CPBlockAddress; }
 103   bool isLSDA() const { return Kind == ARMCP::CPLSDA; }
 104   bool isMachineBasicBlock() const{ return Kind == ARMCP::CPMachineBasicBlock; }
 105
 106   int getExistingMachineCPValue(MachineConstantPool *CP,
 107                                 unsigned Alignment) override;
 108
 109   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
 110
 111   /// hasSameValue - Return true if this ARM constpool value can share the same
 112   /// constantpool entry as another ARM constpool value.
 113   virtual bool hasSameValue(ARMConstantPoolValue *ACPV);
 114
 115   bool equals(const ARMConstantPoolValue *A) const {
 116     return this->LabelId == A->LabelId &&
 117       this->PCAdjust == A->PCAdjust &&
 118       this->Modifier == A->Modifier;
 119   }
 120
 121   void print(raw_ostream &O) const override;
 122   void print(raw_ostream *O) const { if (O) print(*O); }
 123   void dump() const;
 124 };
 125
 126 inline raw_ostream &operator<<(raw_ostream &O, const ARMConstantPoolValue &V) {
 127   V.print(O);
 128   return O;
 129 }
 130
 131 /// ARMConstantPoolConstant - ARM-specific constant pool values for Constants,
 132 /// Functions, and BlockAddresses.
 133 class ARMConstantPoolConstant : public ARMConstantPoolValue {
 134   const Constant *CVal;         // Constant being loaded.
 135
 136   ARMConstantPoolConstant(const Constant *C,
 137                           unsigned ID,
 138                           ARMCP::ARMCPKind Kind,
 139                           unsigned char PCAdj,
 140                           ARMCP::ARMCPModifier Modifier,
 141                           bool AddCurrentAddress);
 142   ARMConstantPoolConstant(Type *Ty, const Constant *C,
 143                           unsigned ID,
 144                           ARMCP::ARMCPKind Kind,
 145                           unsigned char PCAdj,
 146                           ARMCP::ARMCPModifier Modifier,
 147                           bool AddCurrentAddress);
 148
 149 public:
 150   static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID);
 151   static ARMConstantPoolConstant *Create(const GlobalValue *GV,
 152                                          ARMCP::ARMCPModifier Modifier);
 153   static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID,
 154                                          ARMCP::ARMCPKind Kind,
 155                                          unsigned char PCAdj);
 156   static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID,
 157                                          ARMCP::ARMCPKind Kind,
 158                                          unsigned char PCAdj,
 159                                          ARMCP::ARMCPModifier Modifier,
 160                                          bool AddCurrentAddress);
 161
 162   const GlobalValue *getGV() const;
 163   const BlockAddress *getBlockAddress() const;
 164
 165   int getExistingMachineCPValue(MachineConstantPool *CP,
 166                                 unsigned Alignment) override;
 167
 168   /// hasSameValue - Return true if this ARM constpool value can share the same
 169   /// constantpool entry as another ARM constpool value.
 170   bool hasSameValue(ARMConstantPoolValue *ACPV) override;
 171
 172   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
 173
 174   void print(raw_ostream &O) const override;
 175   static bool classof(const ARMConstantPoolValue *APV) {
 176     return APV->isGlobalValue() || APV->isBlockAddress() || APV->isLSDA();
 177   }
 178
 179   bool equals(const ARMConstantPoolConstant *A) const {
 180     return CVal == A->CVal && ARMConstantPoolValue::equals(A);
 181   }
 182 };
 183
 184 /// ARMConstantPoolSymbol - ARM-specific constantpool values for external
 185 /// symbols.
 186 class ARMConstantPoolSymbol : public ARMConstantPoolValue {
 187   const std::string S;          // ExtSymbol being loaded.
 188
 189   ARMConstantPoolSymbol(LLVMContext &C, const char *s, unsigned id,
 190                         unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
 191                         bool AddCurrentAddress);
 192
 193 public:
 194   static ARMConstantPoolSymbol *Create(LLVMContext &C, const char *s,
 195                                        unsigned ID, unsigned char PCAdj);
 196
 197   const char *getSymbol() const { return S.c_str(); }
 198
 199   int getExistingMachineCPValue(MachineConstantPool *CP,
 200                                 unsigned Alignment) override;
 201
 202   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
 203
 204   /// hasSameValue - Return true if this ARM constpool value can share the same
 205   /// constantpool entry as another ARM constpool value.
 206   bool hasSameValue(ARMConstantPoolValue *ACPV) override;
 207
 208   void print(raw_ostream &O) const override;
 209
 210   static bool classof(const ARMConstantPoolValue *ACPV) {
 211     return ACPV->isExtSymbol();
 212   }
 213
 214   bool equals(const ARMConstantPoolSymbol *A) const {
 215     return S == A->S && ARMConstantPoolValue::equals(A);
 216   }
 217 };
 218
 219 /// ARMConstantPoolMBB - ARM-specific constantpool value of a machine basic
 220 /// block.
 221 class ARMConstantPoolMBB : public ARMConstantPoolValue {
 222   const MachineBasicBlock *MBB; // Machine basic block.
 223
 224   ARMConstantPoolMBB(LLVMContext &C, const MachineBasicBlock *mbb, unsigned id,
 225                      unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
 226                      bool AddCurrentAddress);
 227
 228 public:
 229   static ARMConstantPoolMBB *Create(LLVMContext &C,
 230                                     const MachineBasicBlock *mbb,
 231                                     unsigned ID, unsigned char PCAdj);
 232
 233   const MachineBasicBlock *getMBB() const { return MBB; }
 234
 235   int getExistingMachineCPValue(MachineConstantPool *CP,
 236                                 unsigned Alignment) override;
 237
 238   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
 239
 240   /// hasSameValue - Return true if this ARM constpool value can share the same
 241   /// constantpool entry as another ARM constpool value.
 242   bool hasSameValue(ARMConstantPoolValue *ACPV) override;
 243
 244   void print(raw_ostream &O) const override;
 245
 246   static bool classof(const ARMConstantPoolValue *ACPV) {
 247     return ACPV->isMachineBasicBlock();
 248   }
 249
 250   bool equals(const ARMConstantPoolMBB *A) const {
 251     return MBB == A->MBB && ARMConstantPoolValue::equals(A);
 252   }
 253 };
 254
 255 } // End llvm namespace
 256
 257 #endif