LLVM  15.0.0git
CSKYConstantPoolValue.h
Go to the documentation of this file.
1 //===-- CSKYConstantPoolValue.h - CSKY constantpool value -----*- C++ -*---===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the CSKY specific constantpool value class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_TARGET_CSKY_CONSTANTPOOLVALUE_H
14 #define LLVM_TARGET_CSKY_CONSTANTPOOLVALUE_H
15 
16 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Support/Casting.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 CSKYCP {
31 enum CSKYCPKind {
37 };
38 
40 } // namespace CSKYCP
41 
42 /// CSKYConstantPoolValue - CSKY specific constantpool value. This is used to
43 /// represent PC-relative displacement between the address of the load
44 /// instruction and the constant being loaded, i.e. (&GV-(LPIC+8)).
46 protected:
47  CSKYCP::CSKYCPKind Kind; // Kind of constant.
48  unsigned PCAdjust; // Extra adjustment if constantpool is pc-relative.
51 
52  unsigned LabelId = 0;
53 
56  unsigned ID = 0);
57 
58 public:
59  const char *getModifierText() const;
60  unsigned getPCAdjustment() const { return PCAdjust; }
61  bool mustAddCurrentAddress() const { return AddCurrentAddress; }
63  unsigned getLabelID() const { return LabelId; }
64 
65  bool isGlobalValue() const { return Kind == CSKYCP::CPValue; }
66  bool isExtSymbol() const { return Kind == CSKYCP::CPExtSymbol; }
67  bool isBlockAddress() const { return Kind == CSKYCP::CPBlockAddress; }
68  bool isMachineBasicBlock() const {
70  }
71  bool isJT() const { return Kind == CSKYCP::CPJT; }
72 
74  Align Alignment) override;
75 
77 
78  void print(raw_ostream &O) const override;
79 
80  bool equals(const CSKYConstantPoolValue *A) const {
81  return this->LabelId == A->LabelId && this->PCAdjust == A->PCAdjust &&
82  this->Modifier == A->Modifier;
83  }
84 
85  template <typename Derived>
87  const std::vector<MachineConstantPoolEntry> &Constants = CP->getConstants();
88  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
89  if (Constants[i].isMachineConstantPoolEntry() &&
90  Constants[i].getAlign() >= Alignment) {
91  auto *CPV =
92  static_cast<CSKYConstantPoolValue *>(Constants[i].Val.MachineCPVal);
93  if (Derived *APC = dyn_cast<Derived>(CPV))
94  if (cast<Derived>(this)->equals(APC))
95  return i;
96  }
97  }
98 
99  return -1;
100  }
101 };
102 
103 /// CSKY-specific constant pool values for Constants,
104 /// Functions, and BlockAddresses.
106  const Constant *CVal; // Constant being loaded.
107 
110  bool AddCurrentAddress, unsigned ID);
111 
112 public:
113  static CSKYConstantPoolConstant *
114  Create(const Constant *C, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust,
116  unsigned ID = 0);
117  const GlobalValue *getGV() const;
118  const BlockAddress *getBlockAddress() const;
119 
121  Align Alignment) override;
122  void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
123  void print(raw_ostream &O) const override;
124 
125  bool equals(const CSKYConstantPoolConstant *A) const {
126  return CVal == A->CVal && CSKYConstantPoolValue::equals(A);
127  }
128 
129  static bool classof(const CSKYConstantPoolValue *APV) {
130  return APV->isGlobalValue() || APV->isBlockAddress();
131  }
132 };
133 
134 /// CSKYConstantPoolSymbol - CSKY-specific constantpool values for external
135 /// symbols.
137  const std::string S; // ExtSymbol being loaded.
138 
139  CSKYConstantPoolSymbol(Type *Ty, const char *S, unsigned PCAdjust,
141  bool AddCurrentAddress);
142 
143 public:
144  static CSKYConstantPoolSymbol *Create(Type *Ty, const char *S,
145  unsigned PCAdjust,
147 
148  StringRef getSymbol() const { return S; }
149 
151  Align Alignment) override;
152  void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
153  void print(raw_ostream &O) const override;
154 
155  bool equals(const CSKYConstantPoolSymbol *A) const {
156  return S == A->S && CSKYConstantPoolValue::equals(A);
157  }
158 
159  static bool classof(const CSKYConstantPoolValue *ACPV) {
160  return ACPV->isExtSymbol();
161  }
162 };
163 
164 /// CSKYConstantPoolMBB - CSKY-specific constantpool value of a machine basic
165 /// block.
167  const MachineBasicBlock *MBB; // Machine basic block.
168 
169  CSKYConstantPoolMBB(Type *Ty, const MachineBasicBlock *Mbb, unsigned PCAdjust,
171 
172 public:
173  static CSKYConstantPoolMBB *Create(Type *Ty, const MachineBasicBlock *Mbb,
174  unsigned PCAdjust);
175 
176  const MachineBasicBlock *getMBB() const { return MBB; }
177 
179  Align Alignment) override;
180  void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
181  void print(raw_ostream &O) const override;
182 
183  bool equals(const CSKYConstantPoolMBB *A) const {
184  return MBB == A->MBB && CSKYConstantPoolValue::equals(A);
185  }
186 
187  static bool classof(const CSKYConstantPoolValue *ACPV) {
188  return ACPV->isMachineBasicBlock();
189  }
190 };
191 
192 /// CSKY-specific constantpool value of a jump table.
194  signed JTI; // Machine basic block.
195 
196  CSKYConstantPoolJT(Type *Ty, int JTIndex, unsigned PCAdj,
198 
199 public:
200  static CSKYConstantPoolJT *Create(Type *Ty, int JTI, unsigned PCAdj,
202 
203  signed getJTI() { return JTI; }
204 
206  Align Alignment) override;
207  void addSelectionDAGCSEId(FoldingSetNodeID &ID) override;
208  void print(raw_ostream &O) const override;
209 
210  bool equals(const CSKYConstantPoolJT *A) const {
211  return JTI == A->JTI && CSKYConstantPoolValue::equals(A);
212  }
213 
214  static bool classof(const CSKYConstantPoolValue *ACPV) {
215  return ACPV->isJT();
216  }
217 };
218 
219 } // namespace llvm
220 
221 #endif
i
i
Definition: README.txt:29
llvm::CSKYConstantPoolValue::isMachineBasicBlock
bool isMachineBasicBlock() const
Definition: CSKYConstantPoolValue.h:68
llvm::CSKYConstantPoolSymbol::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:143
llvm::CSKYCP::PLT
@ PLT
Definition: CSKYConstantPoolValue.h:39
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::dwarf::Constants
Constants
Definition: Dwarf.h:432
llvm::CSKYCP::TLSGD
@ TLSGD
Definition: CSKYConstantPoolValue.h:39
llvm::CSKYConstantPoolJT::Create
static CSKYConstantPoolJT * Create(Type *Ty, int JTI, unsigned PCAdj, CSKYCP::CSKYCPModifier Modifier)
Definition: CSKYConstantPoolValue.cpp:198
llvm::CSKYConstantPoolValue::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:68
llvm::CSKYCP::CPBlockAddress
@ CPBlockAddress
Definition: CSKYConstantPoolValue.h:34
llvm::CSKYConstantPoolJT::getJTI
signed getJTI()
Definition: CSKYConstantPoolValue.h:203
StringRef.h
llvm::CSKYConstantPoolConstant::classof
static bool classof(const CSKYConstantPoolValue *APV)
Definition: CSKYConstantPoolValue.h:129
llvm::CSKYConstantPoolValue::getExistingMachineCPValueImpl
int getExistingMachineCPValueImpl(MachineConstantPool *CP, Align Alignment)
Definition: CSKYConstantPoolValue.h:86
llvm::CSKYConstantPoolJT
CSKY-specific constantpool value of a jump table.
Definition: CSKYConstantPoolValue.h:193
llvm::CSKYConstantPoolMBB::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:181
llvm::CSKYConstantPoolValue::Modifier
CSKYCP::CSKYCPModifier Modifier
Definition: CSKYConstantPoolValue.h:49
llvm::CSKYConstantPoolValue::isExtSymbol
bool isExtSymbol() const
Definition: CSKYConstantPoolValue.h:66
llvm::CSKYConstantPoolConstant::Create
static CSKYConstantPoolConstant * Create(const Constant *C, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust, CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID=0)
Definition: CSKYConstantPoolValue.cpp:86
ErrorHandling.h
llvm::CSKYConstantPoolJT::equals
bool equals(const CSKYConstantPoolJT *A) const
Definition: CSKYConstantPoolValue.h:210
llvm::MachineConstantPoolValue
Abstract base class for all machine specific constantpool value subclasses.
Definition: MachineConstantPool.h:35
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::CSKYConstantPoolValue::isJT
bool isJT() const
Definition: CSKYConstantPoolValue.h:71
llvm::CSKYConstantPoolJT::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:213
llvm::CSKYCP::GOT
@ GOT
Definition: CSKYConstantPoolValue.h:39
llvm::CSKYConstantPoolValue::isGlobalValue
bool isGlobalValue() const
Definition: CSKYConstantPoolValue.h:65
llvm::CSKYConstantPoolJT::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:203
llvm::CSKYConstantPoolJT::classof
static bool classof(const CSKYConstantPoolValue *ACPV)
Definition: CSKYConstantPoolValue.h:214
llvm::CSKYConstantPoolConstant::equals
bool equals(const CSKYConstantPoolConstant *A) const
Definition: CSKYConstantPoolValue.h:125
llvm::ISD::Constant
@ Constant
Definition: ISDOpcodes.h:76
llvm::CSKYConstantPoolValue::isBlockAddress
bool isBlockAddress() const
Definition: CSKYConstantPoolValue.h:67
llvm::CSKYCP::NO_MOD
@ NO_MOD
Definition: CSKYConstantPoolValue.h:39
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::CSKYCP::CPJT
@ CPJT
Definition: CSKYConstantPoolValue.h:36
llvm::CSKYConstantPoolJT::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:208
llvm::CSKYConstantPoolValue::mustAddCurrentAddress
bool mustAddCurrentAddress() const
Definition: CSKYConstantPoolValue.h:61
llvm::CSKYConstantPoolSymbol::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:148
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::CSKYCP::CPExtSymbol
@ CPExtSymbol
Definition: CSKYConstantPoolValue.h:33
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:94
llvm::CSKYConstantPoolValue::getModifierText
const char * getModifierText() const
Definition: CSKYConstantPoolValue.cpp:35
llvm::CSKYConstantPoolValue::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:62
llvm::CSKYConstantPoolSymbol::Create
static CSKYConstantPoolSymbol * Create(Type *Ty, const char *S, unsigned PCAdjust, CSKYCP::CSKYCPModifier Modifier)
Definition: CSKYConstantPoolValue.cpp:132
llvm::CSKYConstantPoolConstant
CSKY-specific constant pool values for Constants, Functions, and BlockAddresses.
Definition: CSKYConstantPoolValue.h:105
llvm::ISD::BlockAddress
@ BlockAddress
Definition: ISDOpcodes.h:84
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::CSKYConstantPoolValue::getLabelID
unsigned getLabelID() const
Definition: CSKYConstantPoolValue.h:63
llvm::CSKYConstantPoolValue::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:57
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::MachineConstantPool
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
Definition: MachineConstantPool.h:117
llvm::CSKYConstantPoolValue
CSKYConstantPoolValue - CSKY specific constantpool value.
Definition: CSKYConstantPoolValue.h:45
llvm::CSKYCP::GOTOFF
@ GOTOFF
Definition: CSKYConstantPoolValue.h:39
llvm::CSKYConstantPoolSymbol::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:137
llvm::CSKYCP::ADDR
@ ADDR
Definition: CSKYConstantPoolValue.h:39
MachineConstantPool.h
llvm::CSKYConstantPoolConstant::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:114
llvm::CSKYConstantPoolMBB::Create
static CSKYConstantPoolMBB * Create(Type *Ty, const MachineBasicBlock *Mbb, unsigned PCAdjust)
Definition: CSKYConstantPoolValue.cpp:165
llvm::CSKYConstantPoolValue::getModifier
CSKYCP::CSKYCPModifier getModifier() const
Definition: CSKYConstantPoolValue.h:62
llvm::CSKYCP::CPValue
@ CPValue
Definition: CSKYConstantPoolValue.h:32
llvm::CSKYConstantPoolMBB::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:176
llvm::CSKYCP::CSKYCPKind
CSKYCPKind
Definition: CSKYConstantPoolValue.h:31
llvm::CSKYConstantPoolConstant::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:108
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::CSKYCP::TLSLE
@ TLSLE
Definition: CSKYConstantPoolValue.h:39
llvm::CSKYConstantPoolValue::PCAdjust
unsigned PCAdjust
Definition: CSKYConstantPoolValue.h:48
llvm::CSKYConstantPoolValue::LabelId
unsigned LabelId
Definition: CSKYConstantPoolValue.h:52
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::CSKYCP::CSKYCPModifier
CSKYCPModifier
Definition: CSKYConstantPoolValue.h:39
llvm::CSKYCP::CPMachineBasicBlock
@ CPMachineBasicBlock
Definition: CSKYConstantPoolValue.h:35
llvm::CSKYConstantPoolConstant::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:103
llvm::FoldingSetNodeID
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:317
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::CSKYConstantPoolConstant::getBlockAddress
const BlockAddress * getBlockAddress() const
Definition: CSKYConstantPoolValue.cpp:98
llvm::CSKYConstantPoolValue::CSKYConstantPoolValue
CSKYConstantPoolValue(Type *Ty, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust, CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID=0)
Definition: CSKYConstantPoolValue.cpp:27
llvm::CSKYConstantPoolSymbol::classof
static bool classof(const CSKYConstantPoolValue *ACPV)
Definition: CSKYConstantPoolValue.h:159
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::HexagonISD::CP
@ CP
Definition: HexagonISelLowering.h:53
llvm::CSKYConstantPoolValue::Kind
CSKYCP::CSKYCPKind Kind
Definition: CSKYConstantPoolValue.h:47
llvm::CSKYConstantPoolConstant::getGV
const GlobalValue * getGV() const
Definition: CSKYConstantPoolValue.cpp:93
llvm::CSKYConstantPoolValue::AddCurrentAddress
bool AddCurrentAddress
Definition: CSKYConstantPoolValue.h:50
Casting.h
llvm::CSKYConstantPoolSymbol
CSKYConstantPoolSymbol - CSKY-specific constantpool values for external symbols.
Definition: CSKYConstantPoolValue.h:136
llvm::CSKYConstantPoolValue::getPCAdjustment
unsigned getPCAdjustment() const
Definition: CSKYConstantPoolValue.h:60
llvm::CSKYConstantPoolMBB::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:171
llvm::getAlign
bool getAlign(const Function &F, unsigned index, unsigned &align)
Definition: NVPTXUtilities.cpp:284
llvm::CSKYConstantPoolMBB
CSKYConstantPoolMBB - CSKY-specific constantpool value of a machine basic block.
Definition: CSKYConstantPoolValue.h:166
llvm::CSKYConstantPoolMBB::getMBB
const MachineBasicBlock * getMBB() const
Definition: CSKYConstantPoolValue.h:176
llvm::CSKYConstantPoolValue::equals
bool equals(const CSKYConstantPoolValue *A) const
Definition: CSKYConstantPoolValue.h:80
llvm::CSKYCP::TLSIE
@ TLSIE
Definition: CSKYConstantPoolValue.h:39
llvm::CSKYConstantPoolSymbol::getSymbol
StringRef getSymbol() const
Definition: CSKYConstantPoolValue.h:148
llvm::CSKYConstantPoolMBB::equals
bool equals(const CSKYConstantPoolMBB *A) const
Definition: CSKYConstantPoolValue.h:183
llvm::CSKYConstantPoolMBB::classof
static bool classof(const CSKYConstantPoolValue *ACPV)
Definition: CSKYConstantPoolValue.h:187
llvm::CSKYConstantPoolSymbol::equals
bool equals(const CSKYConstantPoolSymbol *A) const
Definition: CSKYConstantPoolValue.h:155