LLVM  10.0.0svn
X86MachObjectWriter.cpp
Go to the documentation of this file.
1 //===-- X86MachObjectWriter.cpp - X86 Mach-O Writer -----------------------===//
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 
11 #include "llvm/ADT/Twine.h"
13 #include "llvm/MC/MCAsmInfo.h"
14 #include "llvm/MC/MCAsmLayout.h"
15 #include "llvm/MC/MCAssembler.h"
16 #include "llvm/MC/MCContext.h"
18 #include "llvm/MC/MCSectionMachO.h"
19 #include "llvm/MC/MCValue.h"
21 #include "llvm/Support/Format.h"
22 
23 using namespace llvm;
24 
25 namespace {
26 class X86MachObjectWriter : public MCMachObjectTargetWriter {
27  bool recordScatteredRelocation(MachObjectWriter *Writer,
28  const MCAssembler &Asm,
29  const MCAsmLayout &Layout,
30  const MCFragment *Fragment,
31  const MCFixup &Fixup,
33  unsigned Log2Size,
34  uint64_t &FixedValue);
35  void recordTLVPRelocation(MachObjectWriter *Writer,
36  const MCAssembler &Asm,
37  const MCAsmLayout &Layout,
38  const MCFragment *Fragment,
39  const MCFixup &Fixup,
41  uint64_t &FixedValue);
42 
43  void RecordX86Relocation(MachObjectWriter *Writer,
44  const MCAssembler &Asm,
45  const MCAsmLayout &Layout,
46  const MCFragment *Fragment,
47  const MCFixup &Fixup,
49  uint64_t &FixedValue);
50  void RecordX86_64Relocation(MachObjectWriter *Writer, MCAssembler &Asm,
51  const MCAsmLayout &Layout,
52  const MCFragment *Fragment, const MCFixup &Fixup,
53  MCValue Target, uint64_t &FixedValue);
54 
55 public:
56  X86MachObjectWriter(bool Is64Bit, uint32_t CPUType, uint32_t CPUSubtype)
57  : MCMachObjectTargetWriter(Is64Bit, CPUType, CPUSubtype) {}
58 
59  void recordRelocation(MachObjectWriter *Writer, MCAssembler &Asm,
60  const MCAsmLayout &Layout, const MCFragment *Fragment,
61  const MCFixup &Fixup, MCValue Target,
62  uint64_t &FixedValue) override {
63  if (Writer->is64Bit())
64  RecordX86_64Relocation(Writer, Asm, Layout, Fragment, Fixup, Target,
65  FixedValue);
66  else
67  RecordX86Relocation(Writer, Asm, Layout, Fragment, Fixup, Target,
68  FixedValue);
69  }
70 };
71 }
72 
73 static bool isFixupKindRIPRel(unsigned Kind) {
74  return Kind == X86::reloc_riprel_4byte ||
78 }
79 
80 static unsigned getFixupKindLog2Size(unsigned Kind) {
81  switch (Kind) {
82  default:
83  llvm_unreachable("invalid fixup kind!");
84  case FK_PCRel_1:
85  case FK_Data_1: return 0;
86  case FK_PCRel_2:
87  case FK_Data_2: return 1;
88  case FK_PCRel_4:
89  // FIXME: Remove these!!!
97  case FK_Data_4: return 2;
98  case FK_Data_8: return 3;
99  }
100 }
101 
102 void X86MachObjectWriter::RecordX86_64Relocation(
103  MachObjectWriter *Writer, MCAssembler &Asm, const MCAsmLayout &Layout,
104  const MCFragment *Fragment, const MCFixup &Fixup, MCValue Target,
105  uint64_t &FixedValue) {
106  unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
107  unsigned IsRIPRel = isFixupKindRIPRel(Fixup.getKind());
108  unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
109 
110  // See <reloc.h>.
111  uint32_t FixupOffset =
112  Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
113  uint32_t FixupAddress =
114  Writer->getFragmentAddress(Fragment, Layout) + Fixup.getOffset();
115  int64_t Value = 0;
116  unsigned Index = 0;
117  unsigned IsExtern = 0;
118  unsigned Type = 0;
119  const MCSymbol *RelSymbol = nullptr;
120 
121  Value = Target.getConstant();
122 
123  if (IsPCRel) {
124  // Compensate for the relocation offset, Darwin x86_64 relocations only have
125  // the addend and appear to have attempted to define it to be the actual
126  // expression addend without the PCrel bias. However, instructions with data
127  // following the relocation are not accommodated for (see comment below
128  // regarding SIGNED{1,2,4}), so it isn't exactly that either.
129  Value += 1LL << Log2Size;
130  }
131 
132  if (Target.isAbsolute()) { // constant
133  // SymbolNum of 0 indicates the absolute section.
135 
136  // FIXME: I believe this is broken, I don't think the linker can understand
137  // it. I think it would require a local relocation, but I'm not sure if that
138  // would work either. The official way to get an absolute PCrel relocation
139  // is to use an absolute symbol (which we don't support yet).
140  if (IsPCRel) {
141  IsExtern = 1;
143  }
144  } else if (Target.getSymB()) { // A - B + constant
145  const MCSymbol *A = &Target.getSymA()->getSymbol();
146  if (A->isTemporary())
147  A = &Writer->findAliasedSymbol(*A);
148  const MCSymbol *A_Base = Asm.getAtom(*A);
149 
150  const MCSymbol *B = &Target.getSymB()->getSymbol();
151  if (B->isTemporary())
152  B = &Writer->findAliasedSymbol(*B);
153  const MCSymbol *B_Base = Asm.getAtom(*B);
154 
155  // Neither symbol can be modified.
156  if (Target.getSymA()->getKind() != MCSymbolRefExpr::VK_None) {
157  Asm.getContext().reportError(Fixup.getLoc(),
158  "unsupported relocation of modified symbol");
159  return;
160  }
161 
162  // We don't support PCrel relocations of differences. Darwin 'as' doesn't
163  // implement most of these correctly.
164  if (IsPCRel) {
165  Asm.getContext().reportError(
166  Fixup.getLoc(), "unsupported pc-relative relocation of difference");
167  return;
168  }
169 
170  // The support for the situation where one or both of the symbols would
171  // require a local relocation is handled just like if the symbols were
172  // external. This is certainly used in the case of debug sections where the
173  // section has only temporary symbols and thus the symbols don't have base
174  // symbols. This is encoded using the section ordinal and non-extern
175  // relocation entries.
176 
177  // Darwin 'as' doesn't emit correct relocations for this (it ends up with a
178  // single SIGNED relocation); reject it for now. Except the case where both
179  // symbols don't have a base, equal but both NULL.
180  if (A_Base == B_Base && A_Base) {
181  Asm.getContext().reportError(
182  Fixup.getLoc(), "unsupported relocation with identical base");
183  return;
184  }
185 
186  // A subtraction expression where either symbol is undefined is a
187  // non-relocatable expression.
188  if (A->isUndefined() || B->isUndefined()) {
189  StringRef Name = A->isUndefined() ? A->getName() : B->getName();
190  Asm.getContext().reportError(Fixup.getLoc(),
191  "unsupported relocation with subtraction expression, symbol '" +
192  Name + "' can not be undefined in a subtraction expression");
193  return;
194  }
195 
196  Value += Writer->getSymbolAddress(*A, Layout) -
197  (!A_Base ? 0 : Writer->getSymbolAddress(*A_Base, Layout));
198  Value -= Writer->getSymbolAddress(*B, Layout) -
199  (!B_Base ? 0 : Writer->getSymbolAddress(*B_Base, Layout));
200 
201  if (!A_Base)
202  Index = A->getFragment()->getParent()->getOrdinal() + 1;
204 
206  MRE.r_word0 = FixupOffset;
207  MRE.r_word1 =
208  (Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
209  Writer->addRelocation(A_Base, Fragment->getParent(), MRE);
210 
211  if (B_Base)
212  RelSymbol = B_Base;
213  else
214  Index = B->getFragment()->getParent()->getOrdinal() + 1;
216  } else {
217  const MCSymbol *Symbol = &Target.getSymA()->getSymbol();
218  if (Symbol->isTemporary() && Value) {
219  const MCSection &Sec = Symbol->getSection();
221  Symbol->setUsedInReloc();
222  }
223  RelSymbol = Asm.getAtom(*Symbol);
224 
225  // Relocations inside debug sections always use local relocations when
226  // possible. This seems to be done because the debugger doesn't fully
227  // understand x86_64 relocation entries, and expects to find values that
228  // have already been fixed up.
229  if (Symbol->isInSection()) {
230  const MCSectionMachO &Section =
231  static_cast<const MCSectionMachO &>(*Fragment->getParent());
232  if (Section.hasAttribute(MachO::S_ATTR_DEBUG))
233  RelSymbol = nullptr;
234  }
235 
236  // x86_64 almost always uses external relocations, except when there is no
237  // symbol to use as a base address (a local symbol with no preceding
238  // non-local symbol).
239  if (RelSymbol) {
240  // Add the local offset, if needed.
241  if (RelSymbol != Symbol)
242  Value += Layout.getSymbolOffset(*Symbol) -
243  Layout.getSymbolOffset(*RelSymbol);
244  } else if (Symbol->isInSection() && !Symbol->isVariable()) {
245  // The index is the section ordinal (1-based).
246  Index = Symbol->getFragment()->getParent()->getOrdinal() + 1;
247  Value += Writer->getSymbolAddress(*Symbol, Layout);
248 
249  if (IsPCRel)
250  Value -= FixupAddress + (1 << Log2Size);
251  } else if (Symbol->isVariable()) {
252  const MCExpr *Value = Symbol->getVariableValue();
253  int64_t Res;
254  bool isAbs = Value->evaluateAsAbsolute(Res, Layout,
255  Writer->getSectionAddressMap());
256  if (isAbs) {
257  FixedValue = Res;
258  return;
259  } else {
260  Asm.getContext().reportError(Fixup.getLoc(),
261  "unsupported relocation of variable '" +
262  Symbol->getName() + "'");
263  return;
264  }
265  } else {
266  Asm.getContext().reportError(
267  Fixup.getLoc(), "unsupported relocation of undefined symbol '" +
268  Symbol->getName() + "'");
269  return;
270  }
271 
272  MCSymbolRefExpr::VariantKind Modifier = Target.getSymA()->getKind();
273  if (IsPCRel) {
274  if (IsRIPRel) {
275  if (Modifier == MCSymbolRefExpr::VK_GOTPCREL) {
276  // x86_64 distinguishes movq foo@GOTPCREL so that the linker can
277  // rewrite the movq to an leaq at link time if the symbol ends up in
278  // the same linkage unit.
281  else
283  } else if (Modifier == MCSymbolRefExpr::VK_TLVP) {
285  } else if (Modifier != MCSymbolRefExpr::VK_None) {
286  Asm.getContext().reportError(
287  Fixup.getLoc(), "unsupported symbol modifier in relocation");
288  return;
289  } else {
291 
292  // The Darwin x86_64 relocation format has a problem where it cannot
293  // encode an address (L<foo> + <constant>) which is outside the atom
294  // containing L<foo>. Generally, this shouldn't occur but it does
295  // happen when we have a RIPrel instruction with data following the
296  // relocation entry (e.g., movb $012, L0(%rip)). Even with the PCrel
297  // adjustment Darwin x86_64 uses, the offset is still negative and the
298  // linker has no way to recognize this.
299  //
300  // To work around this, Darwin uses several special relocation types
301  // to indicate the offsets. However, the specification or
302  // implementation of these seems to also be incomplete; they should
303  // adjust the addend as well based on the actual encoded instruction
304  // (the additional bias), but instead appear to just look at the final
305  // offset.
306  switch (-(Target.getConstant() + (1LL << Log2Size))) {
307  case 1: Type = MachO::X86_64_RELOC_SIGNED_1; break;
308  case 2: Type = MachO::X86_64_RELOC_SIGNED_2; break;
309  case 4: Type = MachO::X86_64_RELOC_SIGNED_4; break;
310  }
311  }
312  } else {
313  if (Modifier != MCSymbolRefExpr::VK_None) {
314  Asm.getContext().reportError(
315  Fixup.getLoc(),
316  "unsupported symbol modifier in branch relocation");
317  return;
318  }
319 
321  }
322  } else {
323  if (Modifier == MCSymbolRefExpr::VK_GOT) {
325  } else if (Modifier == MCSymbolRefExpr::VK_GOTPCREL) {
326  // GOTPCREL is allowed as a modifier on non-PCrel instructions, in which
327  // case all we do is set the PCrel bit in the relocation entry; this is
328  // used with exception handling, for example. The source is required to
329  // include any necessary offset directly.
331  IsPCRel = 1;
332  } else if (Modifier == MCSymbolRefExpr::VK_TLVP) {
333  Asm.getContext().reportError(
334  Fixup.getLoc(), "TLVP symbol modifier should have been rip-rel");
335  return;
336  } else if (Modifier != MCSymbolRefExpr::VK_None) {
337  Asm.getContext().reportError(
338  Fixup.getLoc(), "unsupported symbol modifier in relocation");
339  return;
340  } else {
342  if (Fixup.getTargetKind() == X86::reloc_signed_4byte) {
343  Asm.getContext().reportError(
344  Fixup.getLoc(),
345  "32-bit absolute addressing is not supported in 64-bit mode");
346  return;
347  }
348  }
349  }
350  }
351 
352  // x86_64 always writes custom values into the fixups.
353  FixedValue = Value;
354 
355  // struct relocation_info (8 bytes)
357  MRE.r_word0 = FixupOffset;
358  MRE.r_word1 = (Index << 0) | (IsPCRel << 24) | (Log2Size << 25) |
359  (IsExtern << 27) | (Type << 28);
360  Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE);
361 }
362 
363 bool X86MachObjectWriter::recordScatteredRelocation(MachObjectWriter *Writer,
364  const MCAssembler &Asm,
365  const MCAsmLayout &Layout,
366  const MCFragment *Fragment,
367  const MCFixup &Fixup,
368  MCValue Target,
369  unsigned Log2Size,
370  uint64_t &FixedValue) {
371  uint64_t OriginalFixedValue = FixedValue;
372  uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
373  unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
375 
376  // See <reloc.h>.
377  const MCSymbol *A = &Target.getSymA()->getSymbol();
378 
379  if (!A->getFragment()) {
380  Asm.getContext().reportError(
381  Fixup.getLoc(),
382  "symbol '" + A->getName() +
383  "' can not be undefined in a subtraction expression");
384  return false;
385  }
386 
387  uint32_t Value = Writer->getSymbolAddress(*A, Layout);
388  uint64_t SecAddr = Writer->getSectionAddress(A->getFragment()->getParent());
389  FixedValue += SecAddr;
390  uint32_t Value2 = 0;
391 
392  if (const MCSymbolRefExpr *B = Target.getSymB()) {
393  const MCSymbol *SB = &B->getSymbol();
394 
395  if (!SB->getFragment()) {
396  Asm.getContext().reportError(
397  Fixup.getLoc(),
398  "symbol '" + SB->getName() +
399  "' can not be undefined in a subtraction expression");
400  return false;
401  }
402 
403  // Select the appropriate difference relocation type.
404  //
405  // Note that there is no longer any semantic difference between these two
406  // relocation types from the linkers point of view, this is done solely for
407  // pedantic compatibility with 'as'.
410  Value2 = Writer->getSymbolAddress(*SB, Layout);
411  FixedValue -= Writer->getSectionAddress(SB->getFragment()->getParent());
412  }
413 
414  // Relocations are written out in reverse order, so the PAIR comes first.
415  if (Type == MachO::GENERIC_RELOC_SECTDIFF ||
417  // If the offset is too large to fit in a scattered relocation,
418  // we're hosed. It's an unfortunate limitation of the MachO format.
419  if (FixupOffset > 0xffffff) {
420  char Buffer[32];
421  format("0x%x", FixupOffset).print(Buffer, sizeof(Buffer));
422  Asm.getContext().reportError(Fixup.getLoc(),
423  Twine("Section too large, can't encode "
424  "r_address (") + Buffer +
425  ") into 24 bits of scattered "
426  "relocation entry.");
427  return false;
428  }
429 
431  MRE.r_word0 = ((0 << 0) | // r_address
432  (MachO::GENERIC_RELOC_PAIR << 24) | // r_type
433  (Log2Size << 28) |
434  (IsPCRel << 30) |
436  MRE.r_word1 = Value2;
437  Writer->addRelocation(nullptr, Fragment->getParent(), MRE);
438  } else {
439  // If the offset is more than 24-bits, it won't fit in a scattered
440  // relocation offset field, so we fall back to using a non-scattered
441  // relocation. This is a bit risky, as if the offset reaches out of
442  // the block and the linker is doing scattered loading on this
443  // symbol, things can go badly.
444  //
445  // Required for 'as' compatibility.
446  if (FixupOffset > 0xffffff) {
447  FixedValue = OriginalFixedValue;
448  return false;
449  }
450  }
451 
453  MRE.r_word0 = ((FixupOffset << 0) |
454  (Type << 24) |
455  (Log2Size << 28) |
456  (IsPCRel << 30) |
458  MRE.r_word1 = Value;
459  Writer->addRelocation(nullptr, Fragment->getParent(), MRE);
460  return true;
461 }
462 
463 void X86MachObjectWriter::recordTLVPRelocation(MachObjectWriter *Writer,
464  const MCAssembler &Asm,
465  const MCAsmLayout &Layout,
466  const MCFragment *Fragment,
467  const MCFixup &Fixup,
468  MCValue Target,
469  uint64_t &FixedValue) {
470  const MCSymbolRefExpr *SymA = Target.getSymA();
471  assert(SymA->getKind() == MCSymbolRefExpr::VK_TLVP && !is64Bit() &&
472  "Should only be called with a 32-bit TLVP relocation!");
473 
474  unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
475  uint32_t Value = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
476  unsigned IsPCRel = 0;
477 
478  // We're only going to have a second symbol in pic mode and it'll be a
479  // subtraction from the picbase. For 32-bit pic the addend is the difference
480  // between the picbase and the next address. For 32-bit static the addend is
481  // zero.
482  if (auto *SymB = Target.getSymB()) {
483  // If this is a subtraction then we're pcrel.
484  uint32_t FixupAddress =
485  Writer->getFragmentAddress(Fragment, Layout) + Fixup.getOffset();
486  IsPCRel = 1;
487  FixedValue = FixupAddress -
488  Writer->getSymbolAddress(SymB->getSymbol(), Layout) +
489  Target.getConstant();
490  FixedValue += 1ULL << Log2Size;
491  } else {
492  FixedValue = 0;
493  }
494 
495  // struct relocation_info (8 bytes)
497  MRE.r_word0 = Value;
498  MRE.r_word1 =
499  (IsPCRel << 24) | (Log2Size << 25) | (MachO::GENERIC_RELOC_TLV << 28);
500  Writer->addRelocation(&SymA->getSymbol(), Fragment->getParent(), MRE);
501 }
502 
503 void X86MachObjectWriter::RecordX86Relocation(MachObjectWriter *Writer,
504  const MCAssembler &Asm,
505  const MCAsmLayout &Layout,
506  const MCFragment *Fragment,
507  const MCFixup &Fixup,
508  MCValue Target,
509  uint64_t &FixedValue) {
510  unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
511  unsigned Log2Size = getFixupKindLog2Size(Fixup.getKind());
512 
513  // If this is a 32-bit TLVP reloc it's handled a bit differently.
514  if (Target.getSymA() &&
515  Target.getSymA()->getKind() == MCSymbolRefExpr::VK_TLVP) {
516  recordTLVPRelocation(Writer, Asm, Layout, Fragment, Fixup, Target,
517  FixedValue);
518  return;
519  }
520 
521  // If this is a difference or a defined symbol plus an offset, then we need a
522  // scattered relocation entry. Differences always require scattered
523  // relocations.
524  if (Target.getSymB()) {
525  recordScatteredRelocation(Writer, Asm, Layout, Fragment, Fixup,
526  Target, Log2Size, FixedValue);
527  return;
528  }
529 
530  // Get the symbol data, if any.
531  const MCSymbol *A = nullptr;
532  if (Target.getSymA())
533  A = &Target.getSymA()->getSymbol();
534 
535  // If this is an internal relocation with an offset, it also needs a scattered
536  // relocation entry.
537  uint32_t Offset = Target.getConstant();
538  if (IsPCRel)
539  Offset += 1 << Log2Size;
540  // Try to record the scattered relocation if needed. Fall back to non
541  // scattered if necessary (see comments in recordScatteredRelocation()
542  // for details).
543  if (Offset && A && !Writer->doesSymbolRequireExternRelocation(*A) &&
544  recordScatteredRelocation(Writer, Asm, Layout, Fragment, Fixup, Target,
545  Log2Size, FixedValue))
546  return;
547 
548  // See <reloc.h>.
549  uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
550  unsigned Index = 0;
551  unsigned Type = 0;
552  const MCSymbol *RelSymbol = nullptr;
553 
554  if (Target.isAbsolute()) { // constant
555  // SymbolNum of 0 indicates the absolute section.
556  //
557  // FIXME: Currently, these are never generated (see code below). I cannot
558  // find a case where they are actually emitted.
560  } else {
561  // Resolve constant variables.
562  if (A->isVariable()) {
563  int64_t Res;
564  if (A->getVariableValue()->evaluateAsAbsolute(
565  Res, Layout, Writer->getSectionAddressMap())) {
566  FixedValue = Res;
567  return;
568  }
569  }
570 
571  // Check whether we need an external or internal relocation.
572  if (Writer->doesSymbolRequireExternRelocation(*A)) {
573  RelSymbol = A;
574  // For external relocations, make sure to offset the fixup value to
575  // compensate for the addend of the symbol address, if it was
576  // undefined. This occurs with weak definitions, for example.
577  if (!A->isUndefined())
578  FixedValue -= Layout.getSymbolOffset(*A);
579  } else {
580  // The index is the section ordinal (1-based).
581  const MCSection &Sec = A->getSection();
582  Index = Sec.getOrdinal() + 1;
583  FixedValue += Writer->getSectionAddress(&Sec);
584  }
585  if (IsPCRel)
586  FixedValue -= Writer->getSectionAddress(Fragment->getParent());
587 
589  }
590 
591  // struct relocation_info (8 bytes)
593  MRE.r_word0 = FixupOffset;
594  MRE.r_word1 =
595  (Index << 0) | (IsPCRel << 24) | (Log2Size << 25) | (Type << 28);
596  Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE);
597 }
598 
599 std::unique_ptr<MCObjectTargetWriter>
601  uint32_t CPUSubtype) {
602  return std::make_unique<X86MachObjectWriter>(Is64Bit, CPUType, CPUSubtype);
603 }
const MCAsmInfo * getAsmInfo() const
Definition: MCContext.h:318
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
const MCSymbol & findAliasedSymbol(const MCSymbol &Sym) const
uint64_t getSymbolAddress(const MCSymbol &S, const MCAsmLayout &Layout) const
bool hasAttribute(unsigned Value) const
void setUsedInReloc() const
Definition: MCSymbol.h:214
This represents a section on a Mach-O system (used by Mac OS X).
bool doesSymbolRequireExternRelocation(const MCSymbol &S)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:297
This represents an "assembler immediate".
Definition: MCValue.h:39
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
VariantKind getKind() const
Definition: MCExpr.h:342
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
std::unique_ptr< MCObjectTargetWriter > createX86MachObjectWriter(bool Is64Bit, uint32_t CPUType, uint32_t CPUSubtype)
Construct an X86 Mach-O object writer.
bool isAbsolute() const
Is this an absolute (as opposed to relocatable) value.
Definition: MCValue.h:52
static bool isFixupKindRIPRel(unsigned Kind)
unsigned getOrdinal() const
Definition: MCSection.h:124
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition: MCFixup.h:77
A one-byte pc relative fixup.
Definition: MCFixup.h:29
MCContext & getContext() const
Definition: MCAssembler.h:284
int64_t getConstant() const
Definition: MCValue.h:46
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:48
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
Encapsulates the layout of an assembly file at a particular point in time.
Definition: MCAsmLayout.h:28
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
bool isInSection() const
isInSection - Check if this symbol is defined in some section (i.e., it is defined but not absolute)...
Definition: MCSymbol.h:253
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:169
A four-byte fixup.
Definition: MCFixup.h:26
bool isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind)
void addRelocation(const MCSymbol *RelSymbol, const MCSection *Sec, MachO::any_relocation_info &MRE)
SectionAddrMap & getSectionAddressMap()
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
static bool is64Bit(const char *name)
bool getSymbolOffset(const MCSymbol &S, uint64_t &Val) const
Get the offset of the given symbol, as computed in the current layout.
Definition: MCFragment.cpp:129
virtual bool isSectionAtomizableBySymbols(const MCSection &Section) const
True if the section is atomized using the symbols in it.
Definition: MCAsmInfo.cpp:77
const MCSymbol * getAtom(const MCSymbol &S) const
Find the symbol which defines the atom containing the given symbol, or null if there is no such symbo...
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition: MCSymbol.h:221
const MCSymbolRefExpr * getSymA() const
Definition: MCValue.h:47
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:687
uint32_t getOffset() const
Definition: MCFixup.h:130
bool isExternal() const
Definition: MCSymbol.h:405
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
A one-byte fixup.
Definition: MCFixup.h:24
uint64_t getFragmentOffset(const MCFragment *F) const
Get the offset of the given fragment inside its containing section.
Definition: MCFragment.cpp:77
PowerPC TLS Dynamic Call Fixup
SMLoc getLoc() const
Definition: MCFixup.h:197
static unsigned getFixupKindLog2Size(unsigned Kind)
A two-byte pc relative fixup.
Definition: MCFixup.h:30
uint64_t getFragmentAddress(const MCFragment *Fragment, const MCAsmLayout &Layout) const
A four-byte pc relative fixup.
Definition: MCFixup.h:31
const MCSymbol & getSymbol() const
Definition: MCExpr.h:340
bool isUndefined(bool SetUsed=true) const
isUndefined - Check if this symbol undefined (i.e., implicitly defined).
Definition: MCSymbol.h:258
MCFragment * getFragment(bool SetUsed=true) const
Definition: MCSymbol.h:396
Target - Wrapper for Target specific information.
MCSection * getParent() const
Definition: MCFragment.h:98
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:268
A eight-byte fixup.
Definition: MCFixup.h:27
S_ATTR_DEBUG - A debug section.
Definition: MachO.h:196
uint64_t getSectionAddress(const MCSection *Sec) const
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:204
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
const MCExpr * getVariableValue(bool SetUsed=true) const
getVariableValue - Get the value for variable symbols.
Definition: MCSymbol.h:302
LLVM Value Representation.
Definition: Value.h:73
unsigned getTargetKind() const
Definition: MCFixup.h:128
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
A two-byte fixup.
Definition: MCFixup.h:25
MCFixupKind getKind() const
Definition: MCFixup.h:126