LCOV - code coverage report
Current view: top level - lib/MC - MCAssembler.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 325 358 90.8 %
Date: 2018-06-17 00:07:59 Functions: 27 28 96.4 %
Legend: Lines: hit not hit

          Line data    Source code
       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/ArrayRef.h"
      12             : #include "llvm/ADT/SmallString.h"
      13             : #include "llvm/ADT/SmallVector.h"
      14             : #include "llvm/ADT/Statistic.h"
      15             : #include "llvm/ADT/StringRef.h"
      16             : #include "llvm/ADT/Twine.h"
      17             : #include "llvm/MC/MCAsmBackend.h"
      18             : #include "llvm/MC/MCAsmInfo.h"
      19             : #include "llvm/MC/MCAsmLayout.h"
      20             : #include "llvm/MC/MCCodeEmitter.h"
      21             : #include "llvm/MC/MCCodeView.h"
      22             : #include "llvm/MC/MCContext.h"
      23             : #include "llvm/MC/MCDwarf.h"
      24             : #include "llvm/MC/MCExpr.h"
      25             : #include "llvm/MC/MCFixup.h"
      26             : #include "llvm/MC/MCFixupKindInfo.h"
      27             : #include "llvm/MC/MCFragment.h"
      28             : #include "llvm/MC/MCInst.h"
      29             : #include "llvm/MC/MCObjectWriter.h"
      30             : #include "llvm/MC/MCSection.h"
      31             : #include "llvm/MC/MCSectionELF.h"
      32             : #include "llvm/MC/MCSymbol.h"
      33             : #include "llvm/MC/MCValue.h"
      34             : #include "llvm/Support/Casting.h"
      35             : #include "llvm/Support/Debug.h"
      36             : #include "llvm/Support/ErrorHandling.h"
      37             : #include "llvm/Support/LEB128.h"
      38             : #include "llvm/Support/MathExtras.h"
      39             : #include "llvm/Support/raw_ostream.h"
      40             : #include <cassert>
      41             : #include <cstdint>
      42             : #include <cstring>
      43             : #include <tuple>
      44             : #include <utility>
      45             : 
      46             : using namespace llvm;
      47             : 
      48             : #define DEBUG_TYPE "assembler"
      49             : 
      50             : namespace {
      51             : namespace stats {
      52             : 
      53             : STATISTIC(EmittedFragments, "Number of emitted assembler fragments - total");
      54             : STATISTIC(EmittedRelaxableFragments,
      55             :           "Number of emitted assembler fragments - relaxable");
      56             : STATISTIC(EmittedDataFragments,
      57             :           "Number of emitted assembler fragments - data");
      58             : STATISTIC(EmittedCompactEncodedInstFragments,
      59             :           "Number of emitted assembler fragments - compact encoded inst");
      60             : STATISTIC(EmittedAlignFragments,
      61             :           "Number of emitted assembler fragments - align");
      62             : STATISTIC(EmittedFillFragments,
      63             :           "Number of emitted assembler fragments - fill");
      64             : STATISTIC(EmittedOrgFragments,
      65             :           "Number of emitted assembler fragments - org");
      66             : STATISTIC(evaluateFixup, "Number of evaluated fixups");
      67             : STATISTIC(FragmentLayouts, "Number of fragment layouts");
      68             : STATISTIC(ObjectBytes, "Number of emitted object file bytes");
      69             : STATISTIC(RelaxationSteps, "Number of assembler layout and relaxation steps");
      70             : STATISTIC(RelaxedInstructions, "Number of relaxed instructions");
      71             : STATISTIC(PaddingFragmentsRelaxations,
      72             :           "Number of Padding Fragments relaxations");
      73             : STATISTIC(PaddingFragmentsBytes,
      74             :           "Total size of all padding from adding Fragments");
      75             : 
      76             : } // end namespace stats
      77             : } // end anonymous namespace
      78             : 
      79             : // FIXME FIXME FIXME: There are number of places in this file where we convert
      80             : // what is a 64-bit assembler value used for computation into a value in the
      81             : // object file, which may truncate it. We should detect that truncation where
      82             : // invalid and report errors back.
      83             : 
      84             : /* *** */
      85             : 
      86       29300 : MCAssembler::MCAssembler(MCContext &Context,
      87             :                          std::unique_ptr<MCAsmBackend> Backend,
      88             :                          std::unique_ptr<MCCodeEmitter> Emitter,
      89       29300 :                          std::unique_ptr<MCObjectWriter> Writer)
      90             :     : Context(Context), Backend(std::move(Backend)),
      91             :       Emitter(std::move(Emitter)), Writer(std::move(Writer)),
      92             :       BundleAlignSize(0), RelaxAll(false), SubsectionsViaSymbols(false),
      93       58600 :       IncrementalLinkerCompatible(false), ELFHeaderEFlags(0) {
      94       29300 :   VersionInfo.Major = 0; // Major version == 0 for "none specified"
      95       29300 : }
      96             : 
      97             : MCAssembler::~MCAssembler() = default;
      98             : 
      99        4344 : void MCAssembler::reset() {
     100             :   Sections.clear();
     101             :   Symbols.clear();
     102             :   IndirectSymbols.clear();
     103             :   DataRegions.clear();
     104             :   LinkerOptions.clear();
     105        4344 :   FileNames.clear();
     106        4344 :   ThumbFuncs.clear();
     107        4344 :   BundleAlignSize = 0;
     108        4344 :   RelaxAll = false;
     109        4344 :   SubsectionsViaSymbols = false;
     110        4344 :   IncrementalLinkerCompatible = false;
     111        4344 :   ELFHeaderEFlags = 0;
     112             :   LOHContainer.reset();
     113        4344 :   VersionInfo.Major = 0;
     114             : 
     115             :   // reset objects owned by us
     116        4344 :   if (getBackendPtr())
     117        4344 :     getBackendPtr()->reset();
     118        4344 :   if (getEmitterPtr())
     119        4344 :     getEmitterPtr()->reset();
     120        4344 :   if (getWriterPtr())
     121        4344 :     getWriterPtr()->reset();
     122             :   getLOHContainer().reset();
     123        4344 : }
     124             : 
     125      552848 : bool MCAssembler::registerSection(MCSection &Section) {
     126      552848 :   if (Section.isRegistered())
     127             :     return false;
     128      906176 :   Sections.push_back(&Section);
     129             :   Section.setIsRegistered(true);
     130      453088 :   return true;
     131             : }
     132             : 
     133     5947982 : bool MCAssembler::isThumbFunc(const MCSymbol *Symbol) const {
     134     5947982 :   if (ThumbFuncs.count(Symbol))
     135             :     return true;
     136             : 
     137     5947339 :   if (!Symbol->isVariable())
     138             :     return false;
     139             : 
     140             :   const MCExpr *Expr = Symbol->getVariableValue();
     141             : 
     142         550 :   MCValue V;
     143         550 :   if (!Expr->evaluateAsRelocatable(V, nullptr, nullptr))
     144             :     return false;
     145             : 
     146         549 :   if (V.getSymB() || V.getRefKind() != MCSymbolRefExpr::VK_None)
     147             :     return false;
     148             : 
     149         535 :   const MCSymbolRefExpr *Ref = V.getSymA();
     150         535 :   if (!Ref)
     151             :     return false;
     152             : 
     153         343 :   if (Ref->getKind() != MCSymbolRefExpr::VK_None)
     154             :     return false;
     155             : 
     156         343 :   const MCSymbol &Sym = Ref->getSymbol();
     157         343 :   if (!isThumbFunc(&Sym))
     158             :     return false;
     159             : 
     160           4 :   ThumbFuncs.insert(Symbol); // Cache it.
     161           4 :   return true;
     162             : }
     163             : 
     164       84493 : bool MCAssembler::isSymbolLinkerVisible(const MCSymbol &Symbol) const {
     165             :   // Non-temporary labels should always be visible to the linker.
     166       84493 :   if (!Symbol.isTemporary())
     167             :     return true;
     168             : 
     169             :   // Absolute temporary labels are never visible.
     170       75988 :   if (!Symbol.isInSection())
     171             :     return false;
     172             : 
     173       47527 :   if (Symbol.isUsedInReloc())
     174             :     return true;
     175             : 
     176       47461 :   return false;
     177             : }
     178             : 
     179        1867 : const MCSymbol *MCAssembler::getAtom(const MCSymbol &S) const {
     180             :   // Linker visible symbols define atoms.
     181        1867 :   if (isSymbolLinkerVisible(S))
     182             :     return &S;
     183             : 
     184             :   // Absolute and undefined symbols have no defining atom.
     185        1162 :   if (!S.isInSection())
     186             :     return nullptr;
     187             : 
     188             :   // Non-linker visible symbols in sections which can't be atomized have no
     189             :   // defining atom.
     190        1780 :   if (!getContext().getAsmInfo()->isSectionAtomizableBySymbols(
     191         890 :           *S.getFragment()->getParent()))
     192             :     return nullptr;
     193             : 
     194             :   // Otherwise, return the atom for the containing fragment.
     195         840 :   return S.getFragment()->getAtom();
     196             : }
     197             : 
     198     2715733 : bool MCAssembler::evaluateFixup(const MCAsmLayout &Layout,
     199             :                                 const MCFixup &Fixup, const MCFragment *DF,
     200             :                                 MCValue &Target, uint64_t &Value,
     201             :                                 bool &WasForced) const {
     202             :   ++stats::evaluateFixup;
     203             : 
     204             :   // FIXME: This code has some duplication with recordRelocation. We should
     205             :   // probably merge the two into a single callback that tries to evaluate a
     206             :   // fixup and records a relocation if one is needed.
     207             : 
     208             :   // On error claim to have completely evaluated the fixup, to prevent any
     209             :   // further processing from being done.
     210     2715733 :   const MCExpr *Expr = Fixup.getValue();
     211     2715733 :   MCContext &Ctx = getContext();
     212     2715733 :   Value = 0;
     213     2715733 :   WasForced = false;
     214     2715733 :   if (!Expr->evaluateAsRelocatable(Target, &Layout, &Fixup)) {
     215          13 :     Ctx.reportError(Fixup.getLoc(), "expected relocatable expression");
     216          13 :     return true;
     217             :   }
     218     2715720 :   if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
     219       48621 :     if (RefB->getKind() != MCSymbolRefExpr::VK_None) {
     220           6 :       Ctx.reportError(Fixup.getLoc(),
     221             :                       "unsupported subtraction of qualified symbol");
     222           6 :       return true;
     223             :     }
     224             :   }
     225             : 
     226             :   assert(getBackendPtr() && "Expected assembler backend");
     227     2715714 :   bool IsPCRel = getBackendPtr()->getFixupKindInfo(Fixup.getKind()).Flags &
     228             :                  MCFixupKindInfo::FKF_IsPCRel;
     229             : 
     230             :   bool IsResolved = false;
     231     2715714 :   if (IsPCRel) {
     232      680615 :     if (Target.getSymB()) {
     233             :       IsResolved = false;
     234      680610 :     } else if (!Target.getSymA()) {
     235             :       IsResolved = false;
     236             :     } else {
     237             :       const MCSymbolRefExpr *A = Target.getSymA();
     238      680597 :       const MCSymbol &SA = A->getSymbol();
     239     1306858 :       if (A->getKind() != MCSymbolRefExpr::VK_None || SA.isUndefined()) {
     240             :         IsResolved = false;
     241      595947 :       } else if (auto *Writer = getWriterPtr()) {
     242      595947 :         IsResolved = Writer->isSymbolRefDifferenceFullyResolvedImpl(
     243      595947 :             *this, SA, *DF, false, true);
     244             :       }
     245             :     }
     246             :   } else {
     247     2035099 :     IsResolved = Target.isAbsolute();
     248             :   }
     249             : 
     250     2715714 :   Value = Target.getConstant();
     251             : 
     252     2715714 :   if (const MCSymbolRefExpr *A = Target.getSymA()) {
     253     2541251 :     const MCSymbol &Sym = A->getSymbol();
     254     2541251 :     if (Sym.isDefined())
     255     2451743 :       Value += Layout.getSymbolOffset(Sym);
     256             :   }
     257     2715713 :   if (const MCSymbolRefExpr *B = Target.getSymB()) {
     258       48615 :     const MCSymbol &Sym = B->getSymbol();
     259       48615 :     if (Sym.isDefined())
     260       48590 :       Value -= Layout.getSymbolOffset(Sym);
     261             :   }
     262             : 
     263     2715713 :   bool ShouldAlignPC = getBackend().getFixupKindInfo(Fixup.getKind()).Flags &
     264             :                        MCFixupKindInfo::FKF_IsAlignedDownTo32Bits;
     265             :   assert((ShouldAlignPC ? IsPCRel : true) &&
     266             :     "FKF_IsAlignedDownTo32Bits is only allowed on PC-relative fixups!");
     267             : 
     268     2715713 :   if (IsPCRel) {
     269      680615 :     uint32_t Offset = Layout.getFragmentOffset(DF) + Fixup.getOffset();
     270             : 
     271             :     // A number of ARM fixups in Thumb mode require that the effective PC
     272             :     // address be determined as the 32-bit aligned version of the actual offset.
     273      680615 :     if (ShouldAlignPC) Offset &= ~0x3;
     274      680615 :     Value -= Offset;
     275             :   }
     276             : 
     277             :   // Let the backend force a relocation if needed.
     278     3146838 :   if (IsResolved && getBackend().shouldForceRelocation(*this, Fixup, Target)) {
     279             :     IsResolved = false;
     280         174 :     WasForced = true;
     281             :   }
     282             : 
     283             :   return IsResolved;
     284             : }
     285             : 
     286     6875415 : uint64_t MCAssembler::computeFragmentSize(const MCAsmLayout &Layout,
     287             :                                           const MCFragment &F) const {
     288             :   assert(getBackendPtr() && "Requires assembler backend");
     289     6875415 :   switch (F.getKind()) {
     290             :   case MCFragment::FT_Data:
     291     3752566 :     return cast<MCDataFragment>(F).getContents().size();
     292             :   case MCFragment::FT_Relaxable:
     293      182182 :     return cast<MCRelaxableFragment>(F).getContents().size();
     294             :   case MCFragment::FT_CompactEncodedInst:
     295         408 :     return cast<MCCompactEncodedInstFragment>(F).getContents().size();
     296             :   case MCFragment::FT_Fill: {
     297             :     auto &FF = cast<MCFillFragment>(F);
     298      399834 :     int64_t NumValues = 0;
     299      399834 :     if (!FF.getNumValues().evaluateAsAbsolute(NumValues, Layout)) {
     300           4 :       getContext().reportError(FF.getLoc(),
     301             :                                "expected assembly-time absolute expression");
     302           2 :       return 0;
     303             :     }
     304      399832 :     int64_t Size = NumValues * FF.getValueSize();
     305      399832 :     if (Size < 0) {
     306           8 :       getContext().reportError(FF.getLoc(), "invalid number of bytes");
     307           4 :       return 0;
     308             :     }
     309      399828 :     return Size;
     310             :   }
     311             : 
     312             :   case MCFragment::FT_LEB:
     313      209519 :     return cast<MCLEBFragment>(F).getContents().size();
     314             : 
     315             :   case MCFragment::FT_Padding:
     316           0 :     return cast<MCPaddingFragment>(F).getSize();
     317             : 
     318             :   case MCFragment::FT_SymbolId:
     319             :     return 4;
     320             : 
     321             :   case MCFragment::FT_Align: {
     322             :     const MCAlignFragment &AF = cast<MCAlignFragment>(F);
     323      369104 :     unsigned Offset = Layout.getFragmentOffset(&AF);
     324      738208 :     unsigned Size = OffsetToAlignment(Offset, AF.getAlignment());
     325             :     // If we are padding with nops, force the padding to be larger than the
     326             :     // minimum nop size.
     327      544889 :     if (Size > 0 && AF.hasEmitNops()) {
     328       23432 :       while (Size % getBackend().getMinimumNopSize())
     329           0 :         Size += AF.getAlignment();
     330             :     }
     331      369104 :     if (Size > AF.getMaxBytesToEmit())
     332             :       return 0;
     333      369095 :     return Size;
     334             :   }
     335             : 
     336             :   case MCFragment::FT_Org: {
     337             :     const MCOrgFragment &OF = cast<MCOrgFragment>(F);
     338          40 :     MCValue Value;
     339          40 :     if (!OF.getOffset().evaluateAsValue(Value, Layout)) {
     340           4 :       getContext().reportError(OF.getLoc(),
     341             :                                "expected assembly-time absolute expression");
     342           2 :         return 0;
     343             :     }
     344             : 
     345          38 :     uint64_t FragmentOffset = Layout.getFragmentOffset(&OF);
     346          38 :     int64_t TargetLocation = Value.getConstant();
     347          38 :     if (const MCSymbolRefExpr *A = Value.getSymA()) {
     348             :       uint64_t Val;
     349          15 :       if (!Layout.getSymbolOffset(A->getSymbol(), Val)) {
     350           8 :         getContext().reportError(OF.getLoc(), "expected absolute expression");
     351           4 :         return 0;
     352             :       }
     353          11 :       TargetLocation += Val;
     354             :     }
     355          34 :     int64_t Size = TargetLocation - FragmentOffset;
     356          34 :     if (Size < 0 || Size >= 0x40000000) {
     357           8 :       getContext().reportError(
     358           4 :           OF.getLoc(), "invalid .org offset '" + Twine(TargetLocation) +
     359           8 :                            "' (at offset '" + Twine(FragmentOffset) + "')");
     360           4 :       return 0;
     361             :     }
     362             :     return Size;
     363             :   }
     364             : 
     365             :   case MCFragment::FT_Dwarf:
     366     1442224 :     return cast<MCDwarfLineAddrFragment>(F).getContents().size();
     367             :   case MCFragment::FT_DwarfFrame:
     368      519098 :     return cast<MCDwarfCallFrameFragment>(F).getContents().size();
     369             :   case MCFragment::FT_CVInlineLines:
     370          46 :     return cast<MCCVInlineLineTableFragment>(F).getContents().size();
     371             :   case MCFragment::FT_CVDefRange:
     372         362 :     return cast<MCCVDefRangeFragment>(F).getContents().size();
     373           0 :   case MCFragment::FT_Dummy:
     374           0 :     llvm_unreachable("Should not have been added");
     375             :   }
     376             : 
     377           0 :   llvm_unreachable("invalid fragment kind");
     378             : }
     379             : 
     380     3614282 : void MCAsmLayout::layoutFragment(MCFragment *F) {
     381             :   MCFragment *Prev = F->getPrevNode();
     382             : 
     383             :   // We should never try to recompute something which is valid.
     384             :   assert(!isFragmentValid(F) && "Attempt to recompute a valid fragment!");
     385             :   // We should never try to compute the fragment layout if its predecessor
     386             :   // isn't valid.
     387             :   assert((!Prev || isFragmentValid(Prev)) &&
     388             :          "Attempt to compute fragment before its predecessor!");
     389             : 
     390             :   ++stats::FragmentLayouts;
     391             : 
     392             :   // Compute fragment offset and size.
     393     3161334 :   if (Prev)
     394     3161334 :     F->Offset = Prev->Offset + getAssembler().computeFragmentSize(*this, *Prev);
     395             :   else
     396      452948 :     F->Offset = 0;
     397     7228564 :   LastValidFragment[F->getParent()] = F;
     398             : 
     399             :   // If bundling is enabled and this fragment has instructions in it, it has to
     400             :   // obey the bundling restrictions. With padding, we'll have:
     401             :   //
     402             :   //
     403             :   //        BundlePadding
     404             :   //             |||
     405             :   // -------------------------------------
     406             :   //   Prev  |##########|       F        |
     407             :   // -------------------------------------
     408             :   //                    ^
     409             :   //                    |
     410             :   //                    F->Offset
     411             :   //
     412             :   // The fragment's offset will point to after the padding, and its computed
     413             :   // size won't include the padding.
     414             :   //
     415             :   // When the -mc-relax-all flag is used, we optimize bundling by writting the
     416             :   // padding directly into fragments when the instructions are emitted inside
     417             :   // the streamer. When the fragment is larger than the bundle size, we need to
     418             :   // ensure that it's bundle aligned. This means that if we end up with
     419             :   // multiple fragments, we must emit bundle padding between fragments.
     420             :   //
     421             :   // ".align N" is an example of a directive that introduces multiple
     422             :   // fragments. We could add a special case to handle ".align N" by emitting
     423             :   // within-fragment padding (which would produce less padding when N is less
     424             :   // than the bundle size), but for now we don't.
     425             :   //
     426     3614282 :   if (Assembler.isBundlingEnabled() && F->hasInstructions()) {
     427             :     assert(isa<MCEncodedFragment>(F) &&
     428             :            "Only MCEncodedFragment implementations have instructions");
     429             :     MCEncodedFragment *EF = cast<MCEncodedFragment>(F);
     430         758 :     uint64_t FSize = Assembler.computeFragmentSize(*this, *EF);
     431             : 
     432        1516 :     if (!Assembler.getRelaxAll() && FSize > Assembler.getBundleAlignSize())
     433           1 :       report_fatal_error("Fragment can't be larger than a bundle size");
     434             : 
     435             :     uint64_t RequiredBundlePadding =
     436         757 :         computeBundlePadding(Assembler, EF, EF->Offset, FSize);
     437         757 :     if (RequiredBundlePadding > UINT8_MAX)
     438           0 :       report_fatal_error("Padding cannot exceed 255 bytes");
     439         757 :     EF->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
     440         757 :     EF->Offset += RequiredBundlePadding;
     441             :   }
     442     3614281 : }
     443             : 
     444     6472499 : void MCAssembler::registerSymbol(const MCSymbol &Symbol, bool *Created) {
     445     6472499 :   bool New = !Symbol.isRegistered();
     446     6472499 :   if (Created)
     447          19 :     *Created = New;
     448     6472499 :   if (New) {
     449             :     Symbol.setIsRegistered(true);
     450     6552800 :     Symbols.push_back(&Symbol);
     451             :   }
     452     6472499 : }
     453             : 
     454     1825199 : void MCAssembler::writeFragmentPadding(raw_ostream &OS,
     455             :                                        const MCEncodedFragment &EF,
     456             :                                        uint64_t FSize) const {
     457             :   assert(getBackendPtr() && "Expected assembler backend");
     458             :   // Should NOP padding be written out before this fragment?
     459     1825199 :   unsigned BundlePadding = EF.getBundlePadding();
     460     1825199 :   if (BundlePadding > 0) {
     461             :     assert(isBundlingEnabled() &&
     462             :            "Writing bundle padding with disabled bundling");
     463             :     assert(EF.hasInstructions() &&
     464             :            "Writing bundle padding for a fragment without instructions");
     465             : 
     466         431 :     unsigned TotalLength = BundlePadding + static_cast<unsigned>(FSize);
     467         431 :     if (EF.alignToBundleEnd() && TotalLength > getBundleAlignSize()) {
     468             :       // If the padding itself crosses a bundle boundary, it must be emitted
     469             :       // in 2 pieces, since even nop instructions must not cross boundaries.
     470             :       //             v--------------v   <- BundleAlignSize
     471             :       //        v---------v             <- BundlePadding
     472             :       // ----------------------------
     473             :       // | Prev |####|####|    F    |
     474             :       // ----------------------------
     475             :       //        ^-------------------^   <- TotalLength
     476         128 :       unsigned DistanceToBoundary = TotalLength - getBundleAlignSize();
     477         128 :       if (!getBackend().writeNopData(OS, DistanceToBoundary))
     478           0 :         report_fatal_error("unable to write NOP sequence of " +
     479             :                            Twine(DistanceToBoundary) + " bytes");
     480         128 :       BundlePadding -= DistanceToBoundary;
     481             :     }
     482         431 :     if (!getBackend().writeNopData(OS, BundlePadding))
     483           0 :       report_fatal_error("unable to write NOP sequence of " +
     484             :                          Twine(BundlePadding) + " bytes");
     485             :   }
     486     1825199 : }
     487             : 
     488             : /// Write the fragment \p F to the output file.
     489     3203715 : static void writeFragment(raw_ostream &OS, const MCAssembler &Asm,
     490             :                           const MCAsmLayout &Layout, const MCFragment &F) {
     491             :   // FIXME: Embed in fragments instead?
     492     3203715 :   uint64_t FragmentSize = Asm.computeFragmentSize(Layout, F);
     493             : 
     494     3203715 :   support::endianness Endian = Asm.getBackend().Endian;
     495             : 
     496             :   if (const MCEncodedFragment *EF = dyn_cast<MCEncodedFragment>(&F))
     497     1825176 :     Asm.writeFragmentPadding(OS, *EF, FragmentSize);
     498             : 
     499             :   // This variable (and its dummy usage) is to participate in the assert at
     500             :   // the end of the function.
     501             :   uint64_t Start = OS.tell();
     502             :   (void) Start;
     503             : 
     504             :   ++stats::EmittedFragments;
     505             : 
     506     3203715 :   switch (F.getKind()) {
     507             :   case MCFragment::FT_Align: {
     508             :     ++stats::EmittedAlignFragments;
     509             :     const MCAlignFragment &AF = cast<MCAlignFragment>(F);
     510             :     assert(AF.getValueSize() && "Invalid virtual align in concrete fragment!");
     511             : 
     512      163534 :     uint64_t Count = FragmentSize / AF.getValueSize();
     513             : 
     514             :     // FIXME: This error shouldn't actually occur (the front end should emit
     515             :     // multiple .align directives to enforce the semantics it wants), but is
     516             :     // severe enough that we want to report it. How to handle this?
     517      163534 :     if (Count * AF.getValueSize() != FragmentSize)
     518           0 :       report_fatal_error("undefined .align directive, value size '" +
     519             :                         Twine(AF.getValueSize()) +
     520             :                         "' is not a divisor of padding size '" +
     521             :                         Twine(FragmentSize) + "'");
     522             : 
     523             :     // See if we are aligning with nops, and if so do that first to try to fill
     524             :     // the Count bytes.  Then if that did not fill any bytes or there are any
     525             :     // bytes left to fill use the Value and ValueSize to fill the rest.
     526             :     // If we are aligning with nops, ask that target to emit the right data.
     527      163534 :     if (AF.hasEmitNops()) {
     528       60908 :       if (!Asm.getBackend().writeNopData(OS, Count))
     529           0 :         report_fatal_error("unable to write nop sequence of " +
     530             :                           Twine(Count) + " bytes");
     531             :       break;
     532             :     }
     533             : 
     534             :     // Otherwise, write out in multiples of the value size.
     535      848132 :     for (uint64_t i = 0; i != Count; ++i) {
     536      372753 :       switch (AF.getValueSize()) {
     537           0 :       default: llvm_unreachable("Invalid size!");
     538      372750 :       case 1: OS << char(AF.getValue()); break;
     539           3 :       case 2:
     540           3 :         support::endian::write<uint16_t>(OS, AF.getValue(), Endian);
     541             :         break;
     542           0 :       case 4:
     543           0 :         support::endian::write<uint32_t>(OS, AF.getValue(), Endian);
     544             :         break;
     545           0 :       case 8:
     546           0 :         support::endian::write<uint64_t>(OS, AF.getValue(), Endian);
     547             :         break;
     548             :       }
     549             :     }
     550             :     break;
     551             :   }
     552             : 
     553             :   case MCFragment::FT_Data: 
     554             :     ++stats::EmittedDataFragments;
     555             :     OS << cast<MCDataFragment>(F).getContents();
     556             :     break;
     557             : 
     558             :   case MCFragment::FT_Relaxable:
     559             :     ++stats::EmittedRelaxableFragments;
     560             :     OS << cast<MCRelaxableFragment>(F).getContents();
     561             :     break;
     562             : 
     563             :   case MCFragment::FT_CompactEncodedInst:
     564             :     ++stats::EmittedCompactEncodedInstFragments;
     565             :     OS << cast<MCCompactEncodedInstFragment>(F).getContents();
     566             :     break;
     567             : 
     568             :   case MCFragment::FT_Fill: {
     569             :     ++stats::EmittedFillFragments;
     570             :     const MCFillFragment &FF = cast<MCFillFragment>(F);
     571      175068 :     uint64_t V = FF.getValue();
     572      175068 :     unsigned VSize = FF.getValueSize();
     573             :     const unsigned MaxChunkSize = 16;
     574             :     char Data[MaxChunkSize];
     575             :     // Duplicate V into Data as byte vector to reduce number of
     576             :     // writes done. As such, do endian conversion here.
     577      525218 :     for (unsigned I = 0; I != VSize; ++I) {
     578      175075 :       unsigned index = Endian == support::little ? I : (VSize - I - 1);
     579      175075 :       Data[I] = uint8_t(V >> (index * 8));
     580             :     }
     581     5427094 :     for (unsigned I = VSize; I < MaxChunkSize; ++I)
     582     2626013 :       Data[I] = Data[I - VSize];
     583             : 
     584             :     // Set to largest multiple of VSize in Data.
     585      175068 :     const unsigned NumPerChunk = MaxChunkSize / VSize;
     586             :     // Set ChunkSize to largest multiple of VSize in Data
     587      175068 :     const unsigned ChunkSize = VSize * NumPerChunk;
     588             : 
     589             :     // Do copies by chunk.
     590      175068 :     StringRef Ref(Data, ChunkSize);
     591   109867835 :     for (uint64_t I = 0, E = FragmentSize / ChunkSize; I != E; ++I)
     592   109692767 :       OS << Ref;
     593             : 
     594             :     // do remainder if needed.
     595      175068 :     unsigned TrailingCount = FragmentSize % ChunkSize;
     596      175068 :     if (TrailingCount)
     597       61525 :       OS.write(Data, TrailingCount);
     598             :     break;
     599             :   }
     600             : 
     601             :   case MCFragment::FT_LEB: {
     602             :     const MCLEBFragment &LF = cast<MCLEBFragment>(F);
     603             :     OS << LF.getContents();
     604             :     break;
     605             :   }
     606             : 
     607             :   case MCFragment::FT_Padding: {
     608           0 :     if (!Asm.getBackend().writeNopData(OS, FragmentSize))
     609           0 :       report_fatal_error("unable to write nop sequence of " +
     610             :                          Twine(FragmentSize) + " bytes");
     611             :     break;
     612             :   }
     613             : 
     614             :   case MCFragment::FT_SymbolId: {
     615             :     const MCSymbolIdFragment &SF = cast<MCSymbolIdFragment>(F);
     616          12 :     support::endian::write<uint32_t>(OS, SF.getSymbol()->getIndex(), Endian);
     617             :     break;
     618             :   }
     619             : 
     620             :   case MCFragment::FT_Org: {
     621             :     ++stats::EmittedOrgFragments;
     622             :     const MCOrgFragment &OF = cast<MCOrgFragment>(F);
     623             : 
     624        2482 :     for (uint64_t i = 0, e = FragmentSize; i != e; ++i)
     625        2463 :       OS << char(OF.getValue());
     626             : 
     627             :     break;
     628             :   }
     629             : 
     630             :   case MCFragment::FT_Dwarf: {
     631             :     const MCDwarfLineAddrFragment &OF = cast<MCDwarfLineAddrFragment>(F);
     632             :     OS << OF.getContents();
     633             :     break;
     634             :   }
     635             :   case MCFragment::FT_DwarfFrame: {
     636             :     const MCDwarfCallFrameFragment &CF = cast<MCDwarfCallFrameFragment>(F);
     637             :     OS << CF.getContents();
     638             :     break;
     639             :   }
     640             :   case MCFragment::FT_CVInlineLines: {
     641             :     const auto &OF = cast<MCCVInlineLineTableFragment>(F);
     642             :     OS << OF.getContents();
     643             :     break;
     644             :   }
     645             :   case MCFragment::FT_CVDefRange: {
     646             :     const auto &DRF = cast<MCCVDefRangeFragment>(F);
     647             :     OS << DRF.getContents();
     648             :     break;
     649             :   }
     650           0 :   case MCFragment::FT_Dummy:
     651           0 :     llvm_unreachable("Should not have been added");
     652             :   }
     653             : 
     654             :   assert(OS.tell() - Start == FragmentSize &&
     655             :          "The stream should advance by fragment size");
     656     3203715 : }
     657             : 
     658      452318 : void MCAssembler::writeSectionData(raw_ostream &OS, const MCSection *Sec,
     659             :                                    const MCAsmLayout &Layout) const {
     660             :   assert(getBackendPtr() && "Expected assembler backend");
     661             : 
     662             :   // Ignore virtual sections.
     663      452318 :   if (Sec->isVirtualSection()) {
     664             :     assert(Layout.getSectionFileSize(Sec) == 0 && "Invalid size for section!");
     665             : 
     666             :     // Check that contents are only things legal inside a virtual section.
     667      127912 :     for (const MCFragment &F : *Sec) {
     668      102433 :       switch (F.getKind()) {
     669           0 :       default: llvm_unreachable("Invalid fragment in virtual section!");
     670             :       case MCFragment::FT_Data: {
     671             :         // Check that we aren't trying to write a non-zero contents (or fixups)
     672             :         // into a virtual section. This is to support clients which use standard
     673             :         // directives to fill the contents of virtual sections.
     674             :         const MCDataFragment &DF = cast<MCDataFragment>(F);
     675       51442 :         if (DF.fixup_begin() != DF.fixup_end())
     676           1 :           report_fatal_error("cannot have fixups in virtual section!");
     677       57033 :         for (unsigned i = 0, e = DF.getContents().size(); i != e; ++i)
     678       11186 :           if (DF.getContents()[i]) {
     679             :             if (auto *ELFSec = dyn_cast<const MCSectionELF>(Sec))
     680           1 :               report_fatal_error("non-zero initializer found in section '" +
     681           1 :                   ELFSec->getSectionName() + "'");
     682             :             else
     683           0 :               report_fatal_error("non-zero initializer found in virtual section");
     684             :           }
     685             :         break;
     686             :       }
     687             :       case MCFragment::FT_Align:
     688             :         // Check that we aren't trying to write a non-zero value into a virtual
     689             :         // section.
     690             :         assert((cast<MCAlignFragment>(F).getValueSize() == 0 ||
     691             :                 cast<MCAlignFragment>(F).getValue() == 0) &&
     692             :                "Invalid align in virtual section!");
     693             :         break;
     694             :       case MCFragment::FT_Fill:
     695             :         assert((cast<MCFillFragment>(F).getValue() == 0) &&
     696             :                "Invalid fill in virtual section!");
     697             :         break;
     698             :       }
     699             :     }
     700             : 
     701             :     return;
     702             :   }
     703             : 
     704             :   uint64_t Start = OS.tell();
     705             :   (void)Start;
     706             : 
     707     3630552 :   for (const MCFragment &F : *Sec)
     708     3203715 :     writeFragment(OS, *this, Layout, F);
     709             : 
     710             :   assert(OS.tell() - Start == Layout.getSectionAddressSize(Sec));
     711             : }
     712             : 
     713             : std::tuple<MCValue, uint64_t, bool>
     714     2565723 : MCAssembler::handleFixup(const MCAsmLayout &Layout, MCFragment &F,
     715             :                          const MCFixup &Fixup) {
     716             :   // Evaluate the fixup.
     717     2565723 :   MCValue Target;
     718             :   uint64_t FixedValue;
     719             :   bool WasForced;
     720     2565723 :   bool IsResolved = evaluateFixup(Layout, Fixup, &F, Target, FixedValue,
     721             :                                   WasForced);
     722     2565722 :   if (!IsResolved) {
     723             :     // The fixup was unresolved, we need a relocation. Inform the object
     724             :     // writer of the relocation, and give it an opportunity to adjust the
     725             :     // fixup value if need be.
     726     2332211 :     if (Target.getSymA() && Target.getSymB() &&
     727       48612 :         getBackend().requiresDiffExpressionRelocations()) {
     728             :       // The fixup represents the difference between two symbols, which the
     729             :       // backend has indicated must be resolved at link time. Split up the fixup
     730             :       // into two relocations, one for the add, and one for the sub, and emit
     731             :       // both of these. The constant will be associated with the add half of the
     732             :       // expression.
     733             :       MCFixup FixupAdd = MCFixup::createAddFor(Fixup);
     734             :       MCValue TargetAdd =
     735           0 :           MCValue::get(Target.getSymA(), nullptr, Target.getConstant());
     736           0 :       getWriter().recordRelocation(*this, Layout, &F, FixupAdd, TargetAdd,
     737           0 :                                    FixedValue);
     738             :       MCFixup FixupSub = MCFixup::createSubFor(Fixup);
     739           0 :       MCValue TargetSub = MCValue::get(Target.getSymB());
     740           0 :       getWriter().recordRelocation(*this, Layout, &F, FixupSub, TargetSub,
     741           0 :                                    FixedValue);
     742             :     } else {
     743     2283599 :       getWriter().recordRelocation(*this, Layout, &F, Fixup, Target,
     744     2283599 :                                    FixedValue);
     745             :     }
     746             :   }
     747     5131428 :   return std::make_tuple(Target, FixedValue, IsResolved);
     748             : }
     749             : 
     750        7896 : void MCAssembler::layout(MCAsmLayout &Layout) {
     751             :   assert(getBackendPtr() && "Expected assembler backend");
     752             :   DEBUG_WITH_TYPE("mc-dump", {
     753             :       errs() << "assembler backend - pre-layout\n--\n";
     754             :       dump(); });
     755             : 
     756             :   // Create dummy fragments and assign section ordinals.
     757             :   unsigned SectionIndex = 0;
     758      460844 :   for (MCSection &Sec : *this) {
     759             :     // Create dummy fragments to eliminate any empty sections, this simplifies
     760             :     // layout.
     761      452948 :     if (Sec.getFragmentList().empty())
     762         187 :       new MCDataFragment(&Sec);
     763             : 
     764      452948 :     Sec.setOrdinal(SectionIndex++);
     765             :   }
     766             : 
     767             :   // Assign layout order indices to sections and fragments.
     768      460844 :   for (unsigned i = 0, e = Layout.getSectionOrder().size(); i != e; ++i) {
     769      905896 :     MCSection *Sec = Layout.getSectionOrder()[i];
     770             :     Sec->setLayoutOrder(i);
     771             : 
     772             :     unsigned FragmentIndex = 0;
     773     3760020 :     for (MCFragment &Frag : *Sec)
     774     3307072 :       Frag.setLayoutOrder(FragmentIndex++);
     775             :   }
     776             : 
     777             :   // Layout until everything fits.
     778       10644 :   while (layoutOnce(Layout))
     779        2748 :     if (getContext().hadError())
     780             :       return;
     781             : 
     782             :   DEBUG_WITH_TYPE("mc-dump", {
     783             :       errs() << "assembler backend - post-relaxation\n--\n";
     784             :       dump(); });
     785             : 
     786             :   // Finalize the layout, including fragment lowering.
     787        7895 :   finishLayout(Layout);
     788             : 
     789             :   DEBUG_WITH_TYPE("mc-dump", {
     790             :       errs() << "assembler backend - final-layout\n--\n";
     791             :       dump(); });
     792             : 
     793             :   // Allow the object writer a chance to perform post-layout binding (for
     794             :   // example, to set the index fields in the symbol data).
     795        7894 :   getWriter().executePostLayoutBinding(*this, Layout);
     796             : 
     797             :   // Evaluate and apply the fixups, generating relocation entries as necessary.
     798      460810 :   for (MCSection &Sec : *this) {
     799     3759965 :     for (MCFragment &Frag : Sec) {
     800             :       // Data and relaxable fragments both have fixups.  So only process
     801             :       // those here.
     802             :       // FIXME: Is there a better way to do this?  MCEncodedFragmentWithFixups
     803             :       // being templated makes this tricky.
     804     1876987 :       if (isa<MCEncodedFragment>(&Frag) &&
     805             :           isa<MCCompactEncodedInstFragment>(&Frag))
     806     1430147 :         continue;
     807     2859935 :       if (!isa<MCEncodedFragment>(&Frag) && !isa<MCCVDefRangeFragment>(&Frag))
     808     1429877 :         continue;
     809             :       ArrayRef<MCFixup> Fixups;
     810     1877033 :       MutableArrayRef<char> Contents;
     811             :       const MCSubtargetInfo *STI = nullptr;
     812             :       if (auto *FragWithFixups = dyn_cast<MCDataFragment>(&Frag)) {
     813             :         Fixups = FragWithFixups->getFixups();
     814     1814390 :         Contents = FragWithFixups->getContents();
     815     1814390 :         STI = FragWithFixups->getSubtargetInfo();
     816             :         assert(!FragWithFixups->hasInstructions() || STI != nullptr);
     817             :       } else if (auto *FragWithFixups = dyn_cast<MCRelaxableFragment>(&Frag)) {
     818             :         Fixups = FragWithFixups->getFixups();
     819       62462 :         Contents = FragWithFixups->getContents();
     820       62462 :         STI = FragWithFixups->getSubtargetInfo();
     821             :         assert(!FragWithFixups->hasInstructions() || STI != nullptr);
     822             :       } else if (auto *FragWithFixups = dyn_cast<MCCVDefRangeFragment>(&Frag)) {
     823             :         Fixups = FragWithFixups->getFixups();
     824         181 :         Contents = FragWithFixups->getContents();
     825             :       } else
     826           0 :         llvm_unreachable("Unknown fragment with fixups!");
     827     7008461 :       for (const MCFixup &Fixup : Fixups) {
     828             :         uint64_t FixedValue;
     829             :         bool IsResolved;
     830     2565723 :         MCValue Target;
     831             :         std::tie(Target, FixedValue, IsResolved) =
     832     5131437 :             handleFixup(Layout, Frag, Fixup);
     833     2565714 :         getBackend().applyFixup(*this, Fixup, Target, Contents, FixedValue,
     834     2565714 :                                 IsResolved, STI);
     835             :       }
     836             :     }
     837             :   }
     838             : }
     839             : 
     840        7847 : void MCAssembler::Finish() {
     841             :   // Create the layout object.
     842       15676 :   MCAsmLayout Layout(*this);
     843        7847 :   layout(Layout);
     844             : 
     845             :   // Write the object file.
     846        7832 :   stats::ObjectBytes += getWriter().writeObject(*this, Layout);
     847        7829 : }
     848             : 
     849      150010 : bool MCAssembler::fixupNeedsRelaxation(const MCFixup &Fixup,
     850             :                                        const MCRelaxableFragment *DF,
     851             :                                        const MCAsmLayout &Layout) const {
     852             :   assert(getBackendPtr() && "Expected assembler backend");
     853      150010 :   MCValue Target;
     854             :   uint64_t Value;
     855             :   bool WasForced;
     856      150010 :   bool Resolved = evaluateFixup(Layout, Fixup, DF, Target, Value, WasForced);
     857      300016 :   if (Target.getSymA() &&
     858      150012 :       Target.getSymA()->getKind() == MCSymbolRefExpr::VK_X86_ABS8 &&
     859           2 :       Fixup.getKind() == FK_Data_1)
     860             :     return false;
     861      150008 :   return getBackend().fixupNeedsRelaxationAdvanced(Fixup, Resolved, Value, DF,
     862      300016 :                                                    Layout, WasForced);
     863             : }
     864             : 
     865      215452 : bool MCAssembler::fragmentNeedsRelaxation(const MCRelaxableFragment *F,
     866             :                                           const MCAsmLayout &Layout) const {
     867             :   assert(getBackendPtr() && "Expected assembler backend");
     868             :   // If this inst doesn't ever need relaxation, ignore it. This occurs when we
     869             :   // are intentionally pushing out inst fragments, or because we relaxed a
     870             :   // previous instruction to one that doesn't need relaxation.
     871      430904 :   if (!getBackend().mayNeedRelaxation(F->getInst(), *F->getSubtargetInfo()))
     872             :     return false;
     873             : 
     874      404356 :   for (const MCFixup &Fixup : F->getFixups())
     875      150010 :     if (fixupNeedsRelaxation(Fixup, F, Layout))
     876             :       return true;
     877             : 
     878             :   return false;
     879             : }
     880             : 
     881      215452 : bool MCAssembler::relaxInstruction(MCAsmLayout &Layout,
     882             :                                    MCRelaxableFragment &F) {
     883             :   assert(getEmitterPtr() &&
     884             :          "Expected CodeEmitter defined for relaxInstruction");
     885      215452 :   if (!fragmentNeedsRelaxation(&F, Layout))
     886             :     return false;
     887             : 
     888             :   ++stats::RelaxedInstructions;
     889             : 
     890             :   // FIXME-PERF: We could immediately lower out instructions if we can tell
     891             :   // they are fully resolved, to avoid retesting on later passes.
     892             : 
     893             :   // Relax the fragment.
     894             : 
     895             :   MCInst Relaxed;
     896       48102 :   getBackend().relaxInstruction(F.getInst(), *F.getSubtargetInfo(), Relaxed);
     897             : 
     898             :   // Encode the new instruction.
     899             :   //
     900             :   // FIXME-PERF: If it matters, we could let the target do this. It can
     901             :   // probably do so more efficiently in many cases.
     902             :   SmallVector<MCFixup, 4> Fixups;
     903             :   SmallString<256> Code;
     904             :   raw_svector_ostream VecOS(Code);
     905       24051 :   getEmitter().encodeInstruction(Relaxed, VecOS, Fixups, *F.getSubtargetInfo());
     906             : 
     907             :   // Update the fragment.
     908             :   F.setInst(Relaxed);
     909       24051 :   F.getContents() = Code;
     910       24051 :   F.getFixups() = Fixups;
     911             : 
     912             :   return true;
     913             : }
     914             : 
     915           0 : bool MCAssembler::relaxPaddingFragment(MCAsmLayout &Layout,
     916             :                                        MCPaddingFragment &PF) {
     917             :   assert(getBackendPtr() && "Expected assembler backend");
     918             :   uint64_t OldSize = PF.getSize();
     919           0 :   if (!getBackend().relaxFragment(&PF, Layout))
     920             :     return false;
     921             :   uint64_t NewSize = PF.getSize();
     922             : 
     923             :   ++stats::PaddingFragmentsRelaxations;
     924             :   stats::PaddingFragmentsBytes += NewSize;
     925             :   stats::PaddingFragmentsBytes -= OldSize;
     926           0 :   return true;
     927             : }
     928             : 
     929      258386 : bool MCAssembler::relaxLEB(MCAsmLayout &Layout, MCLEBFragment &LF) {
     930             :   uint64_t OldSize = LF.getContents().size();
     931             :   int64_t Value;
     932      258386 :   bool Abs = LF.getValue().evaluateKnownAbsolute(Value, Layout);
     933      258386 :   if (!Abs)
     934           1 :     report_fatal_error("sleb128 and uleb128 expressions must be absolute");
     935             :   SmallString<8> &Data = LF.getContents();
     936      258385 :   Data.clear();
     937             :   raw_svector_ostream OSE(Data);
     938             :   // The compiler can generate EH table assembly that is impossible to assemble
     939             :   // without either adding padding to an LEB fragment or adding extra padding
     940             :   // to a later alignment fragment. To accommodate such tables, relaxation can
     941             :   // only increase an LEB fragment size here, not decrease it. See PR35809.
     942      258385 :   if (LF.isSigned())
     943           3 :     encodeSLEB128(Value, OSE, OldSize);
     944             :   else
     945      258382 :     encodeULEB128(Value, OSE, OldSize);
     946      516770 :   return OldSize != LF.getContents().size();
     947             : }
     948             : 
     949     2382408 : bool MCAssembler::relaxDwarfLineAddr(MCAsmLayout &Layout,
     950             :                                      MCDwarfLineAddrFragment &DF) {
     951     2382408 :   MCContext &Context = Layout.getAssembler().getContext();
     952             :   uint64_t OldSize = DF.getContents().size();
     953             :   int64_t AddrDelta;
     954     2382408 :   bool Abs = DF.getAddrDelta().evaluateKnownAbsolute(AddrDelta, Layout);
     955             :   assert(Abs && "We created a line delta with an invalid expression");
     956             :   (void) Abs;
     957             :   int64_t LineDelta;
     958     2382408 :   LineDelta = DF.getLineDelta();
     959             :   SmallString<8> &Data = DF.getContents();
     960     2382408 :   Data.clear();
     961             :   raw_svector_ostream OSE(Data);
     962     4764816 :   MCDwarfLineAddr::Encode(Context, getDWARFLinetableParams(), LineDelta,
     963             :                           AddrDelta, OSE);
     964     4764816 :   return OldSize != Data.size();
     965             : }
     966             : 
     967      813590 : bool MCAssembler::relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
     968             :                                               MCDwarfCallFrameFragment &DF) {
     969      813590 :   MCContext &Context = Layout.getAssembler().getContext();
     970             :   uint64_t OldSize = DF.getContents().size();
     971             :   int64_t AddrDelta;
     972      813590 :   bool Abs = DF.getAddrDelta().evaluateKnownAbsolute(AddrDelta, Layout);
     973             :   assert(Abs && "We created call frame with an invalid expression");
     974             :   (void) Abs;
     975             :   SmallString<8> &Data = DF.getContents();
     976      813590 :   Data.clear();
     977             :   raw_svector_ostream OSE(Data);
     978      813590 :   MCDwarfFrameEmitter::EncodeAdvanceLoc(Context, AddrDelta, OSE);
     979     1627180 :   return OldSize != Data.size();
     980             : }
     981             : 
     982          69 : bool MCAssembler::relaxCVInlineLineTable(MCAsmLayout &Layout,
     983             :                                          MCCVInlineLineTableFragment &F) {
     984             :   unsigned OldSize = F.getContents().size();
     985          69 :   getContext().getCVContext().encodeInlineLineTable(Layout, F);
     986          69 :   return OldSize != F.getContents().size();
     987             : }
     988             : 
     989         543 : bool MCAssembler::relaxCVDefRange(MCAsmLayout &Layout,
     990             :                                   MCCVDefRangeFragment &F) {
     991             :   unsigned OldSize = F.getContents().size();
     992         543 :   getContext().getCVContext().encodeDefRange(Layout, F);
     993         543 :   return OldSize != F.getContents().size();
     994             : }
     995             : 
     996      581851 : bool MCAssembler::layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec) {
     997             :   // Holds the first fragment which needed relaxing during this layout. It will
     998             :   // remain NULL if none were relaxed.
     999             :   // When a fragment is relaxed, all the fragments following it should get
    1000             :   // invalidated because their offset is going to change.
    1001             :   MCFragment *FirstRelaxedFragment = nullptr;
    1002             : 
    1003             :   // Attempt to relax all the fragments in the section.
    1004     9988029 :   for (MCSection::iterator I = Sec.begin(), IE = Sec.end(); I != IE; ++I) {
    1005             :     // Check if this is a fragment that needs relaxation.
    1006             :     bool RelaxedFrag = false;
    1007     9406179 :     switch(I->getKind()) {
    1008             :     default:
    1009             :       break;
    1010             :     case MCFragment::FT_Relaxable:
    1011             :       assert(!getRelaxAll() &&
    1012             :              "Did not expect a MCRelaxableFragment in RelaxAll mode");
    1013      215452 :       RelaxedFrag = relaxInstruction(Layout, *cast<MCRelaxableFragment>(I));
    1014      215452 :       break;
    1015             :     case MCFragment::FT_Dwarf:
    1016     2382408 :       RelaxedFrag = relaxDwarfLineAddr(Layout,
    1017             :                                        *cast<MCDwarfLineAddrFragment>(I));
    1018     2382408 :       break;
    1019             :     case MCFragment::FT_DwarfFrame:
    1020      813590 :       RelaxedFrag =
    1021             :         relaxDwarfCallFrameFragment(Layout,
    1022             :                                     *cast<MCDwarfCallFrameFragment>(I));
    1023      813590 :       break;
    1024             :     case MCFragment::FT_LEB:
    1025      258386 :       RelaxedFrag = relaxLEB(Layout, *cast<MCLEBFragment>(I));
    1026      258385 :       break;
    1027             :     case MCFragment::FT_Padding:
    1028           0 :       RelaxedFrag = relaxPaddingFragment(Layout, *cast<MCPaddingFragment>(I));
    1029           0 :       break;
    1030             :     case MCFragment::FT_CVInlineLines:
    1031          69 :       RelaxedFrag =
    1032             :           relaxCVInlineLineTable(Layout, *cast<MCCVInlineLineTableFragment>(I));
    1033          69 :       break;
    1034             :     case MCFragment::FT_CVDefRange:
    1035         543 :       RelaxedFrag = relaxCVDefRange(Layout, *cast<MCCVDefRangeFragment>(I));
    1036         543 :       break;
    1037             :     }
    1038     9406178 :     if (RelaxedFrag && !FirstRelaxedFragment)
    1039             :       FirstRelaxedFragment = &*I;
    1040             :   }
    1041      581850 :   if (FirstRelaxedFragment) {
    1042        8118 :     Layout.invalidateFragmentsFrom(FirstRelaxedFragment);
    1043        8118 :     return true;
    1044             :   }
    1045             :   return false;
    1046             : }
    1047             : 
    1048       10644 : bool MCAssembler::layoutOnce(MCAsmLayout &Layout) {
    1049             :   ++stats::RelaxationSteps;
    1050             : 
    1051             :   bool WasRelaxed = false;
    1052      584376 :   for (iterator it = begin(), ie = end(); it != ie; ++it) {
    1053             :     MCSection &Sec = *it;
    1054      581851 :     while (layoutSectionOnce(Layout, Sec))
    1055             :       WasRelaxed = true;
    1056             :   }
    1057             : 
    1058       10643 :   return WasRelaxed;
    1059             : }
    1060             : 
    1061        7895 : void MCAssembler::finishLayout(MCAsmLayout &Layout) {
    1062             :   assert(getBackendPtr() && "Expected assembler backend");
    1063             :   // The layout is done. Mark every fragment as valid.
    1064      460841 :   for (unsigned int i = 0, n = Layout.getSectionOrder().size(); i != n; ++i) {
    1065      905894 :     MCSection &Section = *Layout.getSectionOrder()[i];
    1066      452947 :     Layout.getFragmentOffset(&*Section.rbegin());
    1067      452946 :     computeFragmentSize(Layout, *Section.rbegin());
    1068             :   }
    1069        7894 :   getBackend().finishLayout(*this, Layout);
    1070        7894 : }
    1071             : 
    1072             : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
    1073             : LLVM_DUMP_METHOD void MCAssembler::dump() const{
    1074             :   raw_ostream &OS = errs();
    1075             : 
    1076             :   OS << "<MCAssembler\n";
    1077             :   OS << "  Sections:[\n    ";
    1078             :   for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
    1079             :     if (it != begin()) OS << ",\n    ";
    1080             :     it->dump();
    1081             :   }
    1082             :   OS << "],\n";
    1083             :   OS << "  Symbols:[";
    1084             : 
    1085             :   for (const_symbol_iterator it = symbol_begin(), ie = symbol_end(); it != ie; ++it) {
    1086             :     if (it != symbol_begin()) OS << ",\n           ";
    1087             :     OS << "(";
    1088             :     it->dump();
    1089             :     OS << ", Index:" << it->getIndex() << ", ";
    1090             :     OS << ")";
    1091             :   }
    1092             :   OS << "]>\n";
    1093             : }
    1094             : #endif

Generated by: LCOV version 1.13