LLVM  16.0.0git
CSKYConstantPoolValue.cpp
Go to the documentation of this file.
1 //===-- CSKYConstantPoolValue.cpp - CSKY constantpool value ---------------===//
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 #include "CSKYConstantPoolValue.h"
14 #include "llvm/ADT/FoldingSet.h"
16 #include "llvm/IR/Constant.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/GlobalValue.h"
19 #include "llvm/IR/Type.h"
21 using namespace llvm;
22 
23 //===----------------------------------------------------------------------===//
24 // CSKYConstantPoolValue
25 //===----------------------------------------------------------------------===//
26 
28  unsigned PCAdjust,
29  CSKYCP::CSKYCPModifier Modifier,
30  bool AddCurrentAddress,
31  unsigned ID)
32  : MachineConstantPoolValue(Ty), Kind(Kind), PCAdjust(PCAdjust),
33  Modifier(Modifier), AddCurrentAddress(AddCurrentAddress), LabelId(ID) {}
34 
36  switch (Modifier) {
37  case CSKYCP::ADDR:
38  return "ADDR";
39  case CSKYCP::GOT:
40  return "GOT";
41  case CSKYCP::GOTOFF:
42  return "GOTOFF";
43  case CSKYCP::PLT:
44  return "PLT";
45  case CSKYCP::TLSIE:
46  return "TLSIE";
47  case CSKYCP::TLSLE:
48  return "TLSLE";
49  case CSKYCP::TLSGD:
50  return "TLSGD";
51  case CSKYCP::NO_MOD:
52  return "";
53  }
54  llvm_unreachable("Unknown modifier!");
55 }
56 
58  Align Alignment) {
59  llvm_unreachable("Shouldn't be calling this directly!");
60 }
61 
63  ID.AddInteger(LabelId);
64  ID.AddInteger(PCAdjust);
65  ID.AddInteger(Modifier);
66 }
67 
69  if (Modifier)
70  O << "(" << getModifierText() << ")";
71  if (PCAdjust)
72  O << " + " << PCAdjust;
73 }
74 
75 //===----------------------------------------------------------------------===//
76 // CSKYConstantPoolConstant
77 //===----------------------------------------------------------------------===//
78 
79 CSKYConstantPoolConstant::CSKYConstantPoolConstant(
80  const Constant *C, Type *Ty, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust,
81  CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID)
82  : CSKYConstantPoolValue(Ty, Kind, PCAdjust, Modifier, AddCurrentAddress,
83  ID),
84  CVal(C) {}
85 
87  const Constant *C, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust,
88  CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID) {
89  return new CSKYConstantPoolConstant(C, C->getType(), Kind, PCAdjust, Modifier,
91 }
92 
94  const Constant *C, Type *Ty, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust,
95  CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID) {
98 }
99 
101  assert(isa<GlobalValue>(CVal) && "CVal should be GlobalValue");
102  return cast<GlobalValue>(CVal);
103 }
104 
106  assert(isa<BlockAddress>(CVal) && "CVal should be BlockAddress");
107  return cast<BlockAddress>(CVal);
108 }
109 
111  return CVal;
112 }
113 
115  Align Alignment) {
116  return getExistingMachineCPValueImpl<CSKYConstantPoolConstant>(CP, Alignment);
117 }
118 
120  ID.AddPointer(CVal);
121 
123 }
124 
126  O << CVal->getName();
128 }
129 
130 //===----------------------------------------------------------------------===//
131 // CSKYConstantPoolSymbol
132 //===----------------------------------------------------------------------===//
133 
134 CSKYConstantPoolSymbol::CSKYConstantPoolSymbol(Type *Ty, const char *S,
135  unsigned PCAdjust,
136  CSKYCP::CSKYCPModifier Modifier,
137  bool AddCurrentAddress)
138  : CSKYConstantPoolValue(Ty, CSKYCP::CPExtSymbol, PCAdjust, Modifier,
139  AddCurrentAddress),
140  S(strdup(S)) {}
141 
143 CSKYConstantPoolSymbol::Create(Type *Ty, const char *S, unsigned PCAdjust,
144  CSKYCP::CSKYCPModifier Modifier) {
145  return new CSKYConstantPoolSymbol(Ty, S, PCAdjust, Modifier, false);
146 }
147 
149  Align Alignment) {
150 
151  return getExistingMachineCPValueImpl<CSKYConstantPoolSymbol>(CP, Alignment);
152 }
153 
155  ID.AddString(S);
157 }
158 
160  O << S;
162 }
163 
164 //===----------------------------------------------------------------------===//
165 // CSKYConstantPoolMBB
166 //===----------------------------------------------------------------------===//
167 
168 CSKYConstantPoolMBB::CSKYConstantPoolMBB(Type *Ty, const MachineBasicBlock *Mbb,
169  unsigned PCAdjust,
170  CSKYCP::CSKYCPModifier Modifier,
171  bool AddCurrentAddress)
172  : CSKYConstantPoolValue(Ty, CSKYCP::CPMachineBasicBlock, PCAdjust, Modifier,
173  AddCurrentAddress),
174  MBB(Mbb) {}
175 
177  const MachineBasicBlock *Mbb,
178  unsigned PCAdjust) {
179  return new CSKYConstantPoolMBB(Ty, Mbb, PCAdjust, CSKYCP::ADDR, false);
180 }
181 
183  Align Alignment) {
184  return getExistingMachineCPValueImpl<CSKYConstantPoolMBB>(CP, Alignment);
185 }
186 
188  ID.AddPointer(MBB);
190 }
191 
193  O << "BB#" << MBB->getNumber();
195 }
196 
197 //===----------------------------------------------------------------------===//
198 // CSKYConstantPoolJT
199 //===----------------------------------------------------------------------===//
200 
201 CSKYConstantPoolJT::CSKYConstantPoolJT(Type *Ty, int JTIndex, unsigned PCAdj,
202  CSKYCP::CSKYCPModifier Modifier,
203  bool AddCurrentAddress)
204  : CSKYConstantPoolValue(Ty, CSKYCP::CPJT, PCAdj, Modifier,
205  AddCurrentAddress),
206  JTI(JTIndex) {}
207 
209 CSKYConstantPoolJT::Create(Type *Ty, int JTI, unsigned PCAdj,
210  CSKYCP::CSKYCPModifier Modifier) {
211  return new CSKYConstantPoolJT(Ty, JTI, PCAdj, Modifier, false);
212 }
213 
215  Align Alignment) {
216  return getExistingMachineCPValueImpl<CSKYConstantPoolJT>(CP, Alignment);
217 }
218 
220  ID.AddInteger(JTI);
222 }
223 
225  O << "JTI#" << JTI;
227 }
llvm::CSKYConstantPoolSymbol::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:154
llvm::CSKYCP::PLT
@ PLT
Definition: CSKYConstantPoolValue.h:40
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::CSKYCP::TLSGD
@ TLSGD
Definition: CSKYConstantPoolValue.h:40
CSKYConstantPoolValue.h
llvm::CSKYConstantPoolJT::Create
static CSKYConstantPoolJT * Create(Type *Ty, int JTI, unsigned PCAdj, CSKYCP::CSKYCPModifier Modifier)
Definition: CSKYConstantPoolValue.cpp:209
llvm::CSKYConstantPoolValue::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:68
llvm::CSKYConstantPoolJT
CSKY-specific constantpool value of a jump table.
Definition: CSKYConstantPoolValue.h:200
llvm::CSKYConstantPoolMBB::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:192
llvm::CSKYConstantPoolValue::Modifier
CSKYCP::CSKYCPModifier Modifier
Definition: CSKYConstantPoolValue.h:50
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
llvm::ARMCP::CPMachineBasicBlock
@ CPMachineBasicBlock
Definition: ARMConstantPoolValue.h:42
MachineBasicBlock.h
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::CSKYConstantPoolJT::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:224
llvm::CSKYCP::GOT
@ GOT
Definition: CSKYConstantPoolValue.h:40
llvm::CSKYConstantPoolJT::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:214
llvm::CSKYConstantPoolConstant::getConstantPool
const Constant * getConstantPool() const
Definition: CSKYConstantPoolValue.cpp:110
GlobalValue.h
Constants.h
llvm::ARMCP::CPExtSymbol
@ CPExtSymbol
Definition: ARMConstantPoolValue.h:39
llvm::CSKYCP::NO_MOD
@ NO_MOD
Definition: CSKYConstantPoolValue.h:40
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:219
llvm::CSKYConstantPoolSymbol::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:159
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
Type.h
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:143
llvm::CSKYConstantPoolConstant
CSKY-specific constant pool values for Constants, Functions, and BlockAddresses.
Definition: CSKYConstantPoolValue.h:107
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:264
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::CSKYConstantPoolValue::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp: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:46
llvm::CSKYCP::GOTOFF
@ GOTOFF
Definition: CSKYConstantPoolValue.h:40
llvm::CSKYConstantPoolSymbol::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:148
llvm::CSKYCP::ADDR
@ ADDR
Definition: CSKYConstantPoolValue.h:40
llvm::CSKYConstantPoolConstant::print
void print(raw_ostream &O) const override
print - Implement operator<<
Definition: CSKYConstantPoolValue.cpp:125
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::CSKYConstantPoolMBB::Create
static CSKYConstantPoolMBB * Create(Type *Ty, const MachineBasicBlock *Mbb, unsigned PCAdjust)
Definition: CSKYConstantPoolValue.cpp:176
llvm::CSKYConstantPoolMBB::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:187
llvm::CSKYCP::CSKYCPKind
CSKYCPKind
Definition: CSKYConstantPoolValue.h:31
llvm::CSKYConstantPoolConstant::addSelectionDAGCSEId
void addSelectionDAGCSEId(FoldingSetNodeID &ID) override
Definition: CSKYConstantPoolValue.cpp:119
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:849
llvm::CSKYCP::TLSLE
@ TLSLE
Definition: CSKYConstantPoolValue.h:40
llvm::CSKYConstantPoolValue::PCAdjust
unsigned PCAdjust
Definition: CSKYConstantPoolValue.h:49
llvm::CSKYConstantPoolValue::LabelId
unsigned LabelId
Definition: CSKYConstantPoolValue.h:53
llvm::MachineBasicBlock::getNumber
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
Definition: MachineBasicBlock.h:1115
llvm::CSKYCP::CSKYCPModifier
CSKYCPModifier
Definition: CSKYConstantPoolValue.h:40
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::CSKYConstantPoolConstant::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:114
llvm::FoldingSetNodeID
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
Definition: FoldingSet.h:318
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:105
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:308
llvm::CSKYConstantPoolValue::CSKYConstantPoolValue
CSKYConstantPoolValue(Type *Ty, CSKYCP::CSKYCPKind Kind, unsigned PCAdjust, CSKYCP::CSKYCPModifier Modifier, bool AddCurrentAddress, unsigned ID=0)
Definition: CSKYConstantPoolValue.cpp:27
FoldingSet.h
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::HexagonISD::CP
@ CP
Definition: HexagonISelLowering.h:53
llvm::CSKYConstantPoolValue::Kind
CSKYCP::CSKYCPKind Kind
Definition: CSKYConstantPoolValue.h:48
Constant.h
llvm::CSKYConstantPoolConstant::getGV
const GlobalValue * getGV() const
Definition: CSKYConstantPoolValue.cpp:100
llvm::CSKYConstantPoolValue::AddCurrentAddress
bool AddCurrentAddress
Definition: CSKYConstantPoolValue.h:51
llvm::CSKYConstantPoolSymbol
CSKYConstantPoolSymbol - CSKY-specific constantpool values for external symbols.
Definition: CSKYConstantPoolValue.h:143
llvm::CSKYConstantPoolMBB::getExistingMachineCPValue
int getExistingMachineCPValue(MachineConstantPool *CP, Align Alignment) override
Definition: CSKYConstantPoolValue.cpp:182
llvm::CSKYConstantPoolMBB
CSKYConstantPoolMBB - CSKY-specific constantpool value of a machine basic block.
Definition: CSKYConstantPoolValue.h:173
llvm::CSKYCP::TLSIE
@ TLSIE
Definition: CSKYConstantPoolValue.h:40
raw_ostream.h