LLVM: lib/Target/LoongArch/MCTargetDesc/LoongArchAsmBackend.cpp Source File

LLVM 22.0.0git
LoongArchAsmBackend.cpp
Go to the documentation of this file.
1//===-- LoongArchAsmBackend.cpp - LoongArch Assembler Backend -*- 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 LoongArchAsmBackend class.
10//
11//===----------------------------------------------------------------------===//
12
13#include "LoongArchAsmBackend.h"
14#include "LoongArchFixupKinds.h"
15#include "llvm/BinaryFormat/ELF.h"
16#include "llvm/MC/MCAsmInfo.h"
17#include "llvm/MC/MCAssembler.h"
18#include "llvm/MC/MCContext.h"
19#include "llvm/MC/MCELFObjectWriter.h"
20#include "llvm/MC/MCExpr.h"
21#include "llvm/MC/MCSection.h"
22#include "llvm/MC/MCValue.h"
23#include "llvm/Support/EndianStream.h"
24#include "llvm/Support/LEB128.h"
25#include "llvm/Support/MathExtras.h"
26
27 #define DEBUG_TYPE "loongarch-asmbackend"
28
29using namespace llvm;
30
32 uint8_t OSABI, bool Is64Bit,
34 : MCAsmBackend(llvm::endianness::little), STI(STI), OSABI(OSABI),
35 Is64Bit(Is64Bit), TargetOptions(Options) {}
36
37std::optional<MCFixupKind>
39 if (STI.getTargetTriple().isOSBinFormatELF()) {
41#define ELF_RELOC(X, Y) .Case(#X, Y)
42#include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
43#undef ELF_RELOC
44 .Case("BFD_RELOC_NONE", ELF::R_LARCH_NONE)
45 .Case("BFD_RELOC_32", ELF::R_LARCH_32)
46 .Case("BFD_RELOC_64", ELF::R_LARCH_64)
47 .Default(-1u);
48 if (Type != -1u)
49 return static_cast<MCFixupKind >(FirstLiteralRelocationKind + Type);
50 }
51 return std::nullopt;
52}
53
55 const static MCFixupKindInfo Infos[] = {
56 // This table *must* be in the order that the fixup_* kinds are defined in
57 // LoongArchFixupKinds.h.
58 //
59 // {name, offset, bits, flags}
60 {"fixup_loongarch_b16", 10, 16, 0},
61 {"fixup_loongarch_b21", 0, 26, 0},
62 {"fixup_loongarch_b26", 0, 26, 0},
63 {"fixup_loongarch_abs_hi20", 5, 20, 0},
64 {"fixup_loongarch_abs_lo12", 10, 12, 0},
65 {"fixup_loongarch_abs64_lo20", 5, 20, 0},
66 {"fixup_loongarch_abs64_hi12", 10, 12, 0},
67 };
68
69 static_assert((std::size(Infos)) == LoongArch::NumTargetFixupKinds,
70 "Not all fixup kinds added to Infos array");
71
72 // Fixup kinds from .reloc directive are like R_LARCH_NONE. They
73 // do not require any extra processing.
74 if (mc::isRelocation(Kind))
75 return {};
76
77 if (Kind < FirstTargetFixupKind)
79
80 assert(unsigned(Kind - FirstTargetFixupKind) <
82 "Invalid kind!");
83 return Infos[Kind - FirstTargetFixupKind];
84}
85
86 static void reportOutOfRangeError(MCContext &Ctx, SMLoc Loc, unsigned N) {
87 Ctx.reportError(Loc, "fixup value out of range [" + Twine(llvm::minIntN(N)) +
88 ", " + Twine(llvm::maxIntN(N)) + "]");
89}
90
92 MCContext &Ctx) {
93 switch (Fixup.getKind()) {
94 default:
95 llvm_unreachable("Unknown fixup kind");
96 case FK_Data_1:
97 case FK_Data_2:
98 case FK_Data_4:
99 case FK_Data_8:
100 case FK_Data_leb128:
101 return Value;
103 if (!isInt<18>(Value))
104 reportOutOfRangeError(Ctx, Fixup.getLoc(), 18);
105 if (Value % 4)
106 Ctx.reportError(Fixup.getLoc(), "fixup value must be 4-byte aligned");
107 return (Value >> 2) & 0xffff;
108 }
110 if (!isInt<23>(Value))
111 reportOutOfRangeError(Ctx, Fixup.getLoc(), 23);
112 if (Value % 4)
113 Ctx.reportError(Fixup.getLoc(), "fixup value must be 4-byte aligned");
114 return ((Value & 0x3fffc) << 8) | ((Value >> 18) & 0x1f);
115 }
117 if (!isInt<28>(Value))
118 reportOutOfRangeError(Ctx, Fixup.getLoc(), 28);
119 if (Value % 4)
120 Ctx.reportError(Fixup.getLoc(), "fixup value must be 4-byte aligned");
121 return ((Value & 0x3fffc) << 8) | ((Value >> 18) & 0x3ff);
122 }
124 return (Value >> 12) & 0xfffff;
126 return Value & 0xfff;
128 return (Value >> 32) & 0xfffff;
130 return (Value >> 52) & 0xfff;
131 }
132}
133
134 static void fixupLeb128(MCContext &Ctx, const MCFixup &Fixup, uint8_t *Data,
135 uint64_t Value) {
136 unsigned I;
137 for (I = 0; Value; ++I, Value >>= 7)
138 Data[I] |= uint8_t(Value & 0x7f);
139 if (Value)
140 Ctx.reportError(Fixup.getLoc(), "Invalid uleb128 value!");
141}
142
144 const MCValue &Target, uint8_t *Data,
145 uint64_t Value, bool IsResolved) {
146 IsResolved = addReloc(F, Fixup, Target, Value, IsResolved);
147 if (!Value)
148 return; // Doesn't change encoding.
149
150 auto Kind = Fixup.getKind();
151 if (mc::isRelocation(Kind))
152 return;
154 MCContext &Ctx = getContext();
155
156 // Fixup leb128 separately.
157 if (Fixup.getKind() == FK_Data_leb128)
158 return fixupLeb128(Ctx, Fixup, Data, Value);
159
160 // Apply any target-specific value adjustments.
162
163 // Shift the value into position.
164 Value <<= Info.TargetOffset;
165
166 unsigned NumBytes = alignTo(Info.TargetSize + Info.TargetOffset, 8) / 8;
167
168 assert(Fixup.getOffset() + NumBytes <= F.getSize() &&
169 "Invalid fixup offset!");
170 // For each byte of the fragment that the fixup touches, mask in the
171 // bits from the fixup value.
172 for (unsigned I = 0; I != NumBytes; ++I) {
173 Data[I] |= uint8_t((Value >> (I * 8)) & 0xff);
174 }
175}
176
177static inline std::pair<MCFixupKind, MCFixupKind>
179 switch (Size) {
180 default:
181 llvm_unreachable("unsupported fixup size");
182 case 6:
183 return std::make_pair(ELF::R_LARCH_ADD6, ELF::R_LARCH_SUB6);
184 case 8:
185 return std::make_pair(ELF::R_LARCH_ADD8, ELF::R_LARCH_SUB8);
186 case 16:
187 return std::make_pair(ELF::R_LARCH_ADD16, ELF::R_LARCH_SUB16);
188 case 32:
189 return std::make_pair(ELF::R_LARCH_ADD32, ELF::R_LARCH_SUB32);
190 case 64:
191 return std::make_pair(ELF::R_LARCH_ADD64, ELF::R_LARCH_SUB64);
192 case 128:
193 return std::make_pair(ELF::R_LARCH_ADD_ULEB128, ELF::R_LARCH_SUB_ULEB128);
194 }
195}
196
197// Check if an R_LARCH_ALIGN relocation is needed for an alignment directive.
198// If conditions are met, compute the padding size and create a fixup encoding
199// the padding size in the addend. If MaxBytesToEmit is smaller than the padding
200// size, the fixup encodes MaxBytesToEmit in the higher bits and references a
201// per-section marker symbol.
203 // Alignments before the first linker-relaxable instruction have fixed sizes
204 // and do not require relocations. Alignments after a linker-relaxable
205 // instruction require a relocation, even if the STI specifies norelax.
206 //
207 // firstLinkerRelaxable is the layout order within the subsection, which may
208 // be smaller than the section's order. Therefore, alignments in a
209 // lower-numbered subsection may be unnecessarily treated as linker-relaxable.
210 auto *Sec = F.getParent();
211 if (F.getLayoutOrder() <= Sec->firstLinkerRelaxable())
212 return false;
213
214 // Use default handling unless linker relaxation is enabled and the
215 // MaxBytesToEmit >= the nop size.
216 const unsigned MinNopLen = 4;
217 unsigned MaxBytesToEmit = F.getAlignMaxBytesToEmit();
218 if (MaxBytesToEmit < MinNopLen)
219 return false;
220
221 Size = F.getAlignment().value() - MinNopLen;
222 if (F.getAlignment() <= MinNopLen)
223 return false;
224
225 MCContext &Ctx = getContext();
226 const MCExpr *Expr = nullptr;
227 if (MaxBytesToEmit >= Size) {
229 } else {
230 MCSection *Sec = F.getParent();
231 const MCSymbolRefExpr *SymRef = getSecToAlignSym()[Sec];
232 if (SymRef == nullptr) {
233 // Define a marker symbol at the section with an offset of 0.
234 MCSymbol *Sym = Ctx.createNamedTempSymbol("la-relax-align");
235 Sym->setFragment(&*Sec->getBeginSymbol()->getFragment());
236 Asm->registerSymbol(*Sym);
237 SymRef = MCSymbolRefExpr::create(Sym, Ctx);
238 getSecToAlignSym()[Sec] = SymRef;
239 }
241 SymRef,
242 MCConstantExpr::create((MaxBytesToEmit << 8) | Log2(F.getAlignment()),
243 Ctx),
244 Ctx);
245 }
246 MCFixup Fixup =
247 MCFixup::create(0, Expr, FirstLiteralRelocationKind + ELF::R_LARCH_ALIGN);
248 F.setVarFixups({Fixup});
249 F.setLinkerRelaxable();
250 return true;
251}
252
254 int64_t &Value) const {
255 const MCExpr &Expr = F.getLEBValue();
256 if (F.isLEBSigned() || !Expr.evaluateKnownAbsolute(Value, *Asm))
257 return std::make_pair(false, false);
258 F.setVarFixups({MCFixup::create(0, &Expr, FK_Data_leb128)});
259 return std::make_pair(true, true);
260}
261
264 int64_t LineDelta = F.getDwarfLineDelta();
265 const MCExpr &AddrDelta = F.getDwarfAddrDelta();
266 int64_t Value;
267 if (AddrDelta.evaluateAsAbsolute(Value, *Asm))
268 return false;
269 [[maybe_unused]] bool IsAbsolute =
270 AddrDelta.evaluateKnownAbsolute(Value, *Asm);
271 assert(IsAbsolute);
272
275
276 // INT64_MAX is a signal that this is actually a DW_LNE_end_sequence.
277 if (LineDelta != INT64_MAX) {
278 OS << uint8_t(dwarf::DW_LNS_advance_line);
279 encodeSLEB128(LineDelta, OS);
280 }
281
282 // According to the DWARF specification, the `DW_LNS_fixed_advance_pc` opcode
283 // takes a single unsigned half (unencoded) operand. The maximum encodable
284 // value is therefore 65535. Set a conservative upper bound for relaxation.
285 unsigned PCBytes;
286 if (Value > 60000) {
287 unsigned PtrSize = C.getAsmInfo()->getCodePointerSize();
288 assert((PtrSize == 4 || PtrSize == 8) && "Unexpected pointer size");
289 PCBytes = PtrSize;
290 OS << uint8_t(dwarf::DW_LNS_extended_op) << uint8_t(PtrSize + 1)
291 << uint8_t(dwarf::DW_LNE_set_address);
292 OS.write_zeros(PtrSize);
293 } else {
294 PCBytes = 2;
295 OS << uint8_t(dwarf::DW_LNS_fixed_advance_pc);
297 }
298 auto Offset = OS.tell() - PCBytes;
299
300 if (LineDelta == INT64_MAX) {
301 OS << uint8_t(dwarf::DW_LNS_extended_op);
302 OS << uint8_t(1);
303 OS << uint8_t(dwarf::DW_LNE_end_sequence);
304 } else {
305 OS << uint8_t(dwarf::DW_LNS_copy);
306 }
307
308 F.setVarContents(Data);
309 F.setVarFixups({MCFixup::create(Offset, &AddrDelta,
310 MCFixup::getDataKindForSize(PCBytes))});
311 return true;
312}
313
315 const MCExpr &AddrDelta = F.getDwarfAddrDelta();
317 int64_t Value;
318 if (AddrDelta.evaluateAsAbsolute(Value, *Asm))
319 return false;
320 bool IsAbsolute = AddrDelta.evaluateKnownAbsolute(Value, *Asm);
321 assert(IsAbsolute && "CFA with invalid expression");
322 (void)IsAbsolute;
323
324 assert(getContext().getAsmInfo()->getMinInstAlignment() == 1 &&
325 "expected 1-byte alignment");
326 if (Value == 0) {
327 F.clearVarContents();
328 F.clearVarFixups();
329 return true;
330 }
331
332 auto AddFixups = [&Fixups,
333 &AddrDelta](unsigned Offset,
334 std::pair<MCFixupKind, MCFixupKind> FK) {
335 const MCBinaryExpr &MBE = cast<MCBinaryExpr>(AddrDelta);
336 Fixups.push_back(MCFixup::create(Offset, MBE.getLHS(), std::get<0>(FK)));
337 Fixups.push_back(MCFixup::create(Offset, MBE.getRHS(), std::get<1>(FK)));
338 };
339
342 if (isUIntN(6, Value)) {
343 OS << uint8_t(dwarf::DW_CFA_advance_loc);
344 AddFixups(0, getRelocPairForSize(6));
345 } else if (isUInt<8>(Value)) {
346 OS << uint8_t(dwarf::DW_CFA_advance_loc1);
348 AddFixups(1, getRelocPairForSize(8));
349 } else if (isUInt<16>(Value)) {
350 OS << uint8_t(dwarf::DW_CFA_advance_loc2);
352 AddFixups(1, getRelocPairForSize(16));
353 } else if (isUInt<32>(Value)) {
354 OS << uint8_t(dwarf::DW_CFA_advance_loc4);
356 AddFixups(1, getRelocPairForSize(32));
357 } else {
358 llvm_unreachable("unsupported CFA encoding");
359 }
360 F.setVarContents(Data);
361 F.setVarFixups(Fixups);
362 return true;
363}
364
366 const MCSubtargetInfo *STI) const {
367 // We mostly follow binutils' convention here: align to 4-byte boundary with a
368 // 0-fill padding.
369 OS.write_zeros(Count % 4);
370
371 // The remainder is now padded with 4-byte nops.
372 // nop: andi r0, r0, 0
373 for (; Count >= 4; Count -= 4)
374 OS.write("0円0円\x40\x03", 4);
375
376 return true;
377}
378
379bool LoongArchAsmBackend::isPCRelFixupResolved(const MCSymbol *SymA,
380 const MCFragment &F) {
381 // If the section does not contain linker-relaxable fragments, PC-relative
382 // fixups can be resolved.
383 if (!F.getParent()->isLinkerRelaxable())
384 return true;
385
386 // Otherwise, check if the offset between the symbol and fragment is fully
387 // resolved, unaffected by linker-relaxable fragments (e.g. instructions or
388 // offset-affected FT_Align fragments). Complements the generic
389 // isSymbolRefDifferenceFullyResolvedImpl.
390 if (!PCRelTemp)
391 PCRelTemp = getContext().createTempSymbol();
392 PCRelTemp->setFragment(const_cast<MCFragment *>(&F));
393 MCValue Res;
394 MCExpr::evaluateSymbolicAdd(Asm, false, MCValue::get(SymA),
395 MCValue::get(nullptr, PCRelTemp), Res);
396 return !Res.getSubSym();
397}
398
400 const MCValue &Target, uint64_t &FixedValue,
401 bool IsResolved) {
402 auto Fallback = [&]() {
403 MCAsmBackend::maybeAddReloc(F, Fixup, Target, FixedValue, IsResolved);
404 return true;
405 };
406 uint64_t FixedValueA, FixedValueB;
407 if (Target.getSubSym()) {
408 assert(Target.getSpecifier() == 0 &&
409 "relocatable SymA-SymB cannot have relocation specifier");
410 std::pair<MCFixupKind, MCFixupKind> FK;
411 const MCSymbol &SA = *Target.getAddSym();
412 const MCSymbol &SB = *Target.getSubSym();
413
414 bool force = !SA.isInSection() || !SB.isInSection();
415 if (!force) {
416 const MCSection &SecA = SA.getSection();
417 const MCSection &SecB = SB.getSection();
418 const MCSection &SecCur = *F.getParent();
419
420 // To handle the case of A - B which B is same section with the current,
421 // generate PCRel relocations is better than ADD/SUB relocation pair.
422 // We can resolve it as A - PC + PC - B. The A - PC will be resolved
423 // as a PCRel relocation, while PC - B will serve as the addend.
424 // If the linker relaxation is disabled, it can be done directly since
425 // PC - B is constant. Otherwise, we should evaluate whether PC - B
426 // is constant. If it can be resolved as PCRel, use Fallback which
427 // generates R_LARCH_{32,64}_PCREL relocation later.
428 if (&SecA != &SecB && &SecB == &SecCur &&
429 isPCRelFixupResolved(Target.getSubSym(), F))
430 return Fallback();
431
432 // In SecA == SecB case. If the section is not linker-relaxable, the
433 // FixedValue has already been calculated out in evaluateFixup,
434 // return true and avoid record relocations.
435 if (&SecA == &SecB && !SecA.isLinkerRelaxable())
436 return true;
437 }
438
439 switch (Fixup.getKind()) {
440 case llvm::FK_Data_1:
441 FK = getRelocPairForSize(8);
442 break;
443 case llvm::FK_Data_2:
444 FK = getRelocPairForSize(16);
445 break;
446 case llvm::FK_Data_4:
447 FK = getRelocPairForSize(32);
448 break;
449 case llvm::FK_Data_8:
450 FK = getRelocPairForSize(64);
451 break;
453 FK = getRelocPairForSize(128);
454 break;
455 default:
456 llvm_unreachable("unsupported fixup size");
457 }
458 MCValue A = MCValue::get(Target.getAddSym(), nullptr, Target.getConstant());
459 MCValue B = MCValue::get(Target.getSubSym());
460 auto FA = MCFixup::create(Fixup.getOffset(), nullptr, std::get<0>(FK));
461 auto FB = MCFixup::create(Fixup.getOffset(), nullptr, std::get<1>(FK));
462 Asm->getWriter().recordRelocation(F, FA, A, FixedValueA);
463 Asm->getWriter().recordRelocation(F, FB, B, FixedValueB);
464 FixedValue = FixedValueA - FixedValueB;
465 return false;
466 }
467
468 // If linker relaxation is enabled and supported by the current relocation,
469 // generate a relocation and then append a RELAX.
470 if (Fixup.isLinkerRelaxable())
471 IsResolved = false;
472 if (IsResolved && Fixup.isPCRel())
473 IsResolved = isPCRelFixupResolved(Target.getAddSym(), F);
474
475 if (!IsResolved)
476 Asm->getWriter().recordRelocation(F, Fixup, Target, FixedValue);
477
478 if (Fixup.isLinkerRelaxable()) {
479 auto FA = MCFixup::create(Fixup.getOffset(), nullptr, ELF::R_LARCH_RELAX);
480 Asm->getWriter().recordRelocation(F, FA, MCValue::get(nullptr),
481 FixedValueA);
482 }
483
484 return true;
485}
486
487std::unique_ptr<MCObjectTargetWriter>
491
493 const MCSubtargetInfo &STI,
494 const MCRegisterInfo &MRI,
495 const MCTargetOptions &Options) {
496 const Triple &TT = STI.getTargetTriple();
497 uint8_t OSABI = MCELFObjectTargetWriter::getOSABI(TT.getOS());
498 return new LoongArchAsmBackend(STI, OSABI, TT.isArch64Bit(), Options);
499}
unsigned const MachineRegisterInfo * MRI
static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target, uint64_t Value, MCContext &Ctx, const Triple &TheTriple, bool IsResolved)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
A
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static LVOptions Options
Definition LVOptions.cpp:25
static std::pair< MCFixupKind, MCFixupKind > getRelocPairForSize(unsigned Size)
static void fixupLeb128(MCContext &Ctx, const MCFixup &Fixup, uint8_t *Data, uint64_t Value)
static void reportOutOfRangeError(MCContext &Ctx, SMLoc Loc, unsigned N)
F
#define F(x, y, z)
Definition MD5.cpp:55
I
#define I(x, y, z)
Definition MD5.cpp:58
T
#define T
PowerPC TLS Dynamic Call Fixup
@ Fallback
bool relaxDwarfCFA(MCFragment &) const override
std::unique_ptr< MCObjectTargetWriter > createObjectTargetWriter() const override
bool addReloc(const MCFragment &, const MCFixup &, const MCValue &, uint64_t &FixedValue, bool IsResolved)
std::optional< MCFixupKind > getFixupKind(StringRef Name) const override
Map a relocation name used in .reloc to a fixup kind.
DenseMap< MCSection *, const MCSymbolRefExpr * > & getSecToAlignSym()
bool relaxDwarfLineAddr(MCFragment &) const override
LoongArchAsmBackend(const MCSubtargetInfo &STI, uint8_t OSABI, bool Is64Bit, const MCTargetOptions &Options)
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.
void applyFixup(const MCFragment &, const MCFixup &, const MCValue &Target, uint8_t *Data, uint64_t Value, bool IsResolved) override
bool relaxAlign(MCFragment &F, unsigned &Size) override
std::pair< bool, bool > relaxLEB128(MCFragment &F, int64_t &Value) const override
MCFixupKindInfo getFixupKindInfo(MCFixupKind Kind) const override
Get information on a fixup kind.
Generic interface to target specific assembler backends.
Definition MCAsmBackend.h:55
MCAsmBackend(llvm::endianness Endian)
Definition MCAsmBackend.h:57
virtual MCFixupKindInfo getFixupKindInfo(MCFixupKind Kind) const
Get information on a fixup kind.
MCAssembler * Asm
Definition MCAsmBackend.h:59
MCContext & getContext() const
void maybeAddReloc(const MCFragment &, const MCFixup &, const MCValue &, uint64_t &Value, bool IsResolved)
Binary assembler expressions.
Definition MCExpr.h:299
const MCExpr * getLHS() const
Get the left-hand side expression of the binary operator.
Definition MCExpr.h:446
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.h:343
const MCExpr * getRHS() const
Get the right-hand side expression of the binary operator.
Definition MCExpr.h:449
static LLVM_ABI const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition MCExpr.cpp:212
Context object for machine code objects.
Definition MCContext.h:83
LLVM_ABI MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition MCContext.cpp:393
Base class for the full range of assembler expressions which are needed for parsing.
Definition MCExpr.h:34
static LLVM_ABI bool evaluateSymbolicAdd(const MCAssembler *, bool, const MCValue &, const MCValue &, MCValue &)
Definition MCExpr.cpp:407
LLVM_ABI bool evaluateKnownAbsolute(int64_t &Res, const MCAssembler &Asm) const
Aggressive variant of evaluateAsRelocatable when relocations are unavailable (e.g.
Definition MCExpr.cpp:250
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition MCFixup.h:61
static MCFixupKind getDataKindForSize(unsigned Size)
Return the generic fixup kind for a value with the given size.
Definition MCFixup.h:110
static MCFixup create(uint32_t Offset, const MCExpr *Value, MCFixupKind Kind, bool PCRel=false)
Consider bit fields if we need more flags.
Definition MCFixup.h:86
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition MCSection.h:521
bool isLinkerRelaxable() const
Definition MCSection.h:623
MCSymbol * getBeginSymbol()
Definition MCSection.h:593
Generic base class for all target subtargets.
const Triple & getTargetTriple() const
Represent a reference to a symbol from inside an expression.
Definition MCExpr.h:190
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition MCExpr.h:214
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute).
Definition MCSymbol.h:237
void setFragment(MCFragment *F) const
Mark the symbol as defined in the fragment F.
Definition MCSymbol.h:257
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition MCSymbol.h:251
MCFragment * getFragment() const
Definition MCSymbol.h:346
static MCValue get(const MCSymbol *SymA, const MCSymbol *SymB=nullptr, int64_t Val=0, uint32_t Specifier=0)
Definition MCValue.h:56
const MCSymbol * getSubSym() const
Definition MCValue.h:51
Represents a location in source code.
Definition SMLoc.h:23
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1203
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
A switch()-like statement whose cases are string literals.
Definition StringSwitch.h:46
StringSwitch & Case(StringLiteral S, T Value)
Definition StringSwitch.h:68
R Default(T Value)
Definition StringSwitch.h:198
Target - Wrapper for Target specific information.
Triple - Helper class for working with autoconf configuration names.
Definition Triple.h:47
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
LLVM Value Representation.
Definition Value.h:75
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
raw_ostream & write_zeros(unsigned NumZeros)
write_zeros - Insert 'NumZeros' nulls.
uint64_t tell() const
tell - Return the current offset with the file.
Definition raw_ostream.h:148
raw_ostream & write(unsigned char C)
A raw_ostream that writes to an SmallVector or SmallString.
Definition raw_ostream.h:692
#define INT64_MAX
Definition DataTypes.h:71
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition CallingConv.h:34
bool isRelocation(MCFixupKind FixupKind)
Definition MCFixup.h:130
void write(void *memory, value_type value, endianness endian)
Write a value to memory with a particular endianness.
Definition Endian.h:96
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
@ Offset
Definition DWP.cpp:477
std::unique_ptr< MCObjectTargetWriter > createLoongArchELFObjectWriter(uint8_t OSABI, bool Is64Bit)
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
Definition MathExtras.h:165
constexpr int64_t minIntN(int64_t N)
Gets the minimum value for a N-bit signed integer.
Definition MathExtras.h:223
constexpr bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
Definition MathExtras.h:243
uint16_t MCFixupKind
Extensible enumeration to represent the type of a fixup.
Definition MCFixup.h:22
MCAsmBackend * createLoongArchAsmBackend(const Target &T, const MCSubtargetInfo &STI, const MCRegisterInfo &MRI, const MCTargetOptions &Options)
FunctionAddr VTableAddr Count
Definition InstrProf.h:139
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
Definition MathExtras.h:189
@ FirstTargetFixupKind
Definition MCFixup.h:44
@ FirstLiteralRelocationKind
Definition MCFixup.h:29
@ FK_Data_8
A eight-byte fixup.
Definition MCFixup.h:37
@ FK_Data_1
A one-byte fixup.
Definition MCFixup.h:34
@ FK_Data_4
A four-byte fixup.
Definition MCFixup.h:36
@ FK_Data_leb128
A leb128 fixup.
Definition MCFixup.h:38
@ FK_Data_2
A two-byte fixup.
Definition MCFixup.h:35
FunctionAddr VTableAddr uintptr_t uintptr_t Data
Definition InstrProf.h:189
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition Alignment.h:144
constexpr int64_t maxIntN(int64_t N)
Gets the maximum value for a N-bit signed integer.
Definition MathExtras.h:232
unsigned encodeSLEB128(int64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a SLEB128 value to an output stream.
Definition LEB128.h:24
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
unsigned Log2(Align A)
Returns the log2 of the alignment.
Definition Alignment.h:197
endianness
Definition bit.h:71
N
#define N
Target independent information on a fixup kind.
Definition MCAsmBackend.h:38
Generated on for LLVM by doxygen 1.14.0

AltStyle によって変換されたページ (->オリジナル) /