Remove bundling from the MCAssembler interface

lib/MC/MCAssembler.cpp

 //===- lib/MC/MCAssembler.cpp - Assembler Backend Implementation ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "assembler"
@@ skipping 475 matching lines @@
 
   case MCFragment::FT_Dwarf:
     return cast<MCDwarfLineAddrFragment>(F).getContents().size();
   case MCFragment::FT_DwarfFrame:
     return cast<MCDwarfCallFrameFragment>(F).getContents().size();
   }
 
   llvm_unreachable("invalid fragment kind");
 }
 
-void MCAsmLayout::LayoutFragment(MCFragment *F) {
-  MCFragment *Prev = F->getPrevNode();
-
-  // We should never try to recompute something which is up-to-date.
-  assert(!isFragmentUpToDate(F) && "Attempt to recompute up-to-date fragment!");
-  // We should never try to compute the fragment layout if it's predecessor
-  // isn't up-to-date.
-  assert((!Prev || isFragmentUpToDate(Prev)) &&
-         "Attempt to compute fragment before it's predecessor!");
-
-  ++stats::FragmentLayouts;
-
-  // Compute fragment offset and size.
-  uint64_t Offset = 0;
-  if (Prev)
-    Offset += Prev->Offset + getAssembler().computeFragmentSize(*this, *Prev);
-  // @LOCALMOD-BEGIN
-  F->BundlePadding = getAssembler().ComputeBundlePadding(*this, F, Offset);
-  Offset += F->BundlePadding;
-  // @LOCALMOD-END
-  F->Offset = Offset;
-  LastValidFragment[F->getParent()] = F;
-}
-
 // @LOCALMOD-BEGIN
 // Returns number of bytes of padding needed to align to bundle start.
 static uint64_t AddressToBundlePadding(uint64_t Address, uint64_t BundleMask) {
   return (~Address + 1) & BundleMask;
 }
 
-uint64_t MCAssembler::getBundleSize() const {
-  return getBackend().getBundleSize();
-}
-
-uint64_t MCAssembler::getBundleMask() const {
-  uint64_t BundleSize = getBundleSize();
+static uint64_t ComputeBundleMask(uint64_t BundleSize) {
   uint64_t BundleMask = BundleSize - 1;
   assert(BundleSize != 0);
   assert((BundleSize & BundleMask) == 0 &&
          "Bundle size must be a power of 2!");
   return BundleMask;
 }
 
 static unsigned ComputeGroupSize(MCFragment *F) {
   if (!F->isBundleGroupStart()) {
     return 0;
@@ skipping 21 matching lines @@
       GroupSize += cast<MCTinyFragment>(Cur)->getContents().size();
       break;
     }
     if (Cur->isBundleGroupEnd())
       break;
     Cur = Cur->getNextNode();
   }
   return GroupSize;
 }
 
-uint8_t MCAssembler::ComputeBundlePadding(const MCAsmLayout &Layout,
-                                          MCFragment *F,
-                                          uint64_t FragmentOffset) const {
+static uint8_t ComputeBundlePadding(const MCAssembler &Asm,
+                                    const MCAsmLayout &Layout,
+                                    MCFragment *F,
+                                    uint64_t FragmentOffset) {
   if (!F->getParent()->isBundlingEnabled())
     return 0;
 
-  uint64_t BundleSize = getBundleSize();
-  uint64_t BundleMask = getBundleMask();
+  uint64_t BundleSize = Asm.getBackend().getBundleSize();
+  uint64_t BundleMask = ComputeBundleMask(BundleSize);
   unsigned GroupSize = ComputeGroupSize(F);
 
   if (GroupSize > BundleSize) {
     // EmitFill creates large groups consisting of repeated single bytes.
     // These should be safe at any alignment, and in any case we cannot
     // fix them up here.
     return 0;
   }
 
   uint64_t Padding = 0;
   uint64_t OffsetInBundle = FragmentOffset & BundleMask;
 
   if (OffsetInBundle + GroupSize > BundleSize ||
       F->getBundleAlign() == MCFragment::BundleAlignStart) {
     // If this group would cross the bundle boundary, or this group must be
     // aligned to the start of a bundle, then pad up to start of the next bundle
     Padding += AddressToBundlePadding(OffsetInBundle, BundleMask);
     OffsetInBundle = 0;
   }
   if (F->getBundleAlign() == MCFragment::BundleAlignEnd) {
     // Push to the end of the bundle
     Padding += AddressToBundlePadding(OffsetInBundle + GroupSize, BundleMask);
   }
   return Padding;
 }
-// @LOCALMOD-END
 
-
-
-
-// @LOCALMOD-BEGIN
 // Write out BundlePadding bytes in NOPs, being careful not to cross a bundle
 // boundary.
 static void WriteBundlePadding(const MCAssembler &Asm,
                                const MCAsmLayout &Layout,
                                uint64_t Offset, uint64_t TotalPadding,
                                MCObjectWriter *OW) {
-  uint64_t BundleSize = Asm.getBundleSize();
-  uint64_t BundleMask = Asm.getBundleMask();
+  uint64_t BundleSize = Asm.getBackend().getBundleSize();
+  uint64_t BundleMask = ComputeBundleMask(BundleSize);
   uint64_t PaddingLeft = TotalPadding;
   uint64_t StartPos = Offset;
 
   bool FirstWrite = true;
   while (PaddingLeft > 0) {
     uint64_t NopsToWrite =
       FirstWrite ? AddressToBundlePadding(StartPos, BundleMask) :
                    BundleSize;
     if (NopsToWrite > PaddingLeft)
       NopsToWrite = PaddingLeft;
     if (!Asm.getBackend().writeNopData(NopsToWrite, OW))
       report_fatal_error("unable to write nop sequence of " +
                          Twine(NopsToWrite) + " bytes");
     PaddingLeft -= NopsToWrite;
     FirstWrite = false;
   }
 }
 // @LOCALMOD-END
 
+void MCAsmLayout::LayoutFragment(MCFragment *F) {
+  MCFragment *Prev = F->getPrevNode();
+
+  // We should never try to recompute something which is up-to-date.
+  assert(!isFragmentUpToDate(F) && "Attempt to recompute up-to-date fragment!");
+  // We should never try to compute the fragment layout if it's predecessor
+  // isn't up-to-date.
+  assert((!Prev || isFragmentUpToDate(Prev)) &&
+         "Attempt to compute fragment before it's predecessor!");
+
+  ++stats::FragmentLayouts;
+
+  // Compute fragment offset and size.
+  uint64_t Offset = 0;
+  if (Prev)
+    Offset += Prev->Offset + getAssembler().computeFragmentSize(*this, *Prev);
+  // @LOCALMOD-BEGIN
+  F->BundlePadding = ComputeBundlePadding(getAssembler(), *this, F, Offset);
+  Offset += F->BundlePadding;
+  // @LOCALMOD-END
+  F->Offset = Offset;
+  LastValidFragment[F->getParent()] = F;
+}
+
+
 /// WriteFragmentData - Write the \p F data to the output file.
 static void WriteFragmentData(const MCAssembler &Asm, const MCAsmLayout &Layout,
                               const MCFragment &F) {
   MCObjectWriter *OW = &Asm.getWriter();
   // @LOCALMOD-BEGIN
   if (F.getParent()->isBundlingEnabled()) {
     uint64_t BundlePadding = Layout.getFragmentPadding(&F);
     uint64_t PaddingOffset = Layout.getFragmentOffset(&F) - BundlePadding;
     WriteBundlePadding(Asm, Layout, PaddingOffset, BundlePadding, OW);
   }
@@ skipping 21 matching lines @@
                         Twine(AF.getValueSize()) +
                         "' is not a divisor of padding size '" +
                         Twine(FragmentSize) + "'");
 
     // See if we are aligning with nops, and if so do that first to try to fill
     // the Count bytes.  Then if that did not fill any bytes or there are any
     // bytes left to fill use the Value and ValueSize to fill the rest.
     // If we are aligning with nops, ask that target to emit the right data.
     if (AF.hasEmitNops()) {
       // @LOCALMOD-BEGIN
-      if (Asm.getBundleSize()) {
+      if (Asm.getBackend().getBundleSize()) {
         WriteBundlePadding(Asm, Layout,
                            Layout.getFragmentOffset(&F),
                            FragmentSize,
                            OW);
         break;
       }
       // @LOCALMOD-END
 
       if (!Asm.getBackend().writeNopData(Count, OW))
         report_fatal_error("unable to write nop sequence of " +
@@ skipping 594 matching lines @@
 
 // anchors for MC*Fragment vtables
 void MCDataFragment::anchor() { }
 void MCInstFragment::anchor() { }
 void MCAlignFragment::anchor() { }
 void MCFillFragment::anchor() { }
 void MCOrgFragment::anchor() { }
 void MCLEBFragment::anchor() { }
 void MCDwarfLineAddrFragment::anchor() { }
 void MCDwarfCallFrameFragment::anchor() { }