LLVM  15.0.0git
CSKYAsmBackend.cpp
Go to the documentation of this file.
1 //===-- CSKYAsmBackend.cpp - CSKY Assembler Backend -----------------------===//
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 #include "CSKYAsmBackend.h"
11 #include "llvm/ADT/DenseMap.h"
12 #include "llvm/MC/MCAsmLayout.h"
13 #include "llvm/MC/MCAssembler.h"
14 #include "llvm/MC/MCContext.h"
16 #include "llvm/MC/MCObjectWriter.h"
17 #include "llvm/Support/Debug.h"
18 
19 #define DEBUG_TYPE "csky-asmbackend"
20 
21 using namespace llvm;
22 
23 std::unique_ptr<MCObjectTargetWriter>
26 }
27 
28 const MCFixupKindInfo &
30 
32  {CSKY::Fixups::fixup_csky_addr32, {"fixup_csky_addr32", 0, 32, 0}},
33  {CSKY::Fixups::fixup_csky_addr_hi16, {"fixup_csky_addr_hi16", 0, 32, 0}},
34  {CSKY::Fixups::fixup_csky_addr_lo16, {"fixup_csky_addr_lo16", 0, 32, 0}},
36  {"fixup_csky_pcrel_imm16_scale2", 0, 32, MCFixupKindInfo::FKF_IsPCRel}},
38  {"fixup_csky_pcrel_uimm16_scale4", 0, 32,
42  {"fixup_csky_pcrel_uimm8_scale4", 0, 32,
46  {"fixup_csky_pcrel_imm26_scale2", 0, 32, MCFixupKindInfo::FKF_IsPCRel}},
48  {"fixup_csky_pcrel_imm18_scale2", 0, 32, MCFixupKindInfo::FKF_IsPCRel}},
49  {CSKY::Fixups::fixup_csky_got32, {"fixup_csky_got32", 0, 32, 0}},
51  {"fixup_csky_got_imm18_scale4", 0, 32, 0}},
52  {CSKY::Fixups::fixup_csky_gotoff, {"fixup_csky_gotoff", 0, 32, 0}},
54  {"fixup_csky_gotpc", 0, 32, MCFixupKindInfo::FKF_IsPCRel}},
55  {CSKY::Fixups::fixup_csky_plt32, {"fixup_csky_plt32", 0, 32, 0}},
57  {"fixup_csky_plt_imm18_scale4", 0, 32, 0}},
59  {"fixup_csky_pcrel_imm10_scale2", 0, 16, MCFixupKindInfo::FKF_IsPCRel}},
61  {"fixup_csky_pcrel_uimm7_scale4", 0, 16,
65  {"fixup_csky_doffset_imm18", 0, 18, 0}},
67  {"fixup_csky_doffset_imm18_scale2", 0, 18, 0}},
69  {"fixup_csky_doffset_imm18_scale4", 0, 18, 0}}};
70 
72  "Not all fixup kinds added to Infos array");
73 
76  "Invalid kind!");
77 
78  return Infos[Kind];
79  } else if (Kind < FirstTargetFixupKind) {
81  } else {
83  }
84 }
85 
87  MCContext &Ctx) {
88  switch (Fixup.getTargetKind()) {
89  default:
90  llvm_unreachable("Unknown fixup kind!");
97  llvm_unreachable("Relocation should be unconditionally forced\n");
98  case FK_Data_1:
99  case FK_Data_2:
100  case FK_Data_4:
101  case FK_Data_8:
102  return Value;
104  return Value & 0xffffffff;
106  if (!isIntN(17, Value))
107  Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
108  if (Value & 0x1)
109  Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned.");
110 
111  return (Value >> 1) & 0xffff;
113  if (!isUIntN(18, Value))
114  Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
115  if (Value & 0x3)
116  Ctx.reportError(Fixup.getLoc(), "fixup value must be 4-byte aligned.");
117 
118  return (Value >> 2) & 0xffff;
120  if (!isIntN(27, Value))
121  Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
122  if (Value & 0x1)
123  Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned.");
124 
125  return (Value >> 1) & 0x3ffffff;
127  if (!isIntN(19, Value))
128  Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
129  if (Value & 0x1)
130  Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned.");
131 
132  return (Value >> 1) & 0x3ffff;
134  if (!isUIntN(10, Value))
135  Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
136  if (Value & 0x3)
137  Ctx.reportError(Fixup.getLoc(), "fixup value must be 4-byte aligned.");
138 
139  unsigned IMM4L = (Value >> 2) & 0xf;
140  unsigned IMM4H = (Value >> 6) & 0xf;
141 
142  Value = (IMM4H << 21) | (IMM4L << 4);
143  return Value;
144  }
146  if (!isIntN(11, Value))
147  Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
148  if (Value & 0x1)
149  Ctx.reportError(Fixup.getLoc(), "fixup value must be 2-byte aligned.");
150 
151  return (Value >> 1) & 0x3ff;
153  if (!isUIntN(9, Value))
154  Ctx.reportError(Fixup.getLoc(), "out of range pc-relative fixup value.");
155  if (Value & 0x3)
156  Ctx.reportError(Fixup.getLoc(), "fixup value must be 4-byte aligned.");
157 
158  if ((Value & 0xff) <= 0b111111100) {
159  unsigned IMM5L = (Value >> 2) & 0x1f;
160  unsigned IMM2H = (Value >> 7) & 0x3;
161 
162  Value = (1 << 12) | (IMM2H << 8) | IMM5L;
163  } else {
164  unsigned IMM5L = (!Value >> 2) & 0x1f;
165  unsigned IMM2H = (!Value >> 7) & 0x3;
166 
167  Value = (IMM2H << 8) | IMM5L;
168  }
169 
170  return Value & 0xffff;
171  }
172 }
173 
175  bool Resolved, uint64_t Value,
176  const MCRelaxableFragment *DF,
177  const MCAsmLayout &Layout,
178  const bool WasForced) const {
179  // Return true if the symbol is actually unresolved.
180  // Resolved could be always false when shouldForceRelocation return true.
181  // We use !WasForced to indicate that the symbol is unresolved and not forced
182  // by shouldForceRelocation.
183  if (!Resolved && !WasForced)
184  return true;
185 
186  int64_t Offset = int64_t(Value);
187  switch (Fixup.getTargetKind()) {
188  default:
189  return false;
191  return !isShiftedInt<10, 1>(Offset);
193  return !isShiftedInt<16, 1>(Offset);
195  return !isShiftedInt<26, 1>(Offset);
197  return !isShiftedUInt<8, 2>(Offset);
198  }
199 }
200 
202  const MCValue &Target,
204  bool IsResolved,
205  const MCSubtargetInfo *STI) const {
206  MCFixupKind Kind = Fixup.getKind();
208  return;
209  MCContext &Ctx = Asm.getContext();
211  if (!Value)
212  return; // Doesn't change encoding.
213  // Apply any target-specific value adjustments.
215 
216  // Shift the value into position.
217  Value <<= Info.TargetOffset;
218 
219  unsigned Offset = Fixup.getOffset();
220  unsigned NumBytes = alignTo(Info.TargetSize + Info.TargetOffset, 8) / 8;
221 
222  assert(Offset + NumBytes <= Data.size() && "Invalid fixup offset!");
223 
224  // For each byte of the fragment that the fixup touches, mask in the
225  // bits from the fixup value.
226  bool IsLittleEndian = (Endian == support::little);
227  bool IsInstFixup = (Kind >= FirstTargetFixupKind);
228 
229  if (IsLittleEndian && IsInstFixup && (NumBytes == 4)) {
230  Data[Offset + 0] |= uint8_t((Value >> 16) & 0xff);
231  Data[Offset + 1] |= uint8_t((Value >> 24) & 0xff);
232  Data[Offset + 2] |= uint8_t(Value & 0xff);
233  Data[Offset + 3] |= uint8_t((Value >> 8) & 0xff);
234  } else {
235  for (unsigned I = 0; I != NumBytes; I++) {
236  unsigned Idx = IsLittleEndian ? I : (NumBytes - 1 - I);
237  Data[Offset + Idx] |= uint8_t((Value >> (I * 8)) & 0xff);
238  }
239  }
240 }
241 
243  const MCSubtargetInfo &STI) const {
244  switch (Inst.getOpcode()) {
245  default:
246  return false;
247  case CSKY::JBR32:
248  case CSKY::JBT32:
249  case CSKY::JBF32:
250  case CSKY::JBSR32:
251  if (!STI.getFeatureBits()[CSKY::Has2E3])
252  return false;
253  return true;
254  case CSKY::JBR16:
255  case CSKY::JBT16:
256  case CSKY::JBF16:
257  case CSKY::LRW16:
258  case CSKY::BR16:
259  return true;
260  }
261 }
262 
264  const MCFixup &Fixup,
265  const MCValue &Target) {
266  if (Fixup.getKind() >= FirstLiteralRelocationKind)
267  return true;
268  switch (Fixup.getTargetKind()) {
269  default:
270  break;
280  return true;
281  }
282 
283  return false;
284 }
285 
287  const MCRelaxableFragment *DF,
288  const MCAsmLayout &Layout) const {
289  return false;
290 }
291 
293  const MCSubtargetInfo &STI) const {
294  MCInst Res;
295 
296  switch (Inst.getOpcode()) {
297  default:
298  LLVM_DEBUG(Inst.dump());
299  llvm_unreachable("Opcode not expected!");
300  case CSKY::LRW16:
301  Res.setOpcode(CSKY::LRW32);
302  Res.addOperand(Inst.getOperand(0));
303  Res.addOperand(Inst.getOperand(1));
304  break;
305  case CSKY::BR16:
306  Res.setOpcode(CSKY::BR32);
307  Res.addOperand(Inst.getOperand(0));
308  break;
309  case CSKY::JBSR32:
310  Res.setOpcode(CSKY::JSRI32);
311  Res.addOperand(Inst.getOperand(1));
312  break;
313  case CSKY::JBR32:
314  Res.setOpcode(CSKY::JMPI32);
315  Res.addOperand(Inst.getOperand(1));
316  break;
317  case CSKY::JBT32:
318  case CSKY::JBF32:
319  Res.setOpcode(Inst.getOpcode() == CSKY::JBT32 ? CSKY::JBT_E : CSKY::JBF_E);
320  Res.addOperand(Inst.getOperand(0));
321  Res.addOperand(Inst.getOperand(1));
322  Res.addOperand(Inst.getOperand(2));
323  break;
324  case CSKY::JBR16:
325  Res.setOpcode(CSKY::JBR32);
326  Res.addOperand(Inst.getOperand(0));
327  Res.addOperand(Inst.getOperand(1));
328  break;
329  case CSKY::JBT16:
330  case CSKY::JBF16:
331  // ck801
332  unsigned opcode;
333  if (STI.getFeatureBits()[CSKY::HasE2])
334  opcode = Inst.getOpcode() == CSKY::JBT16 ? CSKY::JBT32 : CSKY::JBF32;
335  else
336  opcode = Inst.getOpcode() == CSKY::JBT16 ? CSKY::JBT_E : CSKY::JBF_E;
337 
338  Res.setOpcode(opcode);
339  Res.addOperand(Inst.getOperand(0));
340  Res.addOperand(Inst.getOperand(1));
341  Res.addOperand(Inst.getOperand(2));
342  break;
343  }
344  Inst = std::move(Res);
345 }
346 
348  const MCSubtargetInfo *STI) const {
349  OS.write_zeros(Count);
350  return true;
351 }
352 
354  const MCSubtargetInfo &STI,
355  const MCRegisterInfo &MRI,
356  const MCTargetOptions &Options) {
357  return new CSKYAsmBackend(STI, Options);
358 }
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:156
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::MCRelaxableFragment
A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler lay...
Definition: MCFragment.h:270
llvm::MCAsmBackend::getFixupKindInfo
virtual const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
Definition: MCAsmBackend.cpp:82
llvm::CSKYAsmBackend
Definition: CSKYAsmBackend.h:19
llvm::CSKYAsmBackend::mayNeedRelaxation
bool mayNeedRelaxation(const MCInst &Inst, const MCSubtargetInfo &STI) const override
Check whether the given instruction may need relaxation.
Definition: CSKYAsmBackend.cpp:242
T
llvm::raw_ostream::write_zeros
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert 'NumZeros' nulls.
Definition: raw_ostream.cpp:501
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:76
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:145
llvm::FirstTargetFixupKind
@ FirstTargetFixupKind
Definition: MCFixup.h:45
llvm::CSKY::fixup_csky_pcrel_imm10_scale2
@ fixup_csky_pcrel_imm10_scale2
Definition: CSKYFixupKinds.h:43
MCAssembler.h
llvm::CSKY::fixup_csky_gotpc
@ fixup_csky_gotpc
Definition: CSKYFixupKinds.h:31
llvm::MCInst::dump
void dump() const
Definition: MCInst.cpp:104
DenseMap.h
llvm::CSKY::fixup_csky_pcrel_uimm7_scale4
@ fixup_csky_pcrel_uimm7_scale4
Definition: CSKYFixupKinds.h:45
MCFixupKindInfo.h
llvm::CSKY::fixup_csky_got32
@ fixup_csky_got32
Definition: CSKYFixupKinds.h:35
llvm::CSKY::fixup_csky_doffset_imm18
@ fixup_csky_doffset_imm18
Definition: CSKYFixupKinds.h:49
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
llvm::CSKY::fixup_csky_got_imm18_scale4
@ fixup_csky_got_imm18_scale4
Definition: CSKYFixupKinds.h:37
llvm::CSKYAsmBackend::getNumFixupKinds
unsigned int getNumFixupKinds() const override
Get the number of target specific fixup kinds.
Definition: CSKYAsmBackend.h:25
llvm::MCFixupKindInfo::FKF_IsAlignedDownTo32Bits
@ FKF_IsAlignedDownTo32Bits
Should this fixup kind force a 4-byte aligned effective PC value?
Definition: MCFixupKindInfo.h:22
llvm::CSKY::fixup_csky_pcrel_uimm8_scale4
@ fixup_csky_pcrel_uimm8_scale4
Definition: CSKYFixupKinds.h:47
llvm::Data
@ Data
Definition: SIMachineScheduler.h:55
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::MCAsmBackend::Endian
const support::endianness Endian
Definition: MCAsmBackend.h:51
llvm::MCInst::setOpcode
void setOpcode(unsigned Op)
Definition: MCInst.h:197
llvm::FirstLiteralRelocationKind
@ FirstLiteralRelocationKind
The range [FirstLiteralRelocationKind, MaxTargetFixupKind) is used for relocations coming from ....
Definition: MCFixup.h:50
x3
In x86 we generate this spiffy xmm0 xmm0 ret in x86 we generate this which could be xmm1 movss xmm1 xmm0 ret In sse4 we could use insertps to make both better Here s another testcase that could use x3
Definition: README-SSE.txt:547
llvm::FK_Data_4
@ FK_Data_4
A four-byte fixup.
Definition: MCFixup.h:25
llvm::MCAsmBackend
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:42
llvm::MutableArrayRef< char >
llvm::CSKY::fixup_csky_plt32
@ fixup_csky_plt32
Definition: CSKYFixupKinds.h:39
llvm::support::little
@ little
Definition: Endian.h:27
CSKYAsmBackend.h
llvm::CSKYAsmBackend::applyFixup
void applyFixup(const MCAssembler &Asm, const MCFixup &Fixup, const MCValue &Target, MutableArrayRef< char > Data, uint64_t Value, bool IsResolved, const MCSubtargetInfo *STI) const override
Apply the Value for given Fixup into the provided data fragment, at the offset specified by the fixup...
Definition: CSKYAsmBackend.cpp:201
llvm::CSKY::fixup_csky_doffset_imm18_scale4
@ fixup_csky_doffset_imm18_scale4
Definition: CSKYFixupKinds.h:53
MCContext.h
llvm::CSKY::fixup_csky_doffset_imm18_scale2
@ fixup_csky_doffset_imm18_scale2
Definition: CSKYFixupKinds.h:51
llvm::isUIntN
bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:455
llvm::MCSubtargetInfo::getFeatureBits
const FeatureBitset & getFeatureBits() const
Definition: MCSubtargetInfo.h:112
llvm::createCSKYAsmBackend
MCAsmBackend * createCSKYAsmBackend(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options)
Definition: CSKYAsmBackend.cpp:353
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
Info
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
llvm::CSKY::fixup_csky_addr_lo16
@ fixup_csky_addr_lo16
Definition: CSKYFixupKinds.h:21
llvm::isIntN
bool isIntN(unsigned N, int64_t x)
Checks if an signed integer fits into the given (dynamic) bit width.
Definition: MathExtras.h:460
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::CSKY::fixup_csky_pcrel_imm26_scale2
@ fixup_csky_pcrel_imm26_scale2
Definition: CSKYFixupKinds.h:27
DF
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
llvm::MCInst::addOperand
void addOperand(const MCOperand Op)
Definition: MCInst.h:210
llvm::CSKY::fixup_csky_pcrel_imm16_scale2
@ fixup_csky_pcrel_imm16_scale2
Definition: CSKYFixupKinds.h:23
llvm::MCAssembler
Definition: MCAssembler.h:73
llvm::CSKYAsmBackend::shouldForceRelocation
bool shouldForceRelocation(const MCAssembler &Asm, const MCFixup &Fixup, const MCValue &Target) override
Hook to check if a relocation is needed for some target specific reason.
Definition: CSKYAsmBackend.cpp:263
uint64_t
llvm::CSKYAsmBackend::writeNopData
bool writeNopData(raw_ostream &OS, uint64_t Count, const MCSubtargetInfo *STI) const override
Write an (optimal) nop sequence of Count bytes to the given output.
Definition: CSKYAsmBackend.cpp:347
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::MCFixupKindInfo::FKF_IsPCRel
@ FKF_IsPCRel
Is this fixup kind PCrelative? This is used by the assembler backend to evaluate fixup values in a ta...
Definition: MCFixupKindInfo.h:19
llvm::DenseMap
Definition: DenseMap.h:716
I
#define I(x, y, z)
Definition: MD5.cpp:58
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::CSKYAsmBackend::createObjectTargetWriter
std::unique_ptr< MCObjectTargetWriter > createObjectTargetWriter() const override
Definition: CSKYAsmBackend.cpp:24
llvm::MCFixupKindInfo
Target independent information on a fixup kind.
Definition: MCFixupKindInfo.h:15
llvm::CSKY::fixup_csky_addr_hi16
@ fixup_csky_addr_hi16
Definition: CSKYFixupKinds.h:19
CSKYMCTargetDesc.h
llvm::MCContext::reportError
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1037
llvm::CSKY::fixup_csky_pcrel_uimm16_scale4
@ fixup_csky_pcrel_uimm16_scale4
Definition: CSKYFixupKinds.h:25
llvm::FK_Data_1
@ FK_Data_1
A one-byte fixup.
Definition: MCFixup.h:23
llvm::MCTargetOptions
Definition: MCTargetOptions.h:42
llvm::FK_NONE
@ FK_NONE
A no-op fixup.
Definition: MCFixup.h:22
llvm::CSKYAsmBackend::relaxInstruction
void relaxInstruction(MCInst &Inst, const MCSubtargetInfo &STI) const override
Relax the instruction in the given fragment to the next wider instruction.
Definition: CSKYAsmBackend.cpp:292
llvm::CSKY::fixup_csky_gotoff
@ fixup_csky_gotoff
Definition: CSKYFixupKinds.h:33
llvm::CSKY::fixup_csky_plt_imm18_scale4
@ fixup_csky_plt_imm18_scale4
Definition: CSKYFixupKinds.h:41
Fixup
PowerPC TLS Dynamic Call Fixup
Definition: PPCTLSDynamicCall.cpp:215
adjustFixupValue
static uint64_t adjustFixupValue(const MCFixup &Fixup, uint64_t Value, MCContext &Ctx)
Definition: CSKYAsmBackend.cpp:86
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::CSKY::fixup_csky_pcrel_imm18_scale2
@ fixup_csky_pcrel_imm18_scale2
Definition: CSKYFixupKinds.h:29
llvm::MCRegisterInfo
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Definition: MCRegisterInfo.h:135
llvm::CSKYAsmBackend::fixupNeedsRelaxationAdvanced
bool fixupNeedsRelaxationAdvanced(const MCFixup &Fixup, bool Resolved, uint64_t Value, const MCRelaxableFragment *DF, const MCAsmLayout &Layout, const bool WasForced) const override
Target specific predicate for whether a given fixup requires the associated instruction to be relaxed...
Definition: CSKYAsmBackend.cpp:174
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
MCAsmLayout.h
llvm::createCSKYELFObjectWriter
std::unique_ptr< MCObjectTargetWriter > createCSKYELFObjectWriter()
Definition: CSKYELFObjectWriter.cpp:147
MCObjectWriter.h
llvm::CSKY::NumTargetFixupKinds
@ NumTargetFixupKinds
Definition: CSKYFixupKinds.h:56
llvm::MCAsmLayout
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
llvm::CSKYAsmBackend::getFixupKindInfo
const MCFixupKindInfo & getFixupKindInfo(MCFixupKind Kind) const override
Get information on a fixup kind.
Definition: CSKYAsmBackend.cpp:29
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::size
unsigned size() const
Definition: DenseMap.h:101
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::MCInst::getOpcode
unsigned getOpcode() const
Definition: MCInst.h:198
llvm::CSKYAsmBackend::fixupNeedsRelaxation
bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value, const MCRelaxableFragment *DF, const MCAsmLayout &Layout) const override
Simple predicate for targets where !Resolved implies requiring relaxation.
Definition: CSKYAsmBackend.cpp:286
llvm::MCFixupKind
MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition: MCFixup.h:21
llvm::FK_Data_8
@ FK_Data_8
A eight-byte fixup.
Definition: MCFixup.h:26
llvm::MCInst::getOperand
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:206
llvm::HexStyle::Asm
@ Asm
0ffh
Definition: MCInstPrinter.h:34
llvm::CSKY::fixup_csky_addr32
@ fixup_csky_addr32
Definition: CSKYFixupKinds.h:17
llvm::MCValue
This represents an "assembler immediate".
Definition: MCValue.h:36
llvm::FK_Data_2
@ FK_Data_2
A two-byte fixup.
Definition: MCFixup.h:24
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:76
llvm::MCFixup
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:71
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
Debug.h