Representing bundle locked groups as fragments in MCAssembler

[colinl]

Summary

The motivation for this change is because we're interested in using bundle locked groups for Hexagon though want the option to relax previous instructions to satisfy alignment rather than only emitting nops.

The high level changes are creating two new fragment types, MCBundleLockFragment and MCBundleUnlockFragment and handling all the bundle logic in MCObjectStreamer rather than MCElfStreamer/MCAssembler.

computeBundlePadding was converted to MCBundleLockFragment::getSize which is queried when computing fragment size.

A function MCAssembler::writeNopData was extracted to write nop data according to bundling requirements.

I removed special functionality around relax-all handling. I'm not sure how much assemble-time memory it was saving but it was generating degenerate sequences of nops:

foo:
       0:       55      pushl   %ebp
       1:       66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00    nopw    %cs:(%eax,%eax)
      10:       66 66 66 66 66 66 2e 0f 1f 84 00 00 00 00 00    nopw    %cs:(%eax,%eax)
      1f:       90      nop
      20:       c7 04 24 01 00 00 00    movl    $1, (%esp)

Memory usage will decrease during non bundle locked assembling due to the fact that the bundle lock members were removed from the MCFragment base class.

[• rafael]

I love how much more localized the blundle handling code is with this patch.

I have never used the feature myself, I I don't think I am comfortable being the main reviewer. Eli, what do you think?

[phosek]

I'm happy with the removal of the relax-all related logic. This was a workaround to reduce the memory usage in constrained environments like PNaCl (where we only have 768MB of address space available), but at the cost of producing fairly suboptimal instruction sequences in some cases. We've recently switched from llc to Subzero for PNaCl and so this workaround is no longer needed.

The new implementation looks significantly cleaner, introducing the new fragment type for bundle handling definitely seems like the right way.

[eliben]

In D19924#423662, @rafael wrote:

I love how much more localized the blundle handling code is with this patch.

I have never used the feature myself, I I don't think I am comfortable being the main reviewer. Eli, what do you think?

Since I haven't touched this code base for years and Petr has been maintaining it, I fully defer to his judgement

[dschuff]

In general I like this direction too. Here are a few preliminary comments. Wrt mc-relax-all, we haven't completely replaced llc in PNaCl yet; I wouldn't necessarily be against removing mc-relax-all anyway though. We might want to consider how this would impact memory usage, and especially if it's an improvement over the previous "normal" case, then that's a no-brainer.

lib/MC/MCAssembler.cpp

356

I guess this code enforces the requirement that nop data not cross bundle boundaries? Can we add back some of the explanatory comments? (here and elsewhere where it makes sense?)

lib/MC/MCFragment.cpp

194

Can this assert just go away now?

test/MC/X86/AlignedBundling/nesting.s

36

Is there some particular reason why the align_to_end has been moved to the first bundle_lock directive here? I think we still have the requirement that a nested directive with the align_to_end property makes the bundle be aligned to end even if the first directive doesn't have it.

[colinl]

I retained the behavior of oring AlignToEnd across nested bundles and added back in comments explaining how bundling works as well as breaking up the expression in the writeNopData function for better self-documentation.

Let me know if there are parts that were missed.

As far as memory usage testing, does anyone have a test they could run for this or have a recommended way of testing this? I assume this could be tested by assembling some sort of large BC file with and without bundling.

[dschuff]

Petr, did you have some way of measuring memory use other than assembling a large module and using top or whatever to look at the RSS?

include/llvm/MC/MCFragment.h

555

Is this illustration still true? Before, fragments with bundle padding had the "empty" padding space (the ###) followed by the content of the fragments. Now IIUC, there's just another fragment which is nothing but padding, correct? And now F->Offset just points to the beginning of the fragment, like any other fragment?

[phosek]

Yes, I wrote a little script which can be used to see the memory usage in relation to the input size. I have uploaded a modified version which should work with the upstream Clang/LLVM to Gist. Running with 1000 functions and 1000 calls can take a long time so I recommend stopping the script after you get enough data to see the trend (the script iteratively subdivides the input space as it runs so over time you'll get more and more precise data). To check the memory consumption in the relax-all case, just add -mc-relax-all to the list of argument on the line 128. I also recommend changing the size of the worker group on line 227 depending on the number of cores you have to avoid hammering your machine.

[colinl]

Running the memory tests pointed out poor usage due to having a bundle lock/unlock fragment for each instruction fragment.

I added a BundleLocked bit to MCFragment to represent a fragment being bundle locket to the next fragment. This means only 1 bit per fragment is needed instead of 2 objects.

I added a vector of bundle alignments to MCSection to represent bundle alignment changes throughout the section. Rather than storing the bundle alignment in each fragment we look up the bounding alignment in this vector.

I have a separate machine that runs the go file and gnuplot and I'll report the results for the redesign.

[colinl]

It looks like in order to get the better optimized final code there is a memory increase of around 12% while assembling. This is attributed to not being able to use the data fragment packing optimization for non-relaxable instructions and instead each instruction is in its own fragment.

What does everyone think about this tradeoff?

[dschuff]

For NaCl, the bundle alignment never changes in the section (or ever at all, it only differs between architectures). Does your use case require that ability?

[dschuff]

(Also can you please make sure the diff is uploaded with all the context? It makes it much easier to review in phab).

[colinl]

Added more diff context.

With Hexagon there can be a penalty when jumping to an instruction that crosses an alignment boundary so especially for things like the top of a loop we don't want that instruction to cross that boundary.

I'm hoping to use instruction bundling to do this since it's the semantics we want but it also means we want bundling to be off usually and only on for specific instructions.

[dschuff]

So, from the perspective of an assembly file, you would put extra .bundle_align_mode directives to enable and disable bundling during assembly? I guess you would still want to do this for large groups of instructions, else it's no better than just putting .align before each jump target, right?

[dschuff]

(oh by the way there should definitely be some tests for that behavior; the existing code was written assuming there could only ever be one .bundle_align_mode in each asm file.)

[colinl]

I'll add a test for multiple bundle alignment directives.

The semantics are slightly different than a plain alignment. Plain align will always pad to an alignment boundary though bundle locking only does this if the instruction crosses the boundary.

{ sub } ; 4-byte
.align 16
{ add } ; 8-byte
{ sub } ; 4-byte

Would assemble as
0: { sub
4: nop
8: nop
12: nop }
16: { add }
24: { sub }

Whereas bundle locking would do.

{ sub } ; 4-byte
.bundle_align_mode 4
{ add; add } ; 8-byte
.bundle_align_mode 0
{ sub } ; 4-byte

Would assemble as
0: { sub }
4: { add }
12: { sub }

include/llvm/MC/MCAsmLayout.h

public:
 
   /// @}
   /// \name Fragment Layout Data
   /// @{
 
   /// \brief Get the offset of the given fragment inside its containing section.
   uint64_t getFragmentOffset(const MCFragment *F) const;
 
+  uint64_t getBundlePadding(const MCFragment &F, uint64_t Offset) const;
+
   /// @}
   /// \name Utility Functions
   /// @{
 
   /// \brief Get the address space size of the given section, as it effects
   /// layout. This may differ from the size reported by \see getSectionSize() by
   /// not including section tail padding.
   uint64_t getSectionAddressSize(const MCSection *Sec) const;

include/llvm/MC/MCAssembler.h

private:
   /// been seen.
   //
   // FIXME: We really would like this in target specific code rather than
   // here. Maybe when the relocation stuff moves to target specific,
   // this can go with it? The streamer would need some target specific
   // refactoring too.
   mutable SmallPtrSet<const MCSymbol *, 32> ThumbFuncs;
 
-  /// \brief The bundle alignment size currently set in the assembler.
-  ///
-  /// By default it's 0, which means bundling is disabled.
-  unsigned BundleAlignSize;
-
   unsigned RelaxAll : 1;
   unsigned SubsectionsViaSymbols : 1;
   unsigned IncrementalLinkerCompatible : 1;
 
   /// ELF specific e_header flags
   // It would be good if there were an MCELFAssembler class to hold this.
   // ELF header flags are used both by the integrated and standalone assemblers.
   // Access to the flags is necessary in cases where assembler directives affect
public:
   /// Finish - Do final processing and write the object to the output stream.
   /// \p Writer is used for custom object writer (as the MCJIT does),
   /// if not specified it is automatically created from backend.
   void Finish();
 
   // Layout all section and prepare them for emission.
   void layout(MCAsmLayout &Layout);
 
+  /// Write out nops taking in to consideration instruction bundle boundaries
+  void writeNopData(MCAsmLayout const &Layout, uint64_t Offset, uint64_t Count,
+                    MCObjectWriter *OW, uint64_t BundleSize = 0) const;
+
   // FIXME: This does not belong here.
   bool getSubsectionsViaSymbols() const { return SubsectionsViaSymbols; }
   void setSubsectionsViaSymbols(bool Value) { SubsectionsViaSymbols = Value; }
 
   bool isIncrementalLinkerCompatible() const {
     return IncrementalLinkerCompatible;
   }
   void setIncrementalLinkerCompatible(bool Value) {
     IncrementalLinkerCompatible = Value;
   }
 
   bool getRelaxAll() const { return RelaxAll; }
   void setRelaxAll(bool Value) { RelaxAll = Value; }
 
-  bool isBundlingEnabled() const { return BundleAlignSize != 0; }
-
-  unsigned getBundleAlignSize() const { return BundleAlignSize; }
-
-  void setBundleAlignSize(unsigned Size) {
-    assert((Size == 0 || !(Size & (Size - 1))) &&
-           "Expect a power-of-two bundle align size");
-    BundleAlignSize = Size;
-  }
-
   /// \name Section List Access
   /// @{
 
   iterator begin() { return Sections.begin(); }
   const_iterator begin() const { return Sections.begin(); }
 
   iterator end() { return Sections.end(); }
   const_iterator end() const { return Sections.end(); }
public:
   ArrayRef<std::string> getFileNames() { return FileNames; }
 
   void addFileName(StringRef FileName) {
     if (std::find(FileNames.begin(), FileNames.end(), FileName) ==
         FileNames.end())
       FileNames.push_back(FileName);
   }
 
-  /// \brief Write the necessary bundle padding to the given object writer.
-  /// Expects a fragment \p F containing instructions and its size \p FSize.
-  void writeFragmentPadding(const MCFragment &F, uint64_t FSize,
-                            MCObjectWriter *OW) const;
-
   /// @}
 
   void dump();
 };
 
-/// \brief Compute the amount of padding required before the fragment \p F to
-/// obey bundling restrictions, where \p FOffset is the fragment's offset in
-/// its section and \p FSize is the fragment's size.
-uint64_t computeBundlePadding(const MCAssembler &Assembler, const MCFragment *F,
-                              uint64_t FOffset, uint64_t FSize);
-
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCELFStreamer.h

MCELFStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
                 MCCodeEmitter *Emitter)
       : MCObjectStreamer(Context, TAB, OS, Emitter), SeenIdent(false) {}
 
   ~MCELFStreamer() override;
 
   /// state management
   void reset() override {
     SeenIdent = false;
-    BundleGroups.clear();
     MCObjectStreamer::reset();
   }
 
   /// \name MCStreamer Interface
   /// @{
 
   void InitSections(bool NoExecStack) override;
   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
public:
   void EmitFileDirective(StringRef Filename) override;
 
   void EmitIdent(StringRef IdentString) override;
 
   void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
 
   void FinishImpl() override;
 
-  void EmitBundleAlignMode(unsigned AlignPow2) override;
-  void EmitBundleLock(bool AlignToEnd) override;
-  void EmitBundleUnlock() override;
-
 private:
-  bool isBundleLocked() const;
   void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &) override;
   void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
 
   void fixSymbolsInTLSFixups(const MCExpr *expr);
 
   /// \brief Merge the content of the fragment \p EF into the fragment \p DF.
   void mergeFragment(MCDataFragment *, MCDataFragment *);
 
   bool SeenIdent;
-
-  /// BundleGroups - The stack of fragments holding the bundle-locked
-  /// instructions.
-  llvm::SmallVector<MCDataFragment *, 4> BundleGroups;
 };
 
 MCELFStreamer *createARMELFStreamer(MCContext &Context, MCAsmBackend &TAB,
                                     raw_pwrite_stream &OS,
                                     MCCodeEmitter *Emitter, bool RelaxAll,
                                     bool IsThumb);
 
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCFragment.h

enum FragmentType : uint8_t {
     FT_Relaxable,
     FT_Org,
     FT_Dwarf,
     FT_DwarfFrame,
     FT_LEB,
     FT_SafeSEH,
     FT_CVInlineLines,
     FT_CVDefRange,
+    FT_BundleAlign,
     FT_Dummy
   };
 
 private:
   FragmentType Kind;
 
 protected:
-  bool HasInstructions;
+  unsigned HasInstructions : 1;
+  unsigned BundleLocked : 1;
+  unsigned BundleAlignToEnd : 1;
 
 private:
-  /// \brief Should this fragment be aligned to the end of a bundle?
-  bool AlignToBundleEnd;
-
-  uint8_t BundlePadding;
 
   /// LayoutOrder - The layout order of this fragment.
   unsigned LayoutOrder;
 
   /// The data for the section this fragment is in.
   MCSection *Parent;
 
   /// Atom - The atom this fragment is in, as represented by it's defining
   /// symbol.
   const MCSymbol *Atom;
 
   /// \name Assembler Backend Data
   /// @{
   //
   // FIXME: This could all be kept private to the assembler implementation.
 
   /// Offset - The offset of this fragment in its section. This is ~0 until
   /// initialized.
   uint64_t Offset;
 
   /// @}
 
 protected:
   MCFragment(FragmentType Kind, bool HasInstructions,
-             uint8_t BundlePadding, MCSection *Parent = nullptr);
+             MCSection *Parent = nullptr);
 
   ~MCFragment();
 private:
 
   // This is a friend so that the sentinal can be created.
   friend struct ilist_sentinel_traits<MCFragment>;
   MCFragment();
 
public:
 
   unsigned getLayoutOrder() const { return LayoutOrder; }
   void setLayoutOrder(unsigned Value) { LayoutOrder = Value; }
 
   /// \brief Does this fragment have instructions emitted into it? By default
   /// this is false, but specific fragment types may set it to true.
   bool hasInstructions() const { return HasInstructions; }
 
-  /// \brief Should this fragment be placed at the end of an aligned bundle?
-  bool alignToBundleEnd() const { return AlignToBundleEnd; }
-  void setAlignToBundleEnd(bool V) { AlignToBundleEnd = V; }
-
-  /// \brief Get the padding size that must be inserted before this fragment.
-  /// Used for bundling. By default, no padding is inserted.
-  /// Note that padding size is restricted to 8 bits. This is an optimization
-  /// to reduce the amount of space used for each fragment. In practice, larger
-  /// padding should never be required.
-  uint8_t getBundlePadding() const { return BundlePadding; }
-
-  /// \brief Set the padding size for this fragment. By default it's a no-op,
-  /// and only some fragments have a meaningful implementation.
-  void setBundlePadding(uint8_t N) { BundlePadding = N; }
+  /// \brief Is this fragment bundle locked to the next fragment
+  bool isBundleLocked() const { return BundleLocked; }
+  void setBundleLocked(bool Val) { BundleLocked = Val; }
+
+  // Will this fragment's instructions end at the end of the bundle
+  bool isBundleAlignToEnd() const { return BundleAlignToEnd; }
+  void setBundleAlignToEnd(bool Val) { BundleAlignToEnd = Val; }
 
   /// \brief Return true if given frgment has FT_Dummy type.
   bool isDummy() const { return Kind == FT_Dummy; }
 
   void dump();
 };
 
 class MCDummyFragment : public MCFragment {
 public:
   explicit MCDummyFragment(MCSection *Sec)
-      : MCFragment(FT_Dummy, false, 0, Sec){};
+      : MCFragment(FT_Dummy, false, Sec){};
   static bool classof(const MCFragment *F) { return F->getKind() == FT_Dummy; }
 };
 
 /// Interface implemented by fragments that contain encoded instructions and/or
 /// data.
 ///
 class MCEncodedFragment : public MCFragment {
 protected:
   MCEncodedFragment(MCFragment::FragmentType FType, bool HasInstructions,
                     MCSection *Sec)
-      : MCFragment(FType, HasInstructions, 0, Sec) {}
+      : MCFragment(FType, HasInstructions, Sec) {}
 
 public:
   static bool classof(const MCFragment *F) {
     MCFragment::FragmentType Kind = F->getKind();
     switch (Kind) {
     default:
       return false;
     case MCFragment::FT_Relaxable:
class MCAlignFragment : public MCFragment {
 
   /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
   /// cannot be satisfied in this width then this fragment is ignored.
   unsigned MaxBytesToEmit;
 
 public:
   MCAlignFragment(unsigned Alignment, int64_t Value, unsigned ValueSize,
                   unsigned MaxBytesToEmit, MCSection *Sec = nullptr)
-      : MCFragment(FT_Align, false, 0, Sec), Alignment(Alignment),
+      : MCFragment(FT_Align, false, Sec), Alignment(Alignment),
         EmitNops(false), Value(Value),
         ValueSize(ValueSize), MaxBytesToEmit(MaxBytesToEmit) {}
 
   /// \name Accessors
   /// @{
 
   unsigned getAlignment() const { return Alignment; }
 
class MCFillFragment : public MCFragment {
   /// Value to use for filling bytes.
   uint8_t Value;
 
   /// The number of bytes to insert.
   uint64_t Size;
 
 public:
   MCFillFragment(uint8_t Value, uint64_t Size, MCSection *Sec = nullptr)
-      : MCFragment(FT_Fill, false, 0, Sec), Value(Value), Size(Size) {}
+      : MCFragment(FT_Fill, false, Sec), Value(Value), Size(Size) {}
 
   uint8_t getValue() const { return Value; }
   uint64_t getSize() const { return Size; }
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Fill;
   }
 };
 
 class MCOrgFragment : public MCFragment {
 
   /// Offset - The offset this fragment should start at.
   const MCExpr *Offset;
 
   /// Value - Value to use for filling bytes.
   int8_t Value;
 
 public:
   MCOrgFragment(const MCExpr &Offset, int8_t Value, MCSection *Sec = nullptr)
-      : MCFragment(FT_Org, false, 0, Sec), Offset(&Offset), Value(Value) {}
+      : MCFragment(FT_Org, false, Sec), Offset(&Offset), Value(Value) {}
 
   /// \name Accessors
   /// @{
 
   const MCExpr &getOffset() const { return *Offset; }
 
   uint8_t getValue() const { return Value; }
 
class MCLEBFragment : public MCFragment {
 
   /// IsSigned - True if this is a sleb128, false if uleb128.
   bool IsSigned;
 
   SmallString<8> Contents;
 
 public:
   MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec = nullptr)
-      : MCFragment(FT_LEB, false, 0, Sec), Value(&Value_), IsSigned(IsSigned_) {
+      : MCFragment(FT_LEB, false, Sec), Value(&Value_), IsSigned(IsSigned_) {
     Contents.push_back(0);
   }
 
   /// \name Accessors
   /// @{
 
   const MCExpr &getValue() const { return *Value; }
 
class MCDwarfLineAddrFragment : public MCFragment {
   /// make up the address delta between two .loc dwarf directives.
   const MCExpr *AddrDelta;
 
   SmallString<8> Contents;
 
 public:
   MCDwarfLineAddrFragment(int64_t LineDelta, const MCExpr &AddrDelta,
                           MCSection *Sec = nullptr)
-      : MCFragment(FT_Dwarf, false, 0, Sec), LineDelta(LineDelta),
+      : MCFragment(FT_Dwarf, false, Sec), LineDelta(LineDelta),
         AddrDelta(&AddrDelta) {
     Contents.push_back(0);
   }
 
   /// \name Accessors
   /// @{
 
   int64_t getLineDelta() const { return LineDelta; }
class MCDwarfCallFrameFragment : public MCFragment {
   /// AddrDelta - The expression for the difference of the two symbols that
   /// make up the address delta between two .cfi_* dwarf directives.
   const MCExpr *AddrDelta;
 
   SmallString<8> Contents;
 
 public:
   MCDwarfCallFrameFragment(const MCExpr &AddrDelta, MCSection *Sec = nullptr)
-      : MCFragment(FT_DwarfFrame, false, 0, Sec), AddrDelta(&AddrDelta) {
+      : MCFragment(FT_DwarfFrame, false, Sec), AddrDelta(&AddrDelta) {
     Contents.push_back(0);
   }
 
   /// \name Accessors
   /// @{
 
   const MCExpr &getAddrDelta() const { return *AddrDelta; }
 
   SmallString<8> &getContents() { return Contents; }
   const SmallString<8> &getContents() const { return Contents; }
 
   /// @}
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_DwarfFrame;
   }
 };
 
 class MCSafeSEHFragment : public MCFragment {
   const MCSymbol *Sym;
 
 public:
   MCSafeSEHFragment(const MCSymbol *Sym, MCSection *Sec = nullptr)
-      : MCFragment(FT_SafeSEH, false, 0, Sec), Sym(Sym) {}
+      : MCFragment(FT_SafeSEH, false, Sec), Sym(Sym) {}
 
   /// \name Accessors
   /// @{
 
   const MCSymbol *getSymbol() { return Sym; }
   const MCSymbol *getSymbol() const { return Sym; }
 
   /// @}
class MCCVInlineLineTableFragment : public MCFragment {
   friend class CodeViewContext;
 
 public:
   MCCVInlineLineTableFragment(unsigned SiteFuncId, unsigned StartFileId,
                               unsigned StartLineNum, const MCSymbol *FnStartSym,
                               const MCSymbol *FnEndSym,
                               ArrayRef<unsigned> SecondaryFuncs,
                               MCSection *Sec = nullptr)
-      : MCFragment(FT_CVInlineLines, false, 0, Sec), SiteFuncId(SiteFuncId),
+      : MCFragment(FT_CVInlineLines, false, Sec), SiteFuncId(SiteFuncId),
         StartFileId(StartFileId), StartLineNum(StartLineNum),
         FnStartSym(FnStartSym), FnEndSym(FnEndSym),
         SecondaryFuncs(SecondaryFuncs.begin(), SecondaryFuncs.end()) {}
 
   /// \name Accessors
   /// @{
 
   const MCSymbol *getFnStartSym() const { return FnStartSym; }
public:
   StringRef getFixedSizePortion() const { return FixedSizePortion; }
   /// @}
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_CVDefRange;
   }
 };
 
+// Designates a change to the instruction bundle alignment within a section
+class MCBundleAlignFragment : public MCFragment {
+  /// Alignment - The alignment to ensure, in bytes.
+  unsigned Alignment;
+
+public:
+  MCBundleAlignFragment(unsigned Alignment, MCSection *Sec = nullptr)
+      : MCFragment(FT_BundleAlign, false, Sec), Alignment(Alignment) {}
+
+  unsigned getAlignment() const { return Alignment; }
+
+  static bool classof(const MCFragment *F) {
+    return F->getKind() == MCFragment::FT_BundleAlign;
+  }
+};
+
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCObjectStreamer.h

 /// to that file format or custom semantics expected by the object writer
 /// implementation.
 class MCObjectStreamer : public MCStreamer {
   MCAssembler *Assembler;
   MCSection::iterator CurInsertionPoint;
   bool EmitEHFrame;
   bool EmitDebugFrame;
   SmallVector<MCSymbol *, 2> PendingLabels;
+  /// \brief Depth of .bundle_lock/.bundle_unlock directives
+  /// Bundles are only created for the outermost nesting
+  unsigned BundleDepth;
+  /// \brief The bundle alignment size currently set in the assembler.
+  ///
+  /// By default it's 0, which means bundling is disabled.
+  unsigned BundleAlignment;
+  bool BundleAlignToEnd;
 
   virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
   void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
   void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
 
 protected:
   MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB, raw_pwrite_stream &OS,
                    MCCodeEmitter *Emitter);

include/llvm/MC/MCSection.h

private:
   MCSymbol *End = nullptr;
   /// The alignment requirement of this section.
   unsigned Alignment = 1;
   /// The section index in the assemblers section list.
   unsigned Ordinal = 0;
   /// The index of this section in the layout order.
   unsigned LayoutOrder;
 
-  /// \brief Keeping track of bundle-locked state.
-  BundleLockStateType BundleLockState = NotBundleLocked;
-
-  /// \brief Current nesting depth of bundle_lock directives.
-  unsigned BundleLockNestingDepth = 0;
-
-  /// \brief We've seen a bundle_lock directive but not its first instruction
-  /// yet.
-  unsigned BundleGroupBeforeFirstInst : 1;
-
   /// Whether this section has had instructions emitted into it.
   unsigned HasInstructions : 1;
 
   unsigned IsRegistered : 1;
 
   MCDummyFragment DummyFragment;
 
   FragmentListType Fragments;
 
   /// Mapping from subsection number to insertion point for subsection numbers
   /// below that number.
   SmallVector<std::pair<unsigned, MCFragment *>, 1> SubsectionFragmentMap;
 
+  /// Record of bundle align fragments with this section for fast searching
+  SmallVector<MCBundleAlignFragment*, 1> BundleAlignments;
+
 protected:
   MCSection(SectionVariant V, SectionKind K, MCSymbol *Begin);
   SectionVariant Variant;
   SectionKind Kind;
   ~MCSection();
 
 public:
   SectionKind getKind() const { return Kind; }
void setBeginSymbol(MCSymbol *Sym) {
     Begin = Sym;
   }
   MCSymbol *getEndSymbol(MCContext &Ctx);
   bool hasEnded() const;
 
   unsigned getAlignment() const { return Alignment; }
   void setAlignment(unsigned Value) { Alignment = Value; }
 
+  void addBundleAlignment(MCBundleAlignFragment *Frag) {
+    BundleAlignments.push_back(Frag);
+  }
+
+  /// \brief Bundle alignment for Frag
+  uint64_t getBundleAlignment(MCFragment const &Frag) const;
+  /// \brief Bundle alignment of the last fragment
+  uint64_t getBundleAlignment() const;
+
   unsigned getOrdinal() const { return Ordinal; }
   void setOrdinal(unsigned Value) { Ordinal = Value; }
 
   unsigned getLayoutOrder() const { return LayoutOrder; }
   void setLayoutOrder(unsigned Value) { LayoutOrder = Value; }
 
-  BundleLockStateType getBundleLockState() const { return BundleLockState; }
-  void setBundleLockState(BundleLockStateType NewState);
-  bool isBundleLocked() const { return BundleLockState != NotBundleLocked; }
-
-  bool isBundleGroupBeforeFirstInst() const {
-    return BundleGroupBeforeFirstInst;
-  }
-  void setBundleGroupBeforeFirstInst(bool IsFirst) {
-    BundleGroupBeforeFirstInst = IsFirst;
-  }
-
   bool hasInstructions() const { return HasInstructions; }
   void setHasInstructions(bool Value) { HasInstructions = Value; }
 
   bool isRegistered() const { return IsRegistered; }
   void setIsRegistered(bool Value) { IsRegistered = Value; }
 
   MCSection::FragmentListType &getFragmentList() { return Fragments; }
   const MCSection::FragmentListType &getFragmentList() const {

lib/MC/MCAssembler.cpp

 // object file, which may truncate it. We should detect that truncation where
 // invalid and report errors back.
 
 /* *** */
 
 MCAssembler::MCAssembler(MCContext &Context, MCAsmBackend &Backend,
                          MCCodeEmitter &Emitter, MCObjectWriter &Writer)
     : Context(Context), Backend(Backend), Emitter(Emitter), Writer(Writer),
-      BundleAlignSize(0), RelaxAll(false), SubsectionsViaSymbols(false),
+      RelaxAll(false), SubsectionsViaSymbols(false),
       IncrementalLinkerCompatible(false), ELFHeaderEFlags(0) {
   VersionMinInfo.Major = 0; // Major version == 0 for "none specified"
 }
 
 MCAssembler::~MCAssembler() {
 }
 
 void MCAssembler::reset() {
   Sections.clear();
   Symbols.clear();
   IndirectSymbols.clear();
   DataRegions.clear();
   LinkerOptions.clear();
   FileNames.clear();
   ThumbFuncs.clear();
-  BundleAlignSize = 0;
   RelaxAll = false;
   SubsectionsViaSymbols = false;
   IncrementalLinkerCompatible = false;
   ELFHeaderEFlags = 0;
   LOHContainer.reset();
   VersionMinInfo.Major = 0;
 
   // reset objects owned by us
uint64_t MCAssembler::computeFragmentSize(const MCAsmLayout &Layout,
   case MCFragment::FT_Dwarf:
     return cast<MCDwarfLineAddrFragment>(F).getContents().size();
   case MCFragment::FT_DwarfFrame:
     return cast<MCDwarfCallFrameFragment>(F).getContents().size();
   case MCFragment::FT_CVInlineLines:
     return cast<MCCVInlineLineTableFragment>(F).getContents().size();
   case MCFragment::FT_CVDefRange:
     return cast<MCCVDefRangeFragment>(F).getContents().size();
+  case MCFragment::FT_BundleAlign:
+    return 0;
   case MCFragment::FT_Dummy:
     llvm_unreachable("Should not have been added");
   }
 
   llvm_unreachable("invalid fragment kind");
 }
 
+uint64_t MCAsmLayout::getBundlePadding(const MCFragment &F,
+                                       uint64_t Offset) const {
+  bool AlignToBundleEnd = false;
+  uint64_t BundleSize = F.getParent()->getBundleAlignment(F);
+  if (BundleSize == 0)
+    return 0;
+  uint64_t BundleMask = BundleSize - 1;
+  uint64_t OffsetInBundle = Offset & BundleMask;
+  ilist_iterator<MCFragment const> I = F.getIterator();
+  uint64_t FSize = 0;
+  for(;;) {
+    assert (I != F.getParent()->getFragmentList().end() &&
+            "BundleLock without BundleUnlock");
+    MCFragment const &Fragment = *I;
+    if (!Fragment.hasInstructions())
+      break;
+    FSize += getAssembler().computeFragmentSize(*this, Fragment);
+    AlignToBundleEnd |= Fragment.isBundleAlignToEnd();
+    if (!I->isBundleLocked())
+      break;
+    ++I;
+  }
+  if(FSize > BundleSize)
+    report_fatal_error("Fragment can't be larger than a bundle size");
+  uint64_t EndOfFragment = OffsetInBundle + FSize;
+
+  // There are two kinds of bundling restrictions:
+  //
+  // 1) For alignToBundleEnd(), add padding to ensure that the fragment will
+  //    *end* on a bundle boundary.
+  // 2) Otherwise, check if the fragment would cross a bundle boundary. If it
+  //    would, add padding until the end of the bundle so that the fragment
+  //    will start in a new one.
+  if (AlignToBundleEnd) {
+    // Three possibilities here:
+    //
+    // A) The fragment just happens to end at a bundle boundary, so we're good.
+    // B) The fragment ends before the current bundle boundary: pad it just
+    //    enough to reach the boundary.
+    // C) The fragment ends after the current bundle boundary: pad it until it
+    //    reaches the end of the next bundle boundary.
+    //
+    // Note: this code could be made shorter with some modulo trickery, but it's
+    // intentionally kept in its more explicit form for simplicity.
+    if (EndOfFragment == BundleSize)
+      return 0;
+    else if (EndOfFragment < BundleSize)
+      return BundleSize - EndOfFragment;
+    else { // EndOfFragment > BundleSize
+      return 2 * BundleSize - EndOfFragment;
+    }
+  } else if (OffsetInBundle > 0 && EndOfFragment > BundleSize)
+    return BundleSize - OffsetInBundle;
+  else
+    return 0;
+}
+
 void MCAsmLayout::layoutFragment(MCFragment *F) {
   MCFragment *Prev = F->getPrevNode();
 
   // We should never try to recompute something which is valid.
   assert(!isFragmentValid(F) && "Attempt to recompute a valid fragment!");
   // We should never try to compute the fragment layout if its predecessor
   // isn't valid.
   assert((!Prev || isFragmentValid(Prev)) &&
          "Attempt to compute fragment before its predecessor!");
 
   ++stats::FragmentLayouts;
 
   // Compute fragment offset and size.
-  if (Prev)
-    F->Offset = Prev->Offset + getAssembler().computeFragmentSize(*this, *Prev);
+  if (Prev) {
+    uint64_t PrevSize = getAssembler().computeFragmentSize(*this, *Prev);
+    F->Offset =
+        Prev->Offset + PrevSize + getBundlePadding(*F, Prev->Offset + PrevSize);
+  }
   else
     F->Offset = 0;
   LastValidFragment[F->getParent()] = F;
-
-  // If bundling is enabled and this fragment has instructions in it, it has to
-  // obey the bundling restrictions. With padding, we'll have:
-  //
-  //
-  //        BundlePadding
-  //             |||
-  // -------------------------------------
-  //   Prev  |##########|       F        |
-  // -------------------------------------
-  //                    ^
-  //                    |
-  //                    F->Offset
-  //
-  // The fragment's offset will point to after the padding, and its computed
-  // size won't include the padding.
-  //
-  // When the -mc-relax-all flag is used, we optimize bundling by writting the
-  // padding directly into fragments when the instructions are emitted inside
-  // the streamer. When the fragment is larger than the bundle size, we need to
-  // ensure that it's bundle aligned. This means that if we end up with
-  // multiple fragments, we must emit bundle padding between fragments.
-  //
-  // ".align N" is an example of a directive that introduces multiple
-  // fragments. We could add a special case to handle ".align N" by emitting
-  // within-fragment padding (which would produce less padding when N is less
-  // than the bundle size), but for now we don't.
-  //
-  if (Assembler.isBundlingEnabled() && F->hasInstructions()) {
-    assert(isa<MCEncodedFragment>(F) &&
-           "Only MCEncodedFragment implementations have instructions");
-    uint64_t FSize = Assembler.computeFragmentSize(*this, *F);
-
-    if (!Assembler.getRelaxAll() && FSize > Assembler.getBundleAlignSize())
-      report_fatal_error("Fragment can't be larger than a bundle size");
-
-    uint64_t RequiredBundlePadding = computeBundlePadding(Assembler, F,
-                                                          F->Offset, FSize);
-    if (RequiredBundlePadding > UINT8_MAX)
-      report_fatal_error("Padding cannot exceed 255 bytes");
-    F->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
-    F->Offset += RequiredBundlePadding;
-  }
 }
 
 void MCAssembler::registerSymbol(const MCSymbol &Symbol, bool *Created) {
   bool New = !Symbol.isRegistered();
   if (Created)
     *Created = New;
   if (New) {
     Symbol.setIsRegistered(true);
     Symbols.push_back(&Symbol);
   }
 }
 
-void MCAssembler::writeFragmentPadding(const MCFragment &F, uint64_t FSize,
-                                       MCObjectWriter *OW) const {
-  // Should NOP padding be written out before this fragment?
-  unsigned BundlePadding = F.getBundlePadding();
-  if (BundlePadding > 0) {
-    assert(isBundlingEnabled() &&
-           "Writing bundle padding with disabled bundling");
-    assert(F.hasInstructions() &&
-           "Writing bundle padding for a fragment without instructions");
-
-    unsigned TotalLength = BundlePadding + static_cast<unsigned>(FSize);
-    if (F.alignToBundleEnd() && TotalLength > getBundleAlignSize()) {
-      // If the padding itself crosses a bundle boundary, it must be emitted
-      // in 2 pieces, since even nop instructions must not cross boundaries.
-      //             v--------------v   <- BundleAlignSize
-      //        v---------v             <- BundlePadding
-      // ----------------------------
-      // | Prev |####|####|    F    |
-      // ----------------------------
-      //        ^-------------------^   <- TotalLength
-      unsigned DistanceToBoundary = TotalLength - getBundleAlignSize();
-      if (!getBackend().writeNopData(DistanceToBoundary, OW))
-          report_fatal_error("unable to write NOP sequence of " +
-                             Twine(DistanceToBoundary) + " bytes");
-      BundlePadding -= DistanceToBoundary;
-    }
-    if (!getBackend().writeNopData(BundlePadding, OW))
-      report_fatal_error("unable to write NOP sequence of " +
-                         Twine(BundlePadding) + " bytes");
+void MCAssembler::writeNopData(MCAsmLayout const &Layout, uint64_t Offset,
+                               uint64_t Count, MCObjectWriter *OW,
+                               uint64_t BundleSize) const {
+  if (BundleSize == 0) {
+    getBackend().writeNopData(Count, OW);
+    return;
+  }
+  while (Count > 0) {
+    uint64_t NextBoundary = ((Offset / BundleSize) + 1) * BundleSize;
+    uint64_t Amount = std::min(Count, NextBoundary - Offset);
+    Count -= Amount;
+    Offset += Amount;
+    if (!getBackend().writeNopData(Amount, OW))
+      report_fatal_error("unable to write nop sequence of " +
+                        Twine(Amount) + " bytes");
   }
 }
 
 /// \brief Write the fragment \p F to the output file.
 static void writeFragment(const MCAssembler &Asm, const MCAsmLayout &Layout,
                           const MCFragment &F) {
   MCObjectWriter *OW = &Asm.getWriter();
 
   // FIXME: Embed in fragments instead?
   uint64_t FragmentSize = Asm.computeFragmentSize(Layout, F);
-
-  Asm.writeFragmentPadding(F, FragmentSize, OW);
+  MCFragment const *Prev = F.getPrevNode();
+  uint64_t Offset = Prev
+                        ? Layout.getFragmentOffset(Prev) +
+                              Asm.computeFragmentSize(Layout, *Prev)
+                        : 0;
+  uint64_t BundlePadding = Layout.getBundlePadding(F, Offset);
+  Asm.writeNopData(Layout, Offset, BundlePadding, OW,
+                   F.getParent()->getBundleAlignment(F));
 
   // This variable (and its dummy usage) is to participate in the assert at
   // the end of the function.
   uint64_t Start = OW->getStream().tell();
   (void) Start;
 
   ++stats::EmittedFragments;
 
if (Count * AF.getValueSize() != FragmentSize)
                         "' 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()) {
-      if (!Asm.getBackend().writeNopData(Count, OW))
-        report_fatal_error("unable to write nop sequence of " +
-                          Twine(Count) + " bytes");
+      Asm.writeNopData(Layout, Layout.getFragmentOffset(&F), Count, OW);
       break;
     }
 
     // Otherwise, write out in multiples of the value size.
     for (uint64_t i = 0; i != Count; ++i) {
       switch (AF.getValueSize()) {
       default: llvm_unreachable("Invalid size!");
       case 1: OW->write8 (uint8_t (AF.getValue())); break;
       case 2: OW->write16(uint16_t(AF.getValue())); break;
       case 4: OW->write32(uint32_t(AF.getValue())); break;
       case 8: OW->write64(uint64_t(AF.getValue())); break;
       }
     }
     break;
   }
 
+  case MCFragment::FT_BundleAlign:
+    break;
+
   case MCFragment::FT_Data: 
     ++stats::EmittedDataFragments;
     OW->writeBytes(cast<MCDataFragment>(F).getContents());
     break;
 
   case MCFragment::FT_Relaxable:
     ++stats::EmittedRelaxableFragments;
     OW->writeBytes(cast<MCRelaxableFragment>(F).getContents());

lib/MC/MCELFStreamer.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-bool MCELFStreamer::isBundleLocked() const {
-  return getCurrentSectionOnly()->isBundleLocked();
-}
-
 MCELFStreamer::~MCELFStreamer() {
 }
 
 void MCELFStreamer::mergeFragment(MCDataFragment *DF,
                                   MCDataFragment *EF) {
-  MCAssembler &Assembler = getAssembler();
-
-  if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
-    uint64_t FSize = EF->getContents().size();
-
-    if (FSize > Assembler.getBundleAlignSize())
-      report_fatal_error("Fragment can't be larger than a bundle size");
-
-    uint64_t RequiredBundlePadding = computeBundlePadding(
-        Assembler, EF, DF->getContents().size(), FSize);
-
-    if (RequiredBundlePadding > UINT8_MAX)
-      report_fatal_error("Padding cannot exceed 255 bytes");
-
-    if (RequiredBundlePadding > 0) {
-      SmallString<256> Code;
-      raw_svector_ostream VecOS(Code);
-      MCObjectWriter *OW = Assembler.getBackend().createObjectWriter(VecOS);
-
-      EF->setBundlePadding(static_cast<uint8_t>(RequiredBundlePadding));
-
-      Assembler.writeFragmentPadding(*EF, FSize, OW);
-      delete OW;
-
-      DF->getContents().append(Code.begin(), Code.end());
-    }
-  }
-
   flushPendingLabels(DF, DF->getContents().size());
 
   for (unsigned i = 0, e = EF->getFixups().size(); i != e; ++i) {
     EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() +
                                  DF->getContents().size());
     DF->getFixups().push_back(EF->getFixups()[i]);
   }
   DF->setHasInstructions(true);
void MCELFStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
   case MCAF_SubsectionsViaSymbols:
     getAssembler().setSubsectionsViaSymbols(true);
     return;
   }
 
   llvm_unreachable("invalid assembler flag!");
 }
 
-// If bundle alignment is used and there are any instructions in the section, it
-// needs to be aligned to at least the bundle size.
-static void setSectionAlignmentForBundling(const MCAssembler &Assembler,
-                                           MCSection *Section) {
-  if (Section && Assembler.isBundlingEnabled() && Section->hasInstructions() &&
-      Section->getAlignment() < Assembler.getBundleAlignSize())
-    Section->setAlignment(Assembler.getBundleAlignSize());
-}
-
 void MCELFStreamer::ChangeSection(MCSection *Section,
                                   const MCExpr *Subsection) {
-  MCSection *CurSection = getCurrentSectionOnly();
-  if (CurSection && isBundleLocked())
-    report_fatal_error("Unterminated .bundle_lock when changing a section");
-
   MCAssembler &Asm = getAssembler();
-  // Ensure the previous section gets aligned if necessary.
-  setSectionAlignmentForBundling(Asm, CurSection);
   auto *SectionELF = static_cast<const MCSectionELF *>(Section);
   const MCSymbol *Grp = SectionELF->getGroup();
   if (Grp)
     Asm.registerSymbol(*Grp);
 
   this->MCObjectStreamer::ChangeSection(Section, Subsection);
   MCContext &Ctx = getContext();
   auto *Begin = cast_or_null<MCSymbolELF>(Section->getBeginSymbol());
void MCELFStreamer::EmitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
   getAssembler().registerSymbol(*Symbol);
   Symbol->setBinding(ELF::STB_LOCAL);
   Symbol->setExternal(false);
   EmitCommonSymbol(Symbol, Size, ByteAlignment);
 }
 
 void MCELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
                                   SMLoc Loc) {
-  if (isBundleLocked())
-    report_fatal_error("Emitting values inside a locked bundle is forbidden");
   fixSymbolsInTLSFixups(Value);
   MCObjectStreamer::EmitValueImpl(Value, Size, Loc);
 }
 
 void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment,
                                          int64_t Value,
                                          unsigned ValueSize,
                                          unsigned MaxBytesToEmit) {
-  if (isBundleLocked())
-    report_fatal_error("Emitting values inside a locked bundle is forbidden");
   MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value,
                                          ValueSize, MaxBytesToEmit);
 }
 
 // Add a symbol for the file name of this module. They start after the
 // null symbol and don't count as normal symbol, i.e. a non-STT_FILE symbol
 // with the same name may appear.
 void MCELFStreamer::EmitFileDirective(StringRef Filename) {
void MCELFStreamer::EmitInstToData(const MCInst &Inst,
   SmallVector<MCFixup, 4> Fixups;
   SmallString<256> Code;
   raw_svector_ostream VecOS(Code);
   Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
 
   for (unsigned i = 0, e = Fixups.size(); i != e; ++i)
     fixSymbolsInTLSFixups(Fixups[i].getValue());
 
-  // There are several possibilities here:
-  //
-  // If bundling is disabled, append the encoded instruction to the current data
-  // fragment (or create a new such fragment if the current fragment is not a
-  // data fragment).
-  //
-  // If bundling is enabled:
-  // - If we're not in a bundle-locked group, emit the instruction into a
-  //   fragment of its own. If there are no fixups registered for the
-  //   instruction, emit a MCCompactEncodedInstFragment. Otherwise, emit a
-  //   MCDataFragment.
-  // - If we're in a bundle-locked group, append the instruction to the current
-  //   data fragment because we want all the instructions in a group to get into
-  //   the same fragment. Be careful not to do that for the first instruction in
-  //   the group, though.
-  MCDataFragment *DF;
-
-  if (Assembler.isBundlingEnabled()) {
-    MCSection &Sec = *getCurrentSectionOnly();
-    if (Assembler.getRelaxAll() && isBundleLocked())
-      // If the -mc-relax-all flag is used and we are bundle-locked, we re-use
-      // the current bundle group.
-      DF = BundleGroups.back();
-    else if (Assembler.getRelaxAll() && !isBundleLocked())
-      // When not in a bundle-locked group and the -mc-relax-all flag is used,
-      // we create a new temporary fragment which will be later merged into
-      // the current fragment.
-      DF = new MCDataFragment();
-    else if (isBundleLocked() && !Sec.isBundleGroupBeforeFirstInst())
-      // If we are bundle-locked, we re-use the current fragment.
-      // The bundle-locking directive ensures this is a new data fragment.
-      DF = cast<MCDataFragment>(getCurrentFragment());
-    else if (!isBundleLocked() && Fixups.size() == 0) {
-      // Optimize memory usage by emitting the instruction to a
-      // MCCompactEncodedInstFragment when not in a bundle-locked group and
-      // there are no fixups registered.
-      MCCompactEncodedInstFragment *CEIF = new MCCompactEncodedInstFragment();
-      insert(CEIF);
-      CEIF->getContents().append(Code.begin(), Code.end());
-      return;
-    } else {
-      DF = new MCDataFragment();
-      insert(DF);
-    }
-    if (Sec.getBundleLockState() == MCSection::BundleLockedAlignToEnd) {
-      // If this fragment is for a group marked "align_to_end", set a flag
-      // in the fragment. This can happen after the fragment has already been
-      // created if there are nested bundle_align groups and an inner one
-      // is the one marked align_to_end.
-      DF->setAlignToBundleEnd(true);
-    }
-
-    // We're now emitting an instruction in a bundle group, so this flag has
-    // to be turned off.
-    Sec.setBundleGroupBeforeFirstInst(false);
-  } else {
-    DF = getOrCreateDataFragment();
-  }
+  MCDataFragment *DF = getOrCreateDataFragment();
 
   // Add the fixups and data.
   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
     Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
     DF->getFixups().push_back(Fixups[i]);
   }
   DF->setHasInstructions(true);
   DF->getContents().append(Code.begin(), Code.end());
-
-  if (Assembler.isBundlingEnabled() && Assembler.getRelaxAll()) {
-    if (!isBundleLocked()) {
-      mergeFragment(getOrCreateDataFragment(), DF);
-      delete DF;
-    }
-  }
-}
-
-void MCELFStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
-  assert(AlignPow2 <= 30 && "Invalid bundle alignment");
-  MCAssembler &Assembler = getAssembler();
-  if (AlignPow2 > 0 && (Assembler.getBundleAlignSize() == 0 ||
-                        Assembler.getBundleAlignSize() == 1U << AlignPow2))
-    Assembler.setBundleAlignSize(1U << AlignPow2);
-  else
-    report_fatal_error(".bundle_align_mode cannot be changed once set");
-}
-
-void MCELFStreamer::EmitBundleLock(bool AlignToEnd) {
-  MCSection &Sec = *getCurrentSectionOnly();
-
-  // Sanity checks
-  //
-  if (!getAssembler().isBundlingEnabled())
-    report_fatal_error(".bundle_lock forbidden when bundling is disabled");
-
-  if (!isBundleLocked())
-    Sec.setBundleGroupBeforeFirstInst(true);
-
-  if (getAssembler().getRelaxAll() && !isBundleLocked()) {
-    // TODO: drop the lock state and set directly in the fragment
-    MCDataFragment *DF = new MCDataFragment();
-    BundleGroups.push_back(DF);
-  }
-
-  Sec.setBundleLockState(AlignToEnd ? MCSection::BundleLockedAlignToEnd
-                                    : MCSection::BundleLocked);
-}
-
-void MCELFStreamer::EmitBundleUnlock() {
-  MCSection &Sec = *getCurrentSectionOnly();
-
-  // Sanity checks
-  if (!getAssembler().isBundlingEnabled())
-    report_fatal_error(".bundle_unlock forbidden when bundling is disabled");
-  else if (!isBundleLocked())
-    report_fatal_error(".bundle_unlock without matching lock");
-  else if (Sec.isBundleGroupBeforeFirstInst())
-    report_fatal_error("Empty bundle-locked group is forbidden");
-
-  // When the -mc-relax-all flag is used, we emit instructions to fragments
-  // stored on a stack. When the bundle unlock is emitted, we pop a fragment
-  // from the stack a merge it to the one below.
-  if (getAssembler().getRelaxAll()) {
-    assert(!BundleGroups.empty() && "There are no bundle groups");
-    MCDataFragment *DF = BundleGroups.back();
-
-    // FIXME: Use BundleGroups to track the lock state instead.
-    Sec.setBundleLockState(MCSection::NotBundleLocked);
-
-    // FIXME: Use more separate fragments for nested groups.
-    if (!isBundleLocked()) {
-      mergeFragment(getOrCreateDataFragment(), DF);
-      BundleGroups.pop_back();
-      delete DF;
-    }
-
-    if (Sec.getBundleLockState() != MCSection::BundleLockedAlignToEnd)
-      getOrCreateDataFragment()->setAlignToBundleEnd(false);
-  } else
-    Sec.setBundleLockState(MCSection::NotBundleLocked);
 }
 
 void MCELFStreamer::FinishImpl() {
-  // Ensure the last section gets aligned if necessary.
-  MCSection *CurSection = getCurrentSectionOnly();
-  setSectionAlignmentForBundling(getAssembler(), CurSection);
-
   EmitFrames(nullptr);
 
   this->MCObjectStreamer::FinishImpl();
 }
 
 MCStreamer *llvm::createELFStreamer(MCContext &Context, MCAsmBackend &MAB,
                                     raw_pwrite_stream &OS, MCCodeEmitter *CE,
                                     bool RelaxAll) {

lib/MC/MCFragment.cpp

uint64_t MCAsmLayout::getSectionFileSize(const MCSection *Sec) const {
   // Virtual sections have no file size.
   if (Sec->isVirtualSection())
     return 0;
 
   // Otherwise, the file size is the same as the address space size.
   return getSectionAddressSize(Sec);
 }
 
-uint64_t llvm::computeBundlePadding(const MCAssembler &Assembler,
-                                    const MCFragment *F,
-                                    uint64_t FOffset, uint64_t FSize) {
-  uint64_t BundleSize = Assembler.getBundleAlignSize();
-  assert(BundleSize > 0 &&
-         "computeBundlePadding should only be called if bundling is enabled");
-  uint64_t BundleMask = BundleSize - 1;
-  uint64_t OffsetInBundle = FOffset & BundleMask;
-  uint64_t EndOfFragment = OffsetInBundle + FSize;
-
-  // There are two kinds of bundling restrictions:
-  //
-  // 1) For alignToBundleEnd(), add padding to ensure that the fragment will
-  //    *end* on a bundle boundary.
-  // 2) Otherwise, check if the fragment would cross a bundle boundary. If it
-  //    would, add padding until the end of the bundle so that the fragment
-  //    will start in a new one.
-  if (F->alignToBundleEnd()) {
-    // Three possibilities here:
-    //
-    // A) The fragment just happens to end at a bundle boundary, so we're good.
-    // B) The fragment ends before the current bundle boundary: pad it just
-    //    enough to reach the boundary.
-    // C) The fragment ends after the current bundle boundary: pad it until it
-    //    reaches the end of the next bundle boundary.
-    //
-    // Note: this code could be made shorter with some modulo trickery, but it's
-    // intentionally kept in its more explicit form for simplicity.
-    if (EndOfFragment == BundleSize)
-      return 0;
-    else if (EndOfFragment < BundleSize)
-      return BundleSize - EndOfFragment;
-    else { // EndOfFragment > BundleSize
-      return 2 * BundleSize - EndOfFragment;
-    }
-  } else if (OffsetInBundle > 0 && EndOfFragment > BundleSize)
-    return BundleSize - OffsetInBundle;
-  else
-    return 0;
-}
-
 /* *** */
 
 void ilist_node_traits<MCFragment>::deleteNode(MCFragment *V) {
   V->destroy();
 }
 
-MCFragment::MCFragment() : Kind(FragmentType(~0)), HasInstructions(false),
-                           AlignToBundleEnd(false), BundlePadding(0) {
-}
+MCFragment::MCFragment() : Kind(FragmentType(~0)), HasInstructions(false) {}
 
 MCFragment::~MCFragment() { }
 
 MCFragment::MCFragment(FragmentType Kind, bool HasInstructions,
-                       uint8_t BundlePadding, MCSection *Parent)
-    : Kind(Kind), HasInstructions(HasInstructions), AlignToBundleEnd(false),
-      BundlePadding(BundlePadding), Parent(Parent), Atom(nullptr),
+                       MCSection *Parent)
+    : Kind(Kind), HasInstructions(HasInstructions), BundleLocked(false),
+      BundleAlignToEnd(false), Parent(Parent), Atom(nullptr),
       Offset(~UINT64_C(0)) {
   if (Parent && !isDummy())
     Parent->getFragmentList().push_back(this);
 }
 
 void MCFragment::destroy() {
   // First check if we are the sentinal.
   if (Kind == FragmentType(~0)) {
case FT_SafeSEH:
       delete cast<MCSafeSEHFragment>(this);
       return;
     case FT_CVInlineLines:
       delete cast<MCCVInlineLineTableFragment>(this);
       return;
     case FT_CVDefRange:
       delete cast<MCCVDefRangeFragment>(this);
       return;
+    case FT_BundleAlign:
+      delete cast<MCBundleAlignFragment>(this);
+      return;
     case FT_Dummy:
       delete cast<MCDummyFragment>(this);
       return;
   }
 }
 
 /* *** */
 
LLVM_DUMP_METHOD void MCFragment::dump() {
   case MCFragment::FT_Relaxable:  OS << "MCRelaxableFragment"; break;
   case MCFragment::FT_Org:   OS << "MCOrgFragment"; break;
   case MCFragment::FT_Dwarf: OS << "MCDwarfFragment"; break;
   case MCFragment::FT_DwarfFrame: OS << "MCDwarfCallFrameFragment"; break;
   case MCFragment::FT_LEB:   OS << "MCLEBFragment"; break;
   case MCFragment::FT_SafeSEH:    OS << "MCSafeSEHFragment"; break;
   case MCFragment::FT_CVInlineLines: OS << "MCCVInlineLineTableFragment"; break;
   case MCFragment::FT_CVDefRange: OS << "MCCVDefRangeTableFragment"; break;
+  case MCFragment::FT_BundleAlign: OS << "MCBundleAlignFragment"; break;
   case MCFragment::FT_Dummy: OS << "MCDummyFragment"; break;
   }
 
   OS << "<MCFragment " << (void*) this << " LayoutOrder:" << LayoutOrder
      << " Offset:" << Offset
-     << " HasInstructions:" << hasInstructions() 
-     << " BundlePadding:" << static_cast<unsigned>(getBundlePadding()) << ">";
+     << " HasInstructions:" << hasInstructions()
+     << " BundleLocked:" << BundleLocked
+     << " BundleAlignToEnd:" << BundleAlignToEnd;
 
   switch (getKind()) {
   case MCFragment::FT_Align: {
     const MCAlignFragment *AF = cast<MCAlignFragment>(this);
     if (AF->hasEmitNops())
       OS << " (emit nops)";
     OS << "\n       ";
     OS << " Alignment:" << AF->getAlignment()
case MCFragment::FT_CVDefRange: {
     OS << "\n       ";
     for (std::pair<const MCSymbol *, const MCSymbol *> RangeStartEnd :
          F->getRanges()) {
       OS << " RangeStart:" << RangeStartEnd.first;
       OS << " RangeEnd:" << RangeStartEnd.second;
     }
     break;
   }
+  case MCFragment::FT_BundleAlign: {
+    const auto *F = cast<MCBundleAlignFragment>(this);
+    OS << "\n       ";
+    OS << "Alignment: "<<  F->getAlignment();
+    break;
+  }
   case MCFragment::FT_Dummy:
     break;
   }
   OS << ">";
 }
 
 LLVM_DUMP_METHOD void MCAssembler::dump() {
   raw_ostream &OS = llvm::errs();

lib/MC/MCObjectStreamer.cpp

 using namespace llvm;
 
 MCObjectStreamer::MCObjectStreamer(MCContext &Context, MCAsmBackend &TAB,
                                    raw_pwrite_stream &OS,
                                    MCCodeEmitter *Emitter_)
     : MCStreamer(Context),
       Assembler(new MCAssembler(Context, TAB, *Emitter_,
                                 *TAB.createObjectWriter(OS))),
-      EmitEHFrame(true), EmitDebugFrame(false) {}
+      EmitEHFrame(true), EmitDebugFrame(false), BundleDepth(0),
+      BundleAlignment(0), BundleAlignToEnd(false) {}
 
 MCObjectStreamer::~MCObjectStreamer() {
   delete &Assembler->getBackend();
   delete &Assembler->getEmitter();
   delete &Assembler->getWriter();
   delete Assembler;
 }
 
MCFragment *MCObjectStreamer::getCurrentFragment() const {
 
   return nullptr;
 }
 
 MCDataFragment *MCObjectStreamer::getOrCreateDataFragment() {
   MCDataFragment *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
   // When bundling is enabled, we don't want to add data to a fragment that
   // already has instructions (see MCELFStreamer::EmitInstToData for details)
-  if (!F || (Assembler->isBundlingEnabled() && !Assembler->getRelaxAll() &&
-             F->hasInstructions())) {
+  if (!F || BundleAlignment != 0) {
     F = new MCDataFragment();
     insert(F);
   }
   return F;
 }
 
 void MCObjectStreamer::visitUsedSymbol(const MCSymbol &Sym) {
   Assembler->registerSymbol(Sym);
void MCObjectStreamer::EmitLabel(MCSymbol *Symbol) {
   MCStreamer::EmitLabel(Symbol);
 
   getAssembler().registerSymbol(*Symbol);
 
   // If there is a current fragment, mark the symbol as pointing into it.
   // Otherwise queue the label and set its fragment pointer when we emit the
   // next fragment.
   auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
-  if (F && !(getAssembler().isBundlingEnabled() &&
-             getAssembler().getRelaxAll())) {
+  if (F && BundleAlignment == 0) {
     Symbol->setFragment(F);
     Symbol->setOffset(F->getContents().size());
   } else {
     PendingLabels.push_back(Symbol);
   }
 }
 
 void MCObjectStreamer::EmitULEB128Value(const MCExpr *Value) {

 
 void MCObjectStreamer::EmitWeakReference(MCSymbol *Alias,
                                          const MCSymbol *Symbol) {
   report_fatal_error("This file format doesn't support weak aliases.");
 }
 
 void MCObjectStreamer::ChangeSection(MCSection *Section,
                                      const MCExpr *Subsection) {
+  if (BundleDepth != 0)
+   report_fatal_error("Unterminated .bundle_lock when changing a section");
+
   changeSectionImpl(Section, Subsection);
+  if(Section->getFragmentList().empty() && BundleAlignment != 0) {
+    auto Frag = new MCBundleAlignFragment(1U << BundleAlignment);
+    Section->getFragmentList().push_back(Frag);
+    Frag->setParent(Section);
+    Section->addBundleAlignment(Frag);
+  }
 }
 
 bool MCObjectStreamer::changeSectionImpl(MCSection *Section,
                                          const MCExpr *Subsection) {
   assert(Section && "Cannot switch to a null section!");
   flushPendingLabels(nullptr);
 
   bool Created = getAssembler().registerSection(*Section);
void MCObjectStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
   getAssembler().registerSymbol(*Symbol);
   MCStreamer::EmitAssignment(Symbol, Value);
 }
 
 bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
   return Sec.hasInstructions();
 }
 
+namespace {
+class BundleUnlocker {
+public:
+  BundleUnlocker(MCObjectStreamer *Streamer, bool AlignToEnd, bool Locked) :
+    Streamer(Streamer), AlignToEnd(AlignToEnd), Locked(Locked) { }
+  ~BundleUnlocker() {
+    MCFragment *Frag = Streamer->getCurrentFragment();
+    Frag->setBundleLocked(Locked);
+    Frag->setBundleAlignToEnd(AlignToEnd);
+  }
+  MCObjectStreamer *Streamer;
+  bool AlignToEnd;
+  bool Locked;
+};
+}
+
 void MCObjectStreamer::EmitInstruction(const MCInst &Inst,
                                        const MCSubtargetInfo &STI) {
+  BundleUnlocker Unlocker(this, BundleAlignToEnd, BundleDepth > 0);
   MCStreamer::EmitInstruction(Inst, STI);
 
   MCSection *Sec = getCurrentSectionOnly();
+  unsigned BundleSize = 1U << BundleAlignment;
+  if (Sec->getAlignment() < BundleSize)
+    Sec->setAlignment(BundleSize);
   Sec->setHasInstructions(true);
 
   // Now that a machine instruction has been assembled into this section, make
   // a line entry for any .loc directive that has been seen.
   MCCVLineEntry::Make(this);
   MCDwarfLineEntry::Make(this, getCurrentSection().first);
 
-  // If this instruction doesn't need relaxation, just emit it as data.
   MCAssembler &Assembler = getAssembler();
-  if (!Assembler.getBackend().mayNeedRelaxation(Inst)) {
-    EmitInstToData(Inst, STI);
-    return;
-  }
-
   // Otherwise, relax and emit it as data if either:
   // - The RelaxAll flag was passed
   // - Bundling is enabled and this instruction is inside a bundle-locked
   //   group. We want to emit all such instructions into the same data
   //   fragment.
-  if (Assembler.getRelaxAll() ||
-      (Assembler.isBundlingEnabled() && Sec->isBundleLocked())) {
+  if (Assembler.getBackend().mayNeedRelaxation(Inst) &&
+      Assembler.getRelaxAll()) {
     MCInst Relaxed;
     getAssembler().getBackend().relaxInstruction(Inst, Relaxed);
     while (getAssembler().getBackend().mayNeedRelaxation(Relaxed))
       getAssembler().getBackend().relaxInstruction(Relaxed, Relaxed);
     EmitInstToData(Relaxed, STI);
     return;
   }
 
+  // If this instruction doesn't need relaxation, just emit it as data.
+  if (!Assembler.getBackend().mayNeedRelaxation(Inst)) {
+    EmitInstToData(Inst, STI);
+    return;
+  }
+
   // Otherwise emit to a separate fragment.
   EmitInstToFragment(Inst, STI);
 }
 
 void MCObjectStreamer::EmitInstToFragment(const MCInst &Inst,
                                           const MCSubtargetInfo &STI) {
-  if (getAssembler().getRelaxAll() && getAssembler().isBundlingEnabled())
-    llvm_unreachable("All instructions should have already been relaxed");
-
   // Always create a new, separate fragment here, because its size can change
   // during relaxation.
   MCRelaxableFragment *IF = new MCRelaxableFragment(Inst, STI);
   insert(IF);
 
   SmallString<128> Code;
   raw_svector_ostream VecOS(Code);
   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, IF->getFixups(),
                                                 STI);
   IF->getContents().append(Code.begin(), Code.end());
 }
 
 #ifndef NDEBUG
 static const char *const BundlingNotImplementedMsg =
   "Aligned bundling is not implemented for this object format";
 #endif
 
-void MCObjectStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
-  llvm_unreachable(BundlingNotImplementedMsg);
-}
-
-void MCObjectStreamer::EmitBundleLock(bool AlignToEnd) {
-  llvm_unreachable(BundlingNotImplementedMsg);
-}
-
-void MCObjectStreamer::EmitBundleUnlock() {
-  llvm_unreachable(BundlingNotImplementedMsg);
-}
-
 void MCObjectStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                              unsigned Column, unsigned Flags,
                                              unsigned Isa,
                                              unsigned Discriminator,
                                              StringRef FileName) {
   // In case we see two .loc directives in a row, make sure the
   // first one gets a line entry.
   MCDwarfLineEntry::Make(this, getCurrentSection().first);
if (getContext().getGenDwarfForAssembly())
     MCGenDwarfInfo::Emit(this);
 
   // Dump out the dwarf file & directory tables and line tables.
   MCDwarfLineTable::Emit(this, getAssembler().getDWARFLinetableParams());
 
   flushPendingLabels(nullptr);
   getAssembler().Finish();
 }
+
+void MCObjectStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
+  BundleAlignment = AlignPow2;
+  MCSection *CurSection = getCurrentSectionOnly();
+  if(CurSection != nullptr) {
+    auto Frag = new MCBundleAlignFragment(1U << BundleAlignment);
+    insert(Frag);
+    CurSection->addBundleAlignment(Frag);
+  }
+}
+
+void MCObjectStreamer::EmitBundleLock(bool AlignToEnd) {
+  if (BundleAlignment == 0)
+    report_fatal_error(".bundle_lock forbidden when bundling is disabled");
+  BundleDepth++;
+  BundleAlignToEnd |= AlignToEnd;
+}
+
+void MCObjectStreamer::EmitBundleUnlock() {
+  if(BundleDepth == 0)
+    report_fatal_error(".bundle_unlock without matching lock");
+  --BundleDepth;
+  if (BundleDepth == 0) {
+    getCurrentFragment()->setBundleLocked(false);
+    BundleAlignToEnd = false;
+  }
+}

lib/MC/MCSection.cpp

 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // MCSection
 //===----------------------------------------------------------------------===//
 
 MCSection::MCSection(SectionVariant V, SectionKind K, MCSymbol *Begin)
-    : Begin(Begin), BundleGroupBeforeFirstInst(false), HasInstructions(false),
+    : Begin(Begin),  HasInstructions(false),
       IsRegistered(false), DummyFragment(this), Variant(V), Kind(K) {}
 
 MCSymbol *MCSection::getEndSymbol(MCContext &Ctx) {
   if (!End)
     End = Ctx.createTempSymbol("sec_end", true);
   return End;
 }
 
 bool MCSection::hasEnded() const { return End && End->isInSection(); }
 
-MCSection::~MCSection() {
+uint64_t
+MCSection::getBundleAlignment(MCFragment const &Frag) const {
+  auto NextAlignment =
+      std::upper_bound(BundleAlignments.begin(), BundleAlignments.end(),
+                       &Frag,
+                       [&Frag](MCFragment const *const &LHS,
+                               MCFragment const *const &RHS) {
+      return LHS->getLayoutOrder() < RHS->getLayoutOrder();
+      });
+  if (NextAlignment == BundleAlignments.begin())
+    return 0;
+  --NextAlignment;
+  return (*NextAlignment)->getAlignment();
+}
+
+uint64_t MCSection::getBundleAlignment() const {
+  if (BundleAlignments.empty())
+    return 0;
+  return BundleAlignments.back()->getAlignment();
 }
 
-void MCSection::setBundleLockState(BundleLockStateType NewState) {
-  if (NewState == NotBundleLocked) {
-    if (BundleLockNestingDepth == 0) {
-      report_fatal_error("Mismatched bundle_lock/unlock directives");
-    }
-    if (--BundleLockNestingDepth == 0) {
-      BundleLockState = NotBundleLocked;
-    }
-    return;
-  }
-
-  // If any of the directives is an align_to_end directive, the whole nested
-  // group is align_to_end. So don't downgrade from align_to_end to just locked.
-  if (BundleLockState != BundleLockedAlignToEnd) {
-    BundleLockState = NewState;
-  }
-  ++BundleLockNestingDepth;
+MCSection::~MCSection() {
 }
 
 MCSection::iterator
 MCSection::getSubsectionInsertionPoint(unsigned Subsection) {
   if (Subsection == 0 && SubsectionFragmentMap.empty())
     return end();
 
   SmallVectorImpl<std::pair<unsigned, MCFragment *>>::iterator MI =

test/MC/X86/AlignedBundling/misaligned-bundle-group.s

 # RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu %s -o - \
 # RUN:   | llvm-objdump -disassemble -no-show-raw-insn - \
-# RUN:   | FileCheck -check-prefix=CHECK -check-prefix=CHECK-OPT %s
+# RUN:   | FileCheck -check-prefix=CHECK %s
 # RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu -mc-relax-all %s -o - \
 # RUN:   | llvm-objdump -disassemble -no-show-raw-insn - \
-# RUN:   | FileCheck -check-prefix=CHECK -check-prefix=CHECK-RELAX %s
+# RUN:   | FileCheck -check-prefix=CHECK %s
 
         .text
 foo:
         .bundle_align_mode 5
         push    %ebp # 1 byte
         .align  16
         .bundle_lock align_to_end
 # CHECK:            1:  nopw %cs:(%eax,%eax)
 # CHECK:            10: nopw %cs:(%eax,%eax)
-# CHECK-RELAX:      1f: nop
-# CHECK-RELAX:      20: nopw %cs:(%eax,%eax)
-# CHECK-RELAX:      2f: nopw %cs:(%eax,%eax)
-# CHECK-OPT:        1b: calll -4
-# CHECK-RELAX:      3b: calll -4
+# CHECK:        1b: calll -4
         calll   bar # 5 bytes
         .bundle_unlock
         ret         # 1 byte

test/MC/X86/AlignedBundling/misaligned-bundle.s

 # RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu %s -o - \
 # RUN:   | llvm-objdump -disassemble -no-show-raw-insn - \
-# RUN:   | FileCheck -check-prefix=CHECK -check-prefix=CHECK-OPT %s
+# RUN:   | FileCheck %s
 # RUN: llvm-mc -filetype=obj -triple i686-pc-linux-gnu -mc-relax-all %s -o - \
 # RUN:   | llvm-objdump -disassemble -no-show-raw-insn - \
-# RUN:   | FileCheck -check-prefix=CHECK -check-prefix=CHECK-RELAX %s
+# RUN:   | FileCheck %s
 
         .text
 foo:
         .bundle_align_mode 5
         push    %ebp          # 1 byte
         .align  16
 # CHECK:            1:  nopw %cs:(%eax,%eax)
-# CHECK-RELAX:      10: nopw %cs:(%eax,%eax)
-# CHECK-RELAX:      1f: nop
-# CHECK-OPT:        10: movl $1, (%esp)
-# CHECK-RELAX:      20: movl $1, (%esp)
+# CHECK:        10: movl $1, (%esp)
         movl $0x1, (%esp)     # 7 bytes
         movl $0x1, (%esp)     # 7 bytes
-# CHECK-OPT:        1e: nop
+# CHECK:        1e: nop
         movl $0x2, 0x1(%esp)  # 8 bytes
         movl $0x2, 0x1(%esp)  # 8 bytes
-# CHECK-RELAX:      3e: nop
-# CHECK-RELAX:      40: movl $2, 1(%esp)
         movl $0x2, 0x1(%esp)  # 8 bytes
         movl $0x2, (%esp)     # 7 bytes
-# CHECK-OPT:        3f: nop
-# CHECK-OPT:        40: movl $3, (%esp)
+# CHECK:        3f: nop
+# CHECK:        40: movl $3, (%esp)
         movl $0x3, (%esp)     # 7 bytes
         movl $0x3, (%esp)     # 7 bytes
         ret

test/MC/X86/AlignedBundling/nesting.s

# CHECK-NEXT: 15: callq {{.*}} <bar>
   .p2align 4
 # CHECK-LABEL: bar:
 .type   bar,@function
 bar:
   callq foo
   callq foo
 # Check that the callqs get bundled together, and that the whole group is
 # align_to_end
-  .bundle_lock 
+  .bundle_lock
   callq bar
   .bundle_lock align_to_end
   callq bar
   .bundle_unlock
   .bundle_unlock
 # CHECK:      36: callq {{.*}} <bar>
 # CHECK-NEXT: 3b: callq {{.*}} <bar>
 
 # CHECK-LABEL: baz:
 .type   baz,@function

test/MC/X86/AlignedBundling/relax-in-bundle-group.s

 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - \
 # RUN:   | llvm-objdump -disassemble - | FileCheck %s
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu -mc-relax-all %s -o - \
-# RUN:   | llvm-objdump -disassemble - | FileCheck %s
+# RUN:   | llvm-objdump -disassemble - | FileCheck --check-prefix=CHECK-RELAX %s
 
 # Test that instructions inside bundle-locked groups are relaxed even if their
 # fixup is short enough not to warrant relaxation on its own.
 
   .text
 foo:
   .bundle_align_mode 4
   pushq   %rbp
 
   movl    %edi, %ebx
   callq   bar
   movl    %eax, %r14d
   imull   $17, %ebx, %ebp
   movl    %ebx, %edi
   callq   bar
   cmpl    %r14d, %ebp
   .bundle_lock
 
   jle     .L_ELSE
 # This group would've started at 0x18 and is too long, so a chunky NOP padding
 # is inserted to push it to 0x20.
-# CHECK: 18: {{[a-f0-9 ]+}} nopl
+# CHECK-RELAX: 18: {{[a-f0-9 ]+}} nopl
 
 # The long encoding for JLE should be used here even though its target is close
-# CHECK-NEXT: 20: 0f 8e
+# CHECK: 18: 7e 06
+# CHECK-RELAX-NEXT: 20: 0f 8e
 
   addl    %ebp, %eax
 
   jmp     .L_RET
 # Same for the JMP
-# CHECK: 28: e9
+# CHECK: 1c: eb
+# CHECK-RELAX: 28: e9
 
   .bundle_unlock
 
 .L_ELSE:
   imull   %ebx, %eax
 .L_RET:
 
   popq    %rbx