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,
41     TLSGD,
42     GOT,
43     GOTOFF,
44     GOTTPOFF,
45     TPOFF
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>
getExistingMachineCPValueImpl(MachineConstantPool * CP,unsigned Alignment)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   virtual ~ARMConstantPoolValue();
90 
getModifier()91   ARMCP::ARMCPModifier getModifier() const { return Modifier; }
92   const char *getModifierText() const;
hasModifier()93   bool hasModifier() const { return Modifier != ARMCP::no_modifier; }
94 
mustAddCurrentAddress()95   bool mustAddCurrentAddress() const { return AddCurrentAddress; }
96 
getLabelId()97   unsigned getLabelId() const { return LabelId; }
getPCAdjustment()98   unsigned char getPCAdjustment() const { return PCAdjust; }
99 
isGlobalValue()100   bool isGlobalValue() const { return Kind == ARMCP::CPValue; }
isExtSymbol()101   bool isExtSymbol() const { return Kind == ARMCP::CPExtSymbol; }
isBlockAddress()102   bool isBlockAddress() const { return Kind == ARMCP::CPBlockAddress; }
isLSDA()103   bool isLSDA() const { return Kind == ARMCP::CPLSDA; }
isMachineBasicBlock()104   bool isMachineBasicBlock() const{ return Kind == ARMCP::CPMachineBasicBlock; }
105 
getRelocationInfo()106   unsigned getRelocationInfo() const override { return 2; }
107 
108   int getExistingMachineCPValue(MachineConstantPool *CP,
109                                 unsigned Alignment) override;
110 
111   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
112 
113   /// hasSameValue - Return true if this ARM constpool value can share the same
114   /// constantpool entry as another ARM constpool value.
115   virtual bool hasSameValue(ARMConstantPoolValue *ACPV);
116 
equals(const ARMConstantPoolValue * A)117   bool equals(const ARMConstantPoolValue *A) const {
118     return this->LabelId == A->LabelId &&
119       this->PCAdjust == A->PCAdjust &&
120       this->Modifier == A->Modifier;
121   }
122 
123   void print(raw_ostream &O) const override;
print(raw_ostream * O)124   void print(raw_ostream *O) const { if (O) print(*O); }
125   void dump() const;
126 };
127 
128 inline raw_ostream &operator<<(raw_ostream &O, const ARMConstantPoolValue &V) {
129   V.print(O);
130   return O;
131 }
132 
133 /// ARMConstantPoolConstant - ARM-specific constant pool values for Constants,
134 /// Functions, and BlockAddresses.
135 class ARMConstantPoolConstant : public ARMConstantPoolValue {
136   const Constant *CVal;         // Constant being loaded.
137 
138   ARMConstantPoolConstant(const Constant *C,
139                           unsigned ID,
140                           ARMCP::ARMCPKind Kind,
141                           unsigned char PCAdj,
142                           ARMCP::ARMCPModifier Modifier,
143                           bool AddCurrentAddress);
144   ARMConstantPoolConstant(Type *Ty, const Constant *C,
145                           unsigned ID,
146                           ARMCP::ARMCPKind Kind,
147                           unsigned char PCAdj,
148                           ARMCP::ARMCPModifier Modifier,
149                           bool AddCurrentAddress);
150 
151 public:
152   static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID);
153   static ARMConstantPoolConstant *Create(const GlobalValue *GV,
154                                          ARMCP::ARMCPModifier Modifier);
155   static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID,
156                                          ARMCP::ARMCPKind Kind,
157                                          unsigned char PCAdj);
158   static ARMConstantPoolConstant *Create(const Constant *C, unsigned ID,
159                                          ARMCP::ARMCPKind Kind,
160                                          unsigned char PCAdj,
161                                          ARMCP::ARMCPModifier Modifier,
162                                          bool AddCurrentAddress);
163 
164   const GlobalValue *getGV() const;
165   const BlockAddress *getBlockAddress() const;
166 
167   int getExistingMachineCPValue(MachineConstantPool *CP,
168                                 unsigned Alignment) override;
169 
170   /// hasSameValue - Return true if this ARM constpool value can share the same
171   /// constantpool entry as another ARM constpool value.
172   bool hasSameValue(ARMConstantPoolValue *ACPV) override;
173 
174   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
175 
176   void print(raw_ostream &O) const override;
classof(const ARMConstantPoolValue * APV)177   static bool classof(const ARMConstantPoolValue *APV) {
178     return APV->isGlobalValue() || APV->isBlockAddress() || APV->isLSDA();
179   }
180 
equals(const ARMConstantPoolConstant * A)181   bool equals(const ARMConstantPoolConstant *A) const {
182     return CVal == A->CVal && ARMConstantPoolValue::equals(A);
183   }
184 };
185 
186 /// ARMConstantPoolSymbol - ARM-specific constantpool values for external
187 /// symbols.
188 class ARMConstantPoolSymbol : public ARMConstantPoolValue {
189   const std::string S;          // ExtSymbol being loaded.
190 
191   ARMConstantPoolSymbol(LLVMContext &C, const char *s, unsigned id,
192                         unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
193                         bool AddCurrentAddress);
194 
195 public:
196   static ARMConstantPoolSymbol *Create(LLVMContext &C, const char *s,
197                                        unsigned ID, unsigned char PCAdj);
198 
getSymbol()199   const char *getSymbol() const { return S.c_str(); }
200 
201   int getExistingMachineCPValue(MachineConstantPool *CP,
202                                 unsigned Alignment) override;
203 
204   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
205 
206   /// hasSameValue - Return true if this ARM constpool value can share the same
207   /// constantpool entry as another ARM constpool value.
208   bool hasSameValue(ARMConstantPoolValue *ACPV) override;
209 
210   void print(raw_ostream &O) const override;
211 
classof(const ARMConstantPoolValue * ACPV)212   static bool classof(const ARMConstantPoolValue *ACPV) {
213     return ACPV->isExtSymbol();
214   }
215 
equals(const ARMConstantPoolSymbol * A)216   bool equals(const ARMConstantPoolSymbol *A) const {
217     return S == A->S && ARMConstantPoolValue::equals(A);
218   }
219 };
220 
221 /// ARMConstantPoolMBB - ARM-specific constantpool value of a machine basic
222 /// block.
223 class ARMConstantPoolMBB : public ARMConstantPoolValue {
224   const MachineBasicBlock *MBB; // Machine basic block.
225 
226   ARMConstantPoolMBB(LLVMContext &C, const MachineBasicBlock *mbb, unsigned id,
227                      unsigned char PCAdj, ARMCP::ARMCPModifier Modifier,
228                      bool AddCurrentAddress);
229 
230 public:
231   static ARMConstantPoolMBB *Create(LLVMContext &C,
232                                     const MachineBasicBlock *mbb,
233                                     unsigned ID, unsigned char PCAdj);
234 
getMBB()235   const MachineBasicBlock *getMBB() const { return MBB; }
236 
237   int getExistingMachineCPValue(MachineConstantPool *CP,
238                                 unsigned Alignment) override;
239 
240   void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
241 
242   /// hasSameValue - Return true if this ARM constpool value can share the same
243   /// constantpool entry as another ARM constpool value.
244   bool hasSameValue(ARMConstantPoolValue *ACPV) override;
245 
246   void print(raw_ostream &O) const override;
247 
classof(const ARMConstantPoolValue * ACPV)248   static bool classof(const ARMConstantPoolValue *ACPV) {
249     return ACPV->isMachineBasicBlock();
250   }
251 
equals(const ARMConstantPoolMBB * A)252   bool equals(const ARMConstantPoolMBB *A) const {
253     return MBB == A->MBB && ARMConstantPoolValue::equals(A);
254   }
255 };
256 
257 } // End llvm namespace
258 
259 #endif
260