1//===- lib/MC/MCAssembler.cpp - Assembler Backend Implementation ----------===//
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
10#include "llvm/MC/MCAssembler.h"
11#include "llvm/ADT/Statistic.h"
12#include "llvm/ADT/StringExtras.h"
13#include "llvm/ADT/Twine.h"
14#include "llvm/MC/MCAsmBackend.h"
15#include "llvm/MC/MCAsmLayout.h"
16#include "llvm/MC/MCCodeEmitter.h"
17#include "llvm/MC/MCContext.h"
18#include "llvm/MC/MCDwarf.h"
19#include "llvm/MC/MCExpr.h"
20#include "llvm/MC/MCFixupKindInfo.h"
21#include "llvm/MC/MCObjectWriter.h"
22#include "llvm/MC/MCSection.h"
23#include "llvm/MC/MCSymbol.h"
24#include "llvm/MC/MCValue.h"
25#include "llvm/Support/Debug.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Support/LEB128.h"
28#include "llvm/Support/TargetRegistry.h"
29#include "llvm/Support/raw_ostream.h"
30#include "llvm/MC/MCSectionELF.h"
31#include <tuple>
32using namespace llvm;
33
34#define DEBUG_TYPE "assembler"
35
36namespace {
37namespace stats {
38STATISTIC(EmittedFragments, "Number of emitted assembler fragments - total");
39STATISTIC(EmittedRelaxableFragments,
40          "Number of emitted assembler fragments - relaxable");
41STATISTIC(EmittedDataFragments,
42          "Number of emitted assembler fragments - data");
43STATISTIC(EmittedCompactEncodedInstFragments,
44          "Number of emitted assembler fragments - compact encoded inst");
45STATISTIC(EmittedAlignFragments,
46          "Number of emitted assembler fragments - align");
47STATISTIC(EmittedFillFragments,
48          "Number of emitted assembler fragments - fill");
49STATISTIC(EmittedOrgFragments,
50          "Number of emitted assembler fragments - org");
51STATISTIC(evaluateFixup, "Number of evaluated fixups");
52STATISTIC(FragmentLayouts, "Number of fragment layouts");
53STATISTIC(ObjectBytes, "Number of emitted object file bytes");
54STATISTIC(RelaxationSteps, "Number of assembler layout and relaxation steps");
55STATISTIC(RelaxedInstructions, "Number of relaxed instructions");
56}
57}
58
59// FIXME FIXME FIXME: There are number of places in this file where we convert
60// what is a 64-bit assembler value used for computation into a value in the
61// object file, which may truncate it. We should detect that truncation where
62// invalid and report errors back.
63
64/* *** */
65
66MCAsmLayout::MCAsmLayout(MCAssembler &Asm)
67  : Assembler(Asm), LastValidFragment()
68 {
69  // Compute the section layout order. Virtual sections must go last.
70  for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it)
71    if (!it->getSection().isVirtualSection())
72      SectionOrder.push_back(&*it);
73  for (MCAssembler::iterator it = Asm.begin(), ie = Asm.end(); it != ie; ++it)
74    if (it->getSection().isVirtualSection())
75      SectionOrder.push_back(&*it);
76}
77
78bool MCAsmLayout::isFragmentValid(const MCFragment *F) const {
79  const MCSectionData &SD = *F->getParent();
80  const MCFragment *LastValid = LastValidFragment.lookup(&SD);
81  if (!LastValid)
82    return false;
83  assert(LastValid->getParent() == F->getParent());
84  return F->getLayoutOrder() <= LastValid->getLayoutOrder();
85}
86
87void MCAsmLayout::invalidateFragmentsFrom(MCFragment *F) {
88  // If this fragment wasn't already valid, we don't need to do anything.
89  if (!isFragmentValid(F))
90    return;
91
92  // Otherwise, reset the last valid fragment to the previous fragment
93  // (if this is the first fragment, it will be NULL).
94  const MCSectionData &SD = *F->getParent();
95  LastValidFragment[&SD] = F->getPrevNode();
96}
97
98void MCAsmLayout::ensureValid(const MCFragment *F) const {
99  MCSectionData &SD = *F->getParent();
100
101  MCFragment *Cur = LastValidFragment[&SD];
102  if (!Cur)
103    Cur = &*SD.begin();
104  else
105    Cur = Cur->getNextNode();
106
107  // Advance the layout position until the fragment is valid.
108  while (!isFragmentValid(F)) {
109    assert(Cur && "Layout bookkeeping error");
110    const_cast<MCAsmLayout*>(this)->layoutFragment(Cur);
111    Cur = Cur->getNextNode();
112  }
113}
114
115uint64_t MCAsmLayout::getFragmentOffset(const MCFragment *F) const {
116  ensureValid(F);
117  assert(F->Offset != ~UINT64_C(0) && "Address not set!");
118  return F->Offset;
119}
120
121// Simple getSymbolOffset helper for the non-varibale case.
122static bool getLabelOffset(const MCAsmLayout &Layout, const MCSymbolData &SD,
123                           bool ReportError, uint64_t &Val) {
124  if (!SD.getFragment()) {
125    if (ReportError)
126      report_fatal_error("unable to evaluate offset to undefined symbol '" +
127                         SD.getSymbol().getName() + "'");
128    return false;
129  }
130  Val = Layout.getFragmentOffset(SD.getFragment()) + SD.getOffset();
131  return true;
132}
133
134static bool getSymbolOffsetImpl(const MCAsmLayout &Layout,
135                                const MCSymbolData *SD, bool ReportError,
136                                uint64_t &Val) {
137  const MCSymbol &S = SD->getSymbol();
138
139  if (!S.isVariable())
140    return getLabelOffset(Layout, *SD, ReportError, Val);
141
142  // If SD is a variable, evaluate it.
143  MCValue Target;
144  if (!S.getVariableValue()->EvaluateAsValue(Target, &Layout))
145    report_fatal_error("unable to evaluate offset for variable '" +
146                       S.getName() + "'");
147
148  uint64_t Offset = Target.getConstant();
149
150  const MCAssembler &Asm = Layout.getAssembler();
151
152  const MCSymbolRefExpr *A = Target.getSymA();
153  if (A) {
154    uint64_t ValA;
155    if (!getLabelOffset(Layout, Asm.getSymbolData(A->getSymbol()), ReportError,
156                        ValA))
157      return false;
158    Offset += ValA;
159  }
160
161  const MCSymbolRefExpr *B = Target.getSymB();
162  if (B) {
163    uint64_t ValB;
164    if (!getLabelOffset(Layout, Asm.getSymbolData(B->getSymbol()), ReportError,
165                        ValB))
166      return false;
167    Offset -= ValB;
168  }
169
170  Val = Offset;
171  return true;
172}
173
174bool MCAsmLayout::getSymbolOffset(const MCSymbolData *SD, uint64_t &Val) const {
175  return getSymbolOffsetImpl(*this, SD, false, Val);
176}
177
178uint64_t MCAsmLayout::getSymbolOffset(const MCSymbolData *SD) const {
179  uint64_t Val;
180  getSymbolOffsetImpl(*this, SD, true, Val);
181  return Val;
182}
183
184const MCSymbol *MCAsmLayout::getBaseSymbol(const MCSymbol &Symbol) const {
185  if (!Symbol.isVariable())
186    return &Symbol;
187
188  const MCExpr *Expr = Symbol.getVariableValue();
189  MCValue Value;
190  if (!Expr->EvaluateAsValue(Value, this))
191    llvm_unreachable("Invalid Expression");
192
193  const MCSymbolRefExpr *RefB = Value.getSymB();
194  if (RefB)
195    Assembler.getContext().FatalError(
196        SMLoc(), Twine("symbol '") + RefB->getSymbol().getName() +
197                     "' could not be evaluated in a subtraction expression");
198
199  const MCSymbolRefExpr *A = Value.getSymA();
200  if (!A)
201    return nullptr;
202
203  return &A->getSymbol();
204}
205
206uint64_t MCAsmLayout::getSectionAddressSize(const MCSectionData *SD) const {
207  // The size is the last fragment's end offset.
208  const MCFragment &F = SD->getFragmentList().back();
209  return getFragmentOffset(&F) + getAssembler().computeFragmentSize(*this, F);
210}
211
212uint64_t MCAsmLayout::getSectionFileSize(const MCSectionData *SD) const {
213  // Virtual sections have no file size.
214  if (SD->getSection().isVirtualSection())
215    return 0;
216
217  // Otherwise, the file size is the same as the address space size.
218  return getSectionAddressSize(SD);
219}
220
221uint64_t MCAsmLayout::computeBundlePadding(const MCFragment *F,
222                                           uint64_t FOffset, uint64_t FSize) {
223  uint64_t BundleSize = Assembler.getBundleAlignSize();
224  assert(BundleSize > 0 &&
225         "computeBundlePadding should only be called if bundling is enabled");
226  uint64_t BundleMask = BundleSize - 1;
227  uint64_t OffsetInBundle = FOffset & BundleMask;
228  uint64_t EndOfFragment = OffsetInBundle + FSize;
229
230  // There are two kinds of bundling restrictions:
231  //
232  // 1) For alignToBundleEnd(), add padding to ensure that the fragment will
233  //    *end* on a bundle boundary.
234  // 2) Otherwise, check if the fragment would cross a bundle boundary. If it
235  //    would, add padding until the end of the bundle so that the fragment
236  //    will start in a new one.
237  if (F->alignToBundleEnd()) {
238    // Three possibilities here:
239    //
240    // A) The fragment just happens to end at a bundle boundary, so we're good.
241    // B) The fragment ends before the current bundle boundary: pad it just
242    //    enough to reach the boundary.
243    // C) The fragment ends after the current bundle boundary: pad it until it
244    //    reaches the end of the next bundle boundary.
245    //
246    // Note: this code could be made shorter with some modulo trickery, but it's
247    // intentionally kept in its more explicit form for simplicity.
248    if (EndOfFragment == BundleSize)
249      return 0;
250    else if (EndOfFragment < BundleSize)
251      return BundleSize - EndOfFragment;
252    else { // EndOfFragment > BundleSize
253      return 2 * BundleSize - EndOfFragment;
254    }
255  } else if (EndOfFragment > BundleSize)
256    return BundleSize - OffsetInBundle;
257  else
258    return 0;
259}
260
261/* *** */
262
263MCFragment::MCFragment() : Kind(FragmentType(~0)) {
264}
265
266MCFragment::~MCFragment() {
267}
268
269MCFragment::MCFragment(FragmentType _Kind, MCSectionData *_Parent)
270  : Kind(_Kind), Parent(_Parent), Atom(nullptr), Offset(~UINT64_C(0))
271{
272  if (Parent)
273    Parent->getFragmentList().push_back(this);
274}
275
276/* *** */
277
278MCEncodedFragment::~MCEncodedFragment() {
279}
280
281/* *** */
282
283MCEncodedFragmentWithFixups::~MCEncodedFragmentWithFixups() {
284}
285
286/* *** */
287
288MCSectionData::MCSectionData() : Section(nullptr) {}
289
290MCSectionData::MCSectionData(const MCSection &_Section, MCAssembler *A)
291  : Section(&_Section),
292    Ordinal(~UINT32_C(0)),
293    Alignment(1),
294    BundleLockState(NotBundleLocked), BundleGroupBeforeFirstInst(false),
295    HasInstructions(false)
296{
297  if (A)
298    A->getSectionList().push_back(this);
299}
300
301MCSectionData::iterator
302MCSectionData::getSubsectionInsertionPoint(unsigned Subsection) {
303  if (Subsection == 0 && SubsectionFragmentMap.empty())
304    return end();
305
306  SmallVectorImpl<std::pair<unsigned, MCFragment *> >::iterator MI =
307    std::lower_bound(SubsectionFragmentMap.begin(), SubsectionFragmentMap.end(),
308                     std::make_pair(Subsection, (MCFragment *)nullptr));
309  bool ExactMatch = false;
310  if (MI != SubsectionFragmentMap.end()) {
311    ExactMatch = MI->first == Subsection;
312    if (ExactMatch)
313      ++MI;
314  }
315  iterator IP;
316  if (MI == SubsectionFragmentMap.end())
317    IP = end();
318  else
319    IP = MI->second;
320  if (!ExactMatch && Subsection != 0) {
321    // The GNU as documentation claims that subsections have an alignment of 4,
322    // although this appears not to be the case.
323    MCFragment *F = new MCDataFragment();
324    SubsectionFragmentMap.insert(MI, std::make_pair(Subsection, F));
325    getFragmentList().insert(IP, F);
326    F->setParent(this);
327  }
328  return IP;
329}
330
331/* *** */
332
333MCSymbolData::MCSymbolData() : Symbol(nullptr) {}
334
335MCSymbolData::MCSymbolData(const MCSymbol &_Symbol, MCFragment *_Fragment,
336                           uint64_t _Offset, MCAssembler *A)
337  : Symbol(&_Symbol), Fragment(_Fragment), Offset(_Offset),
338    IsExternal(false), IsPrivateExtern(false),
339    CommonSize(0), SymbolSize(nullptr), CommonAlign(0),
340    Flags(0), Index(0)
341{
342  if (A)
343    A->getSymbolList().push_back(this);
344}
345
346/* *** */
347
348MCAssembler::MCAssembler(MCContext &Context_, MCAsmBackend &Backend_,
349                         MCCodeEmitter &Emitter_, MCObjectWriter &Writer_,
350                         raw_ostream &OS_)
351  : Context(Context_), Backend(Backend_), Emitter(Emitter_), Writer(Writer_),
352    OS(OS_), BundleAlignSize(0), RelaxAll(false), NoExecStack(false),
353    SubsectionsViaSymbols(false), ELFHeaderEFlags(0) {
354  VersionMinInfo.Major = 0; // Major version == 0 for "none specified"
355}
356
357MCAssembler::~MCAssembler() {
358}
359
360void MCAssembler::reset() {
361  Sections.clear();
362  Symbols.clear();
363  SectionMap.clear();
364  SymbolMap.clear();
365  IndirectSymbols.clear();
366  DataRegions.clear();
367  ThumbFuncs.clear();
368  RelaxAll = false;
369  NoExecStack = false;
370  SubsectionsViaSymbols = false;
371  ELFHeaderEFlags = 0;
372
373  // reset objects owned by us
374  getBackend().reset();
375  getEmitter().reset();
376  getWriter().reset();
377  getLOHContainer().reset();
378}
379
380bool MCAssembler::isThumbFunc(const MCSymbol *Symbol) const {
381  if (ThumbFuncs.count(Symbol))
382    return true;
383
384  if (!Symbol->isVariable())
385    return false;
386
387  // FIXME: It looks like gas supports some cases of the form "foo + 2". It
388  // is not clear if that is a bug or a feature.
389  const MCExpr *Expr = Symbol->getVariableValue();
390  const MCSymbolRefExpr *Ref = dyn_cast<MCSymbolRefExpr>(Expr);
391  if (!Ref)
392    return false;
393
394  if (Ref->getKind() != MCSymbolRefExpr::VK_None)
395    return false;
396
397  const MCSymbol &Sym = Ref->getSymbol();
398  if (!isThumbFunc(&Sym))
399    return false;
400
401  ThumbFuncs.insert(Symbol); // Cache it.
402  return true;
403}
404
405bool MCAssembler::isSymbolLinkerVisible(const MCSymbol &Symbol) const {
406  // Non-temporary labels should always be visible to the linker.
407  if (!Symbol.isTemporary())
408    return true;
409
410  // Absolute temporary labels are never visible.
411  if (!Symbol.isInSection())
412    return false;
413
414  // Otherwise, check if the section requires symbols even for temporary labels.
415  return getBackend().doesSectionRequireSymbols(Symbol.getSection());
416}
417
418const MCSymbolData *MCAssembler::getAtom(const MCSymbolData *SD) const {
419  // Linker visible symbols define atoms.
420  if (isSymbolLinkerVisible(SD->getSymbol()))
421    return SD;
422
423  // Absolute and undefined symbols have no defining atom.
424  if (!SD->getFragment())
425    return nullptr;
426
427  // Non-linker visible symbols in sections which can't be atomized have no
428  // defining atom.
429  if (!getBackend().isSectionAtomizable(
430        SD->getFragment()->getParent()->getSection()))
431    return nullptr;
432
433  // Otherwise, return the atom for the containing fragment.
434  return SD->getFragment()->getAtom();
435}
436
437// Try to fully compute Expr to an absolute value and if that fails produce
438// a relocatable expr.
439// FIXME: Should this be the behavior of EvaluateAsRelocatable itself?
440static bool evaluate(const MCExpr &Expr, const MCAsmLayout &Layout,
441                     MCValue &Target) {
442  if (Expr.EvaluateAsValue(Target, &Layout))
443    if (Target.isAbsolute())
444      return true;
445  return Expr.EvaluateAsRelocatable(Target, &Layout);
446}
447
448bool MCAssembler::evaluateFixup(const MCAsmLayout &Layout,
449                                const MCFixup &Fixup, const MCFragment *DF,
450                                MCValue &Target, uint64_t &Value) const {
451  ++stats::evaluateFixup;
452
453  // FIXME: This code has some duplication with RecordRelocation. We should
454  // probably merge the two into a single callback that tries to evaluate a
455  // fixup and records a relocation if one is needed.
456  const MCExpr *Expr = Fixup.getValue();
457  if (!evaluate(*Expr, Layout, Target))
458    getContext().FatalError(Fixup.getLoc(), "expected relocatable expression");
459
460  bool IsPCRel = Backend.getFixupKindInfo(
461    Fixup.getKind()).Flags & MCFixupKindInfo::FKF_IsPCRel;
462
463  bool IsResolved;
464  if (IsPCRel) {
465    if (Target.getSymB()) {
466      IsResolved = false;
467    } else if (!Target.getSymA()) {
468      IsResolved = false;
469    } else {
470      const MCSymbolRefExpr *A = Target.getSymA();
471      const MCSymbol &SA = A->getSymbol();
472      if (A->getKind() != MCSymbolRefExpr::VK_None ||
473          SA.AliasedSymbol().isUndefined()) {
474        IsResolved = false;
475      } else {
476        const MCSymbolData &DataA = getSymbolData(SA);
477        IsResolved =
478          getWriter().IsSymbolRefDifferenceFullyResolvedImpl(*this, DataA,
479                                                             *DF, false, true);
480      }
481    }
482  } else {
483    IsResolved = Target.isAbsolute();
484  }
485
486  Value = Target.getConstant();
487
488  if (const MCSymbolRefExpr *A = Target.getSymA()) {
489    const MCSymbol &Sym = A->getSymbol().AliasedSymbol();
490    if (Sym.isDefined())
491      Value += Layout.getSymbolOffset(&getSymbolData(Sym));
492  }
493  if (const MCSymbolRefExpr *B = Target.getSymB()) {
494    const MCSymbol &Sym = B->getSymbol().AliasedSymbol();
495    if (Sym.isDefined())
496      Value -= Layout.getSymbolOffset(&getSymbolData(Sym));
497  }
498
499
500  bool ShouldAlignPC = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
501                         MCFixupKindInfo::FKF_IsAlignedDownTo32Bits;
502  assert((ShouldAlignPC ? IsPCRel : true) &&
503    "FKF_IsAlignedDownTo32Bits is only allowed on PC-relative fixups!");
504
505  if (IsPCRel) {
506    uint32_t Offset = Layout.getFragmentOffset(DF) + Fixup.getOffset();
507
508    // A number of ARM fixups in Thumb mode require that the effective PC
509    // address be determined as the 32-bit aligned version of the actual offset.
510    if (ShouldAlignPC) Offset &= ~0x3;
511    Value -= Offset;
512  }
513
514  // Let the backend adjust the fixup value if necessary, including whether
515  // we need a relocation.
516  Backend.processFixupValue(*this, Layout, Fixup, DF, Target, Value,
517                            IsResolved);
518
519  return IsResolved;
520}
521
522uint64_t MCAssembler::computeFragmentSize(const MCAsmLayout &Layout,
523                                          const MCFragment &F) const {
524  switch (F.getKind()) {
525  case MCFragment::FT_Data:
526  case MCFragment::FT_Relaxable:
527  case MCFragment::FT_CompactEncodedInst:
528    return cast<MCEncodedFragment>(F).getContents().size();
529  case MCFragment::FT_Fill:
530    return cast<MCFillFragment>(F).getSize();
531
532  case MCFragment::FT_LEB:
533    return cast<MCLEBFragment>(F).getContents().size();
534
535  case MCFragment::FT_Align: {
536    const MCAlignFragment &AF = cast<MCAlignFragment>(F);
537    unsigned Offset = Layout.getFragmentOffset(&AF);
538    unsigned Size = OffsetToAlignment(Offset, AF.getAlignment());
539    // If we are padding with nops, force the padding to be larger than the
540    // minimum nop size.
541    if (Size > 0 && AF.hasEmitNops()) {
542      while (Size % getBackend().getMinimumNopSize())
543        Size += AF.getAlignment();
544    }
545    if (Size > AF.getMaxBytesToEmit())
546      return 0;
547    return Size;
548  }
549
550  case MCFragment::FT_Org: {
551    const MCOrgFragment &OF = cast<MCOrgFragment>(F);
552    int64_t TargetLocation;
553    if (!OF.getOffset().EvaluateAsAbsolute(TargetLocation, Layout))
554      report_fatal_error("expected assembly-time absolute expression");
555
556    // FIXME: We need a way to communicate this error.
557    uint64_t FragmentOffset = Layout.getFragmentOffset(&OF);
558    int64_t Size = TargetLocation - FragmentOffset;
559    if (Size < 0 || Size >= 0x40000000)
560      report_fatal_error("invalid .org offset '" + Twine(TargetLocation) +
561                         "' (at offset '" + Twine(FragmentOffset) + "')");
562    return Size;
563  }
564
565  case MCFragment::FT_Dwarf:
566    return cast<MCDwarfLineAddrFragment>(F).getContents().size();
567  case MCFragment::FT_DwarfFrame:
568    return cast<MCDwarfCallFrameFragment>(F).getContents().size();
569  }
570
571  llvm_unreachable("invalid fragment kind");
572}
573
574void MCAsmLayout::layoutFragment(MCFragment *F) {
575  MCFragment *Prev = F->getPrevNode();
576
577  // We should never try to recompute something which is valid.
578  assert(!isFragmentValid(F) && "Attempt to recompute a valid fragment!");
579  // We should never try to compute the fragment layout if its predecessor
580  // isn't valid.
581  assert((!Prev || isFragmentValid(Prev)) &&
582         "Attempt to compute fragment before its predecessor!");
583
584  ++stats::FragmentLayouts;
585
586  // Compute fragment offset and size.
587  if (Prev)
588    F->Offset = Prev->Offset + getAssembler().computeFragmentSize(*this, *Prev);
589  else
590    F->Offset = 0;
591  LastValidFragment[F->getParent()] = F;
592
593  // If bundling is enabled and this fragment has instructions in it, it has to
594  // obey the bundling restrictions. With padding, we'll have:
595  //
596  //
597  //        BundlePadding
598  //             |||
599  // -------------------------------------
600  //   Prev  |##########|       F        |
601  // -------------------------------------
602  //                    ^
603  //                    |
604  //                    F->Offset
605  //
606  // The fragment's offset will point to after the padding, and its computed
607  // size won't include the padding.
608  //
609  if (Assembler.isBundlingEnabled() && F->hasInstructions()) {
610    assert(isa<MCEncodedFragment>(F) &&
611           "Only MCEncodedFragment implementations have instructions");
612    uint64_t FSize = Assembler.computeFragmentSize(*this, *F);
613
614    if (FSize > Assembler.getBundleAlignSize())
615      report_fatal_error("Fragment can't be larger than a bundle size");
616
617    uint64_t RequiredBundlePadding = computeBundlePadding(F, F->Offset, FSize);
618    if (RequiredBundlePadding > UINT8_MAX)
619      report_fatal_error("Padding cannot exceed 255 bytes");
620    F->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
621    F->Offset += RequiredBundlePadding;
622  }
623}
624
625/// \brief Write the contents of a fragment to the given object writer. Expects
626///        a MCEncodedFragment.
627static void writeFragmentContents(const MCFragment &F, MCObjectWriter *OW) {
628  const MCEncodedFragment &EF = cast<MCEncodedFragment>(F);
629  OW->WriteBytes(EF.getContents());
630}
631
632/// \brief Write the fragment \p F to the output file.
633static void writeFragment(const MCAssembler &Asm, const MCAsmLayout &Layout,
634                          const MCFragment &F) {
635  MCObjectWriter *OW = &Asm.getWriter();
636
637  // FIXME: Embed in fragments instead?
638  uint64_t FragmentSize = Asm.computeFragmentSize(Layout, F);
639
640  // Should NOP padding be written out before this fragment?
641  unsigned BundlePadding = F.getBundlePadding();
642  if (BundlePadding > 0) {
643    assert(Asm.isBundlingEnabled() &&
644           "Writing bundle padding with disabled bundling");
645    assert(F.hasInstructions() &&
646           "Writing bundle padding for a fragment without instructions");
647
648    unsigned TotalLength = BundlePadding + static_cast<unsigned>(FragmentSize);
649    if (F.alignToBundleEnd() && TotalLength > Asm.getBundleAlignSize()) {
650      // If the padding itself crosses a bundle boundary, it must be emitted
651      // in 2 pieces, since even nop instructions must not cross boundaries.
652      //             v--------------v   <- BundleAlignSize
653      //        v---------v             <- BundlePadding
654      // ----------------------------
655      // | Prev |####|####|    F    |
656      // ----------------------------
657      //        ^-------------------^   <- TotalLength
658      unsigned DistanceToBoundary = TotalLength - Asm.getBundleAlignSize();
659      if (!Asm.getBackend().writeNopData(DistanceToBoundary, OW))
660          report_fatal_error("unable to write NOP sequence of " +
661                             Twine(DistanceToBoundary) + " bytes");
662      BundlePadding -= DistanceToBoundary;
663    }
664    if (!Asm.getBackend().writeNopData(BundlePadding, OW))
665      report_fatal_error("unable to write NOP sequence of " +
666                         Twine(BundlePadding) + " bytes");
667  }
668
669  // This variable (and its dummy usage) is to participate in the assert at
670  // the end of the function.
671  uint64_t Start = OW->getStream().tell();
672  (void) Start;
673
674  ++stats::EmittedFragments;
675
676  switch (F.getKind()) {
677  case MCFragment::FT_Align: {
678    ++stats::EmittedAlignFragments;
679    const MCAlignFragment &AF = cast<MCAlignFragment>(F);
680    assert(AF.getValueSize() && "Invalid virtual align in concrete fragment!");
681
682    uint64_t Count = FragmentSize / AF.getValueSize();
683
684    // FIXME: This error shouldn't actually occur (the front end should emit
685    // multiple .align directives to enforce the semantics it wants), but is
686    // severe enough that we want to report it. How to handle this?
687    if (Count * AF.getValueSize() != FragmentSize)
688      report_fatal_error("undefined .align directive, value size '" +
689                        Twine(AF.getValueSize()) +
690                        "' is not a divisor of padding size '" +
691                        Twine(FragmentSize) + "'");
692
693    // See if we are aligning with nops, and if so do that first to try to fill
694    // the Count bytes.  Then if that did not fill any bytes or there are any
695    // bytes left to fill use the Value and ValueSize to fill the rest.
696    // If we are aligning with nops, ask that target to emit the right data.
697    if (AF.hasEmitNops()) {
698      if (!Asm.getBackend().writeNopData(Count, OW))
699        report_fatal_error("unable to write nop sequence of " +
700                          Twine(Count) + " bytes");
701      break;
702    }
703
704    // Otherwise, write out in multiples of the value size.
705    for (uint64_t i = 0; i != Count; ++i) {
706      switch (AF.getValueSize()) {
707      default: llvm_unreachable("Invalid size!");
708      case 1: OW->Write8 (uint8_t (AF.getValue())); break;
709      case 2: OW->Write16(uint16_t(AF.getValue())); break;
710      case 4: OW->Write32(uint32_t(AF.getValue())); break;
711      case 8: OW->Write64(uint64_t(AF.getValue())); break;
712      }
713    }
714    break;
715  }
716
717  case MCFragment::FT_Data:
718    ++stats::EmittedDataFragments;
719    writeFragmentContents(F, OW);
720    break;
721
722  case MCFragment::FT_Relaxable:
723    ++stats::EmittedRelaxableFragments;
724    writeFragmentContents(F, OW);
725    break;
726
727  case MCFragment::FT_CompactEncodedInst:
728    ++stats::EmittedCompactEncodedInstFragments;
729    writeFragmentContents(F, OW);
730    break;
731
732  case MCFragment::FT_Fill: {
733    ++stats::EmittedFillFragments;
734    const MCFillFragment &FF = cast<MCFillFragment>(F);
735
736    assert(FF.getValueSize() && "Invalid virtual align in concrete fragment!");
737
738    for (uint64_t i = 0, e = FF.getSize() / FF.getValueSize(); i != e; ++i) {
739      switch (FF.getValueSize()) {
740      default: llvm_unreachable("Invalid size!");
741      case 1: OW->Write8 (uint8_t (FF.getValue())); break;
742      case 2: OW->Write16(uint16_t(FF.getValue())); break;
743      case 4: OW->Write32(uint32_t(FF.getValue())); break;
744      case 8: OW->Write64(uint64_t(FF.getValue())); break;
745      }
746    }
747    break;
748  }
749
750  case MCFragment::FT_LEB: {
751    const MCLEBFragment &LF = cast<MCLEBFragment>(F);
752    OW->WriteBytes(LF.getContents().str());
753    break;
754  }
755
756  case MCFragment::FT_Org: {
757    ++stats::EmittedOrgFragments;
758    const MCOrgFragment &OF = cast<MCOrgFragment>(F);
759
760    for (uint64_t i = 0, e = FragmentSize; i != e; ++i)
761      OW->Write8(uint8_t(OF.getValue()));
762
763    break;
764  }
765
766  case MCFragment::FT_Dwarf: {
767    const MCDwarfLineAddrFragment &OF = cast<MCDwarfLineAddrFragment>(F);
768    OW->WriteBytes(OF.getContents().str());
769    break;
770  }
771  case MCFragment::FT_DwarfFrame: {
772    const MCDwarfCallFrameFragment &CF = cast<MCDwarfCallFrameFragment>(F);
773    OW->WriteBytes(CF.getContents().str());
774    break;
775  }
776  }
777
778  assert(OW->getStream().tell() - Start == FragmentSize &&
779         "The stream should advance by fragment size");
780}
781
782void MCAssembler::writeSectionData(const MCSectionData *SD,
783                                   const MCAsmLayout &Layout) const {
784  // Ignore virtual sections.
785  if (SD->getSection().isVirtualSection()) {
786    assert(Layout.getSectionFileSize(SD) == 0 && "Invalid size for section!");
787
788    // Check that contents are only things legal inside a virtual section.
789    for (MCSectionData::const_iterator it = SD->begin(),
790           ie = SD->end(); it != ie; ++it) {
791      switch (it->getKind()) {
792      default: llvm_unreachable("Invalid fragment in virtual section!");
793      case MCFragment::FT_Data: {
794        // Check that we aren't trying to write a non-zero contents (or fixups)
795        // into a virtual section. This is to support clients which use standard
796        // directives to fill the contents of virtual sections.
797        const MCDataFragment &DF = cast<MCDataFragment>(*it);
798        assert(DF.fixup_begin() == DF.fixup_end() &&
799               "Cannot have fixups in virtual section!");
800        for (unsigned i = 0, e = DF.getContents().size(); i != e; ++i)
801          if (DF.getContents()[i]) {
802            if (auto *ELFSec = dyn_cast<const MCSectionELF>(&SD->getSection()))
803              report_fatal_error("non-zero initializer found in section '" +
804                  ELFSec->getSectionName() + "'");
805            else
806              report_fatal_error("non-zero initializer found in virtual section");
807          }
808        break;
809      }
810      case MCFragment::FT_Align:
811        // Check that we aren't trying to write a non-zero value into a virtual
812        // section.
813        assert((cast<MCAlignFragment>(it)->getValueSize() == 0 ||
814                cast<MCAlignFragment>(it)->getValue() == 0) &&
815               "Invalid align in virtual section!");
816        break;
817      case MCFragment::FT_Fill:
818        assert((cast<MCFillFragment>(it)->getValueSize() == 0 ||
819                cast<MCFillFragment>(it)->getValue() == 0) &&
820               "Invalid fill in virtual section!");
821        break;
822      }
823    }
824
825    return;
826  }
827
828  uint64_t Start = getWriter().getStream().tell();
829  (void)Start;
830
831  for (MCSectionData::const_iterator it = SD->begin(), ie = SD->end();
832       it != ie; ++it)
833    writeFragment(*this, Layout, *it);
834
835  assert(getWriter().getStream().tell() - Start ==
836         Layout.getSectionAddressSize(SD));
837}
838
839std::pair<uint64_t, bool> MCAssembler::handleFixup(const MCAsmLayout &Layout,
840                                                   MCFragment &F,
841                                                   const MCFixup &Fixup) {
842  // Evaluate the fixup.
843  MCValue Target;
844  uint64_t FixedValue;
845  bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
846                 MCFixupKindInfo::FKF_IsPCRel;
847  if (!evaluateFixup(Layout, Fixup, &F, Target, FixedValue)) {
848    // The fixup was unresolved, we need a relocation. Inform the object
849    // writer of the relocation, and give it an opportunity to adjust the
850    // fixup value if need be.
851    getWriter().RecordRelocation(*this, Layout, &F, Fixup, Target, IsPCRel,
852                                 FixedValue);
853  }
854  return std::make_pair(FixedValue, IsPCRel);
855}
856
857void MCAssembler::Finish() {
858  DEBUG_WITH_TYPE("mc-dump", {
859      llvm::errs() << "assembler backend - pre-layout\n--\n";
860      dump(); });
861
862  // Create the layout object.
863  MCAsmLayout Layout(*this);
864
865  // Create dummy fragments and assign section ordinals.
866  unsigned SectionIndex = 0;
867  for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) {
868    // Create dummy fragments to eliminate any empty sections, this simplifies
869    // layout.
870    if (it->getFragmentList().empty())
871      new MCDataFragment(it);
872
873    it->setOrdinal(SectionIndex++);
874  }
875
876  // Assign layout order indices to sections and fragments.
877  for (unsigned i = 0, e = Layout.getSectionOrder().size(); i != e; ++i) {
878    MCSectionData *SD = Layout.getSectionOrder()[i];
879    SD->setLayoutOrder(i);
880
881    unsigned FragmentIndex = 0;
882    for (MCSectionData::iterator iFrag = SD->begin(), iFragEnd = SD->end();
883         iFrag != iFragEnd; ++iFrag)
884      iFrag->setLayoutOrder(FragmentIndex++);
885  }
886
887  // Layout until everything fits.
888  while (layoutOnce(Layout))
889    continue;
890
891  DEBUG_WITH_TYPE("mc-dump", {
892      llvm::errs() << "assembler backend - post-relaxation\n--\n";
893      dump(); });
894
895  // Finalize the layout, including fragment lowering.
896  finishLayout(Layout);
897
898  DEBUG_WITH_TYPE("mc-dump", {
899      llvm::errs() << "assembler backend - final-layout\n--\n";
900      dump(); });
901
902  uint64_t StartOffset = OS.tell();
903
904  // Allow the object writer a chance to perform post-layout binding (for
905  // example, to set the index fields in the symbol data).
906  getWriter().ExecutePostLayoutBinding(*this, Layout);
907
908  // Evaluate and apply the fixups, generating relocation entries as necessary.
909  for (MCAssembler::iterator it = begin(), ie = end(); it != ie; ++it) {
910    for (MCSectionData::iterator it2 = it->begin(),
911           ie2 = it->end(); it2 != ie2; ++it2) {
912      MCEncodedFragmentWithFixups *F =
913        dyn_cast<MCEncodedFragmentWithFixups>(it2);
914      if (F) {
915        for (MCEncodedFragmentWithFixups::fixup_iterator it3 = F->fixup_begin(),
916             ie3 = F->fixup_end(); it3 != ie3; ++it3) {
917          MCFixup &Fixup = *it3;
918          uint64_t FixedValue;
919          bool IsPCRel;
920          std::tie(FixedValue, IsPCRel) = handleFixup(Layout, *F, Fixup);
921          getBackend().applyFixup(Fixup, F->getContents().data(),
922                                  F->getContents().size(), FixedValue, IsPCRel);
923        }
924      }
925    }
926  }
927
928  // Write the object file.
929  getWriter().WriteObject(*this, Layout);
930
931  stats::ObjectBytes += OS.tell() - StartOffset;
932}
933
934bool MCAssembler::fixupNeedsRelaxation(const MCFixup &Fixup,
935                                       const MCRelaxableFragment *DF,
936                                       const MCAsmLayout &Layout) const {
937  // If we cannot resolve the fixup value, it requires relaxation.
938  MCValue Target;
939  uint64_t Value;
940  if (!evaluateFixup(Layout, Fixup, DF, Target, Value))
941    return true;
942
943  return getBackend().fixupNeedsRelaxation(Fixup, Value, DF, Layout);
944}
945
946bool MCAssembler::fragmentNeedsRelaxation(const MCRelaxableFragment *F,
947                                          const MCAsmLayout &Layout) const {
948  // If this inst doesn't ever need relaxation, ignore it. This occurs when we
949  // are intentionally pushing out inst fragments, or because we relaxed a
950  // previous instruction to one that doesn't need relaxation.
951  if (!getBackend().mayNeedRelaxation(F->getInst()))
952    return false;
953
954  for (MCRelaxableFragment::const_fixup_iterator it = F->fixup_begin(),
955       ie = F->fixup_end(); it != ie; ++it)
956    if (fixupNeedsRelaxation(*it, F, Layout))
957      return true;
958
959  return false;
960}
961
962bool MCAssembler::relaxInstruction(MCAsmLayout &Layout,
963                                   MCRelaxableFragment &F) {
964  if (!fragmentNeedsRelaxation(&F, Layout))
965    return false;
966
967  ++stats::RelaxedInstructions;
968
969  // FIXME-PERF: We could immediately lower out instructions if we can tell
970  // they are fully resolved, to avoid retesting on later passes.
971
972  // Relax the fragment.
973
974  MCInst Relaxed;
975  getBackend().relaxInstruction(F.getInst(), Relaxed);
976
977  // Encode the new instruction.
978  //
979  // FIXME-PERF: If it matters, we could let the target do this. It can
980  // probably do so more efficiently in many cases.
981  SmallVector<MCFixup, 4> Fixups;
982  SmallString<256> Code;
983  raw_svector_ostream VecOS(Code);
984  getEmitter().EncodeInstruction(Relaxed, VecOS, Fixups, F.getSubtargetInfo());
985  VecOS.flush();
986
987  // Update the fragment.
988  F.setInst(Relaxed);
989  F.getContents() = Code;
990  F.getFixups() = Fixups;
991
992  return true;
993}
994
995bool MCAssembler::relaxLEB(MCAsmLayout &Layout, MCLEBFragment &LF) {
996  int64_t Value = 0;
997  uint64_t OldSize = LF.getContents().size();
998  bool IsAbs = LF.getValue().EvaluateAsAbsolute(Value, Layout);
999  (void)IsAbs;
1000  assert(IsAbs);
1001  SmallString<8> &Data = LF.getContents();
1002  Data.clear();
1003  raw_svector_ostream OSE(Data);
1004  if (LF.isSigned())
1005    encodeSLEB128(Value, OSE);
1006  else
1007    encodeULEB128(Value, OSE);
1008  OSE.flush();
1009  return OldSize != LF.getContents().size();
1010}
1011
1012bool MCAssembler::relaxDwarfLineAddr(MCAsmLayout &Layout,
1013                                     MCDwarfLineAddrFragment &DF) {
1014  MCContext &Context = Layout.getAssembler().getContext();
1015  int64_t AddrDelta = 0;
1016  uint64_t OldSize = DF.getContents().size();
1017  bool IsAbs = DF.getAddrDelta().EvaluateAsAbsolute(AddrDelta, Layout);
1018  (void)IsAbs;
1019  assert(IsAbs);
1020  int64_t LineDelta;
1021  LineDelta = DF.getLineDelta();
1022  SmallString<8> &Data = DF.getContents();
1023  Data.clear();
1024  raw_svector_ostream OSE(Data);
1025  MCDwarfLineAddr::Encode(Context, LineDelta, AddrDelta, OSE);
1026  OSE.flush();
1027  return OldSize != Data.size();
1028}
1029
1030bool MCAssembler::relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
1031                                              MCDwarfCallFrameFragment &DF) {
1032  MCContext &Context = Layout.getAssembler().getContext();
1033  int64_t AddrDelta = 0;
1034  uint64_t OldSize = DF.getContents().size();
1035  bool IsAbs = DF.getAddrDelta().EvaluateAsAbsolute(AddrDelta, Layout);
1036  (void)IsAbs;
1037  assert(IsAbs);
1038  SmallString<8> &Data = DF.getContents();
1039  Data.clear();
1040  raw_svector_ostream OSE(Data);
1041  MCDwarfFrameEmitter::EncodeAdvanceLoc(Context, AddrDelta, OSE);
1042  OSE.flush();
1043  return OldSize != Data.size();
1044}
1045
1046bool MCAssembler::layoutSectionOnce(MCAsmLayout &Layout, MCSectionData &SD) {
1047  // Holds the first fragment which needed relaxing during this layout. It will
1048  // remain NULL if none were relaxed.
1049  // When a fragment is relaxed, all the fragments following it should get
1050  // invalidated because their offset is going to change.
1051  MCFragment *FirstRelaxedFragment = nullptr;
1052
1053  // Attempt to relax all the fragments in the section.
1054  for (MCSectionData::iterator I = SD.begin(), IE = SD.end(); I != IE; ++I) {
1055    // Check if this is a fragment that needs relaxation.
1056    bool RelaxedFrag = false;
1057    switch(I->getKind()) {
1058    default:
1059      break;
1060    case MCFragment::FT_Relaxable:
1061      assert(!getRelaxAll() &&
1062             "Did not expect a MCRelaxableFragment in RelaxAll mode");
1063      RelaxedFrag = relaxInstruction(Layout, *cast<MCRelaxableFragment>(I));
1064      break;
1065    case MCFragment::FT_Dwarf:
1066      RelaxedFrag = relaxDwarfLineAddr(Layout,
1067                                       *cast<MCDwarfLineAddrFragment>(I));
1068      break;
1069    case MCFragment::FT_DwarfFrame:
1070      RelaxedFrag =
1071        relaxDwarfCallFrameFragment(Layout,
1072                                    *cast<MCDwarfCallFrameFragment>(I));
1073      break;
1074    case MCFragment::FT_LEB:
1075      RelaxedFrag = relaxLEB(Layout, *cast<MCLEBFragment>(I));
1076      break;
1077    }
1078    if (RelaxedFrag && !FirstRelaxedFragment)
1079      FirstRelaxedFragment = I;
1080  }
1081  if (FirstRelaxedFragment) {
1082    Layout.invalidateFragmentsFrom(FirstRelaxedFragment);
1083    return true;
1084  }
1085  return false;
1086}
1087
1088bool MCAssembler::layoutOnce(MCAsmLayout &Layout) {
1089  ++stats::RelaxationSteps;
1090
1091  bool WasRelaxed = false;
1092  for (iterator it = begin(), ie = end(); it != ie; ++it) {
1093    MCSectionData &SD = *it;
1094    while (layoutSectionOnce(Layout, SD))
1095      WasRelaxed = true;
1096  }
1097
1098  return WasRelaxed;
1099}
1100
1101void MCAssembler::finishLayout(MCAsmLayout &Layout) {
1102  // The layout is done. Mark every fragment as valid.
1103  for (unsigned int i = 0, n = Layout.getSectionOrder().size(); i != n; ++i) {
1104    Layout.getFragmentOffset(&*Layout.getSectionOrder()[i]->rbegin());
1105  }
1106}
1107
1108// Debugging methods
1109
1110namespace llvm {
1111
1112raw_ostream &operator<<(raw_ostream &OS, const MCFixup &AF) {
1113  OS << "<MCFixup" << " Offset:" << AF.getOffset()
1114     << " Value:" << *AF.getValue()
1115     << " Kind:" << AF.getKind() << ">";
1116  return OS;
1117}
1118
1119}
1120
1121#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1122void MCFragment::dump() {
1123  raw_ostream &OS = llvm::errs();
1124
1125  OS << "<";
1126  switch (getKind()) {
1127  case MCFragment::FT_Align: OS << "MCAlignFragment"; break;
1128  case MCFragment::FT_Data:  OS << "MCDataFragment"; break;
1129  case MCFragment::FT_CompactEncodedInst:
1130    OS << "MCCompactEncodedInstFragment"; break;
1131  case MCFragment::FT_Fill:  OS << "MCFillFragment"; break;
1132  case MCFragment::FT_Relaxable:  OS << "MCRelaxableFragment"; break;
1133  case MCFragment::FT_Org:   OS << "MCOrgFragment"; break;
1134  case MCFragment::FT_Dwarf: OS << "MCDwarfFragment"; break;
1135  case MCFragment::FT_DwarfFrame: OS << "MCDwarfCallFrameFragment"; break;
1136  case MCFragment::FT_LEB:   OS << "MCLEBFragment"; break;
1137  }
1138
1139  OS << "<MCFragment " << (void*) this << " LayoutOrder:" << LayoutOrder
1140     << " Offset:" << Offset
1141     << " HasInstructions:" << hasInstructions()
1142     << " BundlePadding:" << static_cast<unsigned>(getBundlePadding()) << ">";
1143
1144  switch (getKind()) {
1145  case MCFragment::FT_Align: {
1146    const MCAlignFragment *AF = cast<MCAlignFragment>(this);
1147    if (AF->hasEmitNops())
1148      OS << " (emit nops)";
1149    OS << "\n       ";
1150    OS << " Alignment:" << AF->getAlignment()
1151       << " Value:" << AF->getValue() << " ValueSize:" << AF->getValueSize()
1152       << " MaxBytesToEmit:" << AF->getMaxBytesToEmit() << ">";
1153    break;
1154  }
1155  case MCFragment::FT_Data:  {
1156    const MCDataFragment *DF = cast<MCDataFragment>(this);
1157    OS << "\n       ";
1158    OS << " Contents:[";
1159    const SmallVectorImpl<char> &Contents = DF->getContents();
1160    for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
1161      if (i) OS << ",";
1162      OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
1163    }
1164    OS << "] (" << Contents.size() << " bytes)";
1165
1166    if (DF->fixup_begin() != DF->fixup_end()) {
1167      OS << ",\n       ";
1168      OS << " Fixups:[";
1169      for (MCDataFragment::const_fixup_iterator it = DF->fixup_begin(),
1170             ie = DF->fixup_end(); it != ie; ++it) {
1171        if (it != DF->fixup_begin()) OS << ",\n                ";
1172        OS << *it;
1173      }
1174      OS << "]";
1175    }
1176    break;
1177  }
1178  case MCFragment::FT_CompactEncodedInst: {
1179    const MCCompactEncodedInstFragment *CEIF =
1180      cast<MCCompactEncodedInstFragment>(this);
1181    OS << "\n       ";
1182    OS << " Contents:[";
1183    const SmallVectorImpl<char> &Contents = CEIF->getContents();
1184    for (unsigned i = 0, e = Contents.size(); i != e; ++i) {
1185      if (i) OS << ",";
1186      OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
1187    }
1188    OS << "] (" << Contents.size() << " bytes)";
1189    break;
1190  }
1191  case MCFragment::FT_Fill:  {
1192    const MCFillFragment *FF = cast<MCFillFragment>(this);
1193    OS << " Value:" << FF->getValue() << " ValueSize:" << FF->getValueSize()
1194       << " Size:" << FF->getSize();
1195    break;
1196  }
1197  case MCFragment::FT_Relaxable:  {
1198    const MCRelaxableFragment *F = cast<MCRelaxableFragment>(this);
1199    OS << "\n       ";
1200    OS << " Inst:";
1201    F->getInst().dump_pretty(OS);
1202    break;
1203  }
1204  case MCFragment::FT_Org:  {
1205    const MCOrgFragment *OF = cast<MCOrgFragment>(this);
1206    OS << "\n       ";
1207    OS << " Offset:" << OF->getOffset() << " Value:" << OF->getValue();
1208    break;
1209  }
1210  case MCFragment::FT_Dwarf:  {
1211    const MCDwarfLineAddrFragment *OF = cast<MCDwarfLineAddrFragment>(this);
1212    OS << "\n       ";
1213    OS << " AddrDelta:" << OF->getAddrDelta()
1214       << " LineDelta:" << OF->getLineDelta();
1215    break;
1216  }
1217  case MCFragment::FT_DwarfFrame:  {
1218    const MCDwarfCallFrameFragment *CF = cast<MCDwarfCallFrameFragment>(this);
1219    OS << "\n       ";
1220    OS << " AddrDelta:" << CF->getAddrDelta();
1221    break;
1222  }
1223  case MCFragment::FT_LEB: {
1224    const MCLEBFragment *LF = cast<MCLEBFragment>(this);
1225    OS << "\n       ";
1226    OS << " Value:" << LF->getValue() << " Signed:" << LF->isSigned();
1227    break;
1228  }
1229  }
1230  OS << ">";
1231}
1232
1233void MCSectionData::dump() {
1234  raw_ostream &OS = llvm::errs();
1235
1236  OS << "<MCSectionData";
1237  OS << " Alignment:" << getAlignment()
1238     << " Fragments:[\n      ";
1239  for (iterator it = begin(), ie = end(); it != ie; ++it) {
1240    if (it != begin()) OS << ",\n      ";
1241    it->dump();
1242  }
1243  OS << "]>";
1244}
1245
1246void MCSymbolData::dump() const {
1247  raw_ostream &OS = llvm::errs();
1248
1249  OS << "<MCSymbolData Symbol:" << getSymbol()
1250     << " Fragment:" << getFragment() << " Offset:" << getOffset()
1251     << " Flags:" << getFlags() << " Index:" << getIndex();
1252  if (isCommon())
1253    OS << " (common, size:" << getCommonSize()
1254       << " align: " << getCommonAlignment() << ")";
1255  if (isExternal())
1256    OS << " (external)";
1257  if (isPrivateExtern())
1258    OS << " (private extern)";
1259  OS << ">";
1260}
1261
1262void MCAssembler::dump() {
1263  raw_ostream &OS = llvm::errs();
1264
1265  OS << "<MCAssembler\n";
1266  OS << "  Sections:[\n    ";
1267  for (iterator it = begin(), ie = end(); it != ie; ++it) {
1268    if (it != begin()) OS << ",\n    ";
1269    it->dump();
1270  }
1271  OS << "],\n";
1272  OS << "  Symbols:[";
1273
1274  for (symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) {
1275    if (it != symbol_begin()) OS << ",\n           ";
1276    it->dump();
1277  }
1278  OS << "]>\n";
1279}
1280#endif
1281
1282// anchors for MC*Fragment vtables
1283void MCEncodedFragment::anchor() { }
1284void MCEncodedFragmentWithFixups::anchor() { }
1285void MCDataFragment::anchor() { }
1286void MCCompactEncodedInstFragment::anchor() { }
1287void MCRelaxableFragment::anchor() { }
1288void MCAlignFragment::anchor() { }
1289void MCFillFragment::anchor() { }
1290void MCOrgFragment::anchor() { }
1291void MCLEBFragment::anchor() { }
1292void MCDwarfLineAddrFragment::anchor() { }
1293void MCDwarfCallFrameFragment::anchor() { }
1294