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