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