[WIP] Draft assembler support for branch alignment

[reames]

Summary

Inspired by discussion on D70157. Please direct all discussion there until direction is agreed on. This isn't worthy of review until we settle on direction and syntax, it's just posted for context.

In particular, this patch is: a) using unsettled syntax which will likely change, b) has no actual implementation, and c) is missing a whole bunch of tests.

The syntax used in this patch is:

.push_align_branch_boundary 5 jcc, fused, call
callq bar
.pop_align_branch_boundary

[reames]

Rebase after CodePadding removal.

[reames]

Update to proposed .push_align_branch_boundary syntax. Note that there's no implementation - as that's in the original patch - this is just round trip serialization.

llvm/include/llvm/MC/MCAssembler.h

private:
 
   /// Perform one layout iteration of the given section and return true
   /// if any offsets were adjusted.
   bool layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec);
 
   bool relaxInstruction(MCAsmLayout &Layout, MCRelaxableFragment &IF);
 
   bool relaxLEB(MCAsmLayout &Layout, MCLEBFragment &IF);
-
+  bool relaxBoundaryAlign(MCAsmLayout &Layout,
+                          MCBoundaryAlignFragment &MF);
   bool relaxDwarfLineAddr(MCAsmLayout &Layout, MCDwarfLineAddrFragment &DF);
   bool relaxDwarfCallFrameFragment(MCAsmLayout &Layout,
                                    MCDwarfCallFrameFragment &DF);
   bool relaxCVInlineLineTable(MCAsmLayout &Layout,
                               MCCVInlineLineTableFragment &DF);
   bool relaxCVDefRange(MCAsmLayout &Layout, MCCVDefRangeFragment &DF);
 
   /// finishLayout - Finalize a layout, including fragment lowering.

llvm/include/llvm/MC/MCFragment.h

enum FragmentType : uint8_t {
     FT_Data,
     FT_CompactEncodedInst,
     FT_Fill,
     FT_Relaxable,
     FT_Org,
     FT_Dwarf,
     FT_DwarfFrame,
     FT_LEB,
+    FT_BoundaryAlign,
     FT_SymbolId,
     FT_CVInlineLines,
     FT_CVDefRange,
     FT_Dummy
   };
 
 private:
   FragmentType Kind;
public:
   StringRef getFixedSizePortion() const { return FixedSizePortion; }
   /// @}
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_CVDefRange;
   }
 };
 
+/// Representing required padding such that the region of instructions
+/// designated by the fragment one past this one to the designated fragment
+/// does does not cross a particular power-of-two boundary. 
+class MCBoundaryAlignFragment : public MCFragment {
+private:
+  /// The size of the MCBoundaryAlignFragment.  Lazily populated
+  /// during relaxation.
+  unsigned Size = 0;
+  /// The fragment which is the inclusive end of the region being aligned
+  /// w.r.t. the specified boundary.  (The begining is the fragment immediately
+  /// following this one.)
+  const MCFragment *Fragment = nullptr;
+  /// The boundary which must not be crossed.  Must be a power of two.
+  unsigned AlignBoundarySize = 0;
+
+public:
+  MCBoundaryAlignFragment(unsigned AlignBoundarySize,
+                             MCSection *Sec = nullptr)
+      : MCFragment(FT_BoundaryAlign, false, Sec),
+        AlignBoundarySize(AlignBoundarySize) {}
+
+  unsigned getBoundarySize() const { return AlignBoundarySize; }
+
+  void setSize(unsigned Value) { Size = Value; }
+  uint64_t getSize() const { return Size; }
+
+  void setFragment(const MCFragment *Target) {
+    assert(Target->getParent() == getParent() && "same section expected");
+    Fragment = Target;
+  }
+  const MCFragment *getFragment() const { return Fragment; }
+
+  static bool classof(const MCFragment *F) {
+    return F->getKind() == MCFragment::FT_BoundaryAlign;
+  }
+};
 } // end namespace llvm
 
 #endif // LLVM_MC_MCFRAGMENT_H

llvm/include/llvm/MC/MCObjectStreamer.h

class MCObjectStreamer : public MCStreamer {
   struct PendingMCFixup {
     const MCSymbol *Sym;
     MCFixup Fixup;
     MCDataFragment *DF;
     PendingMCFixup(const MCSymbol *McSym, MCDataFragment *F, MCFixup McFixup)
         : Sym(McSym), Fixup(McFixup), DF(F) {}
   };
   SmallVector<PendingMCFixup, 2> PendingFixups;
+  MCBoundaryAlignFragment *PendingBA = nullptr;
 
   virtual void EmitInstToData(const MCInst &Inst, const MCSubtargetInfo&) = 0;
   void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
   void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
   MCSymbol *EmitCFILabel() override;
   void resolvePendingFixups();
 
 protected:
public:
   void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
   /// Emit an instruction to a special fragment, because this instruction
   /// can change its size during relaxation.
   virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
 
+  void EmitBoundaryAlign(unsigned AlignPow2) override;
+  void EmitBoundaryAlignEnd() override;
   void EmitBundleAlignMode(unsigned AlignPow2) override;
   void EmitBundleLock(bool AlignToEnd) override;
   void EmitBundleUnlock() override;
   void EmitBytes(StringRef Data) override;
   void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
                             unsigned ValueSize = 1,
                             unsigned MaxBytesToEmit = 0) override;
   void EmitCodeAlignment(unsigned ByteAlignment,

llvm/include/llvm/MC/MCStreamer.h

public:
   }
 
   virtual void EmitAddrsig() {}
   virtual void EmitAddrsigSym(const MCSymbol *Sym) {}
 
   /// Emit the given \p Instruction into the current section.
   virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 
+  /// Mark the region between .boundary_align N and .boundary_align_end  as
+  /// having an alignment requirement such that it can't cross (or end at) the
+  /// specified boundary. 
+  virtual void EmitBoundaryAlign(unsigned BoundaryPow2);
+  virtual void EmitBoundaryAlignEnd();
+
   /// Set the bundle alignment mode from now on in the section.
   /// The argument is the power of 2 to which the alignment is set. The
   /// value 0 means turn the bundle alignment off.
   virtual void EmitBundleAlignMode(unsigned AlignPow2);
 
   /// The following instructions are a bundle-locked group.
   ///
   /// \param AlignToEnd - If true, the bundle-locked group will be aligned to

llvm/lib/MC/MCAsmStreamer.cpp

void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
                         SMLoc Loc) override;
   void EmitWinEHHandlerData(SMLoc Loc) override;
 
   void emitCGProfileEntry(const MCSymbolRefExpr *From,
                           const MCSymbolRefExpr *To, uint64_t Count) override;
 
   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
+  void EmitBoundaryAlign(unsigned BoundaryPow2) override;
+  void EmitBoundaryAlignEnd() override;
   void EmitBundleAlignMode(unsigned AlignPow2) override;
   void EmitBundleLock(bool AlignToEnd) override;
   void EmitBundleUnlock() override;
 
   bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
                           const MCExpr *Expr, SMLoc Loc,
                           const MCSubtargetInfo &STI) override;
 
void MCAsmStreamer::EmitInstruction(const MCInst &Inst,
 
   StringRef Comments = CommentToEmit;
   if (Comments.size() && Comments.back() != '\n')
     GetCommentOS() << "\n";
 
   EmitEOL();
 }
 
+void MCAsmStreamer::EmitBoundaryAlign(unsigned AlignPow2) {
+  OS << "\t.boundary_align " << AlignPow2;
+  EmitEOL();
+}
+
+void MCAsmStreamer::EmitBoundaryAlignEnd() {
+  OS << "\t.boundary_align_end";
+  EmitEOL();
+}
+
 void MCAsmStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
   OS << "\t.bundle_align_mode " << AlignPow2;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitBundleLock(bool AlignToEnd) {
   OS << "\t.bundle_lock";
   if (AlignToEnd)

llvm/lib/MC/MCAssembler.cpp

if (Size < 0) {
       return 0;
     }
     return Size;
   }
 
   case MCFragment::FT_LEB:
     return cast<MCLEBFragment>(F).getContents().size();
 
+  case MCFragment::FT_BoundaryAlign:
+    return cast<MCBoundaryAlignFragment>(F).getSize();
+
   case MCFragment::FT_SymbolId:
     return 4;
 
   case MCFragment::FT_Align: {
     const MCAlignFragment &AF = cast<MCAlignFragment>(F);
     unsigned Offset = Layout.getFragmentOffset(&AF);
     unsigned Size = offsetToAlignment(Offset, Align(AF.getAlignment()));
 
static void writeFragment(raw_ostream &OS, const MCAssembler &Asm,
   }
 
   case MCFragment::FT_LEB: {
     const MCLEBFragment &LF = cast<MCLEBFragment>(F);
     OS << LF.getContents();
     break;
   }
 
+  case MCFragment::FT_BoundaryAlign: {
+    if (FragmentSize == 0)
+      break;
+    if (!Asm.getBackend().writeNopData(OS, FragmentSize))
+      report_fatal_error("unable to write nop sequence of " +
+                         Twine(FragmentSize) + " bytes");
+    break;
+  }
+
   case MCFragment::FT_SymbolId: {
     const MCSymbolIdFragment &SF = cast<MCSymbolIdFragment>(F);
     support::endian::write<uint32_t>(OS, SF.getSymbol()->getIndex(), Endian);
     break;
   }
 
   case MCFragment::FT_Org: {
     ++stats::EmittedOrgFragments;
bool MCAssembler::relaxLEB(MCAsmLayout &Layout, MCLEBFragment &LF) {
   // only increase an LEB fragment size here, not decrease it. See PR35809.
   if (LF.isSigned())
     encodeSLEB128(Value, OSE, OldSize);
   else
     encodeULEB128(Value, OSE, OldSize);
   return OldSize != LF.getContents().size();
 }
 
+/// mayCrossBoundary - Check if the branch with given address and size crosses
+/// the boundary.
+static bool mayCrossBoundary(unsigned StartAddr, unsigned Size,
+                             unsigned BoundarySize) {
+  unsigned EndAddr = StartAddr + Size;
+  return StartAddr / BoundarySize != ((EndAddr - 1) / BoundarySize);
+}
+
+/// isAgainstBoundary - Check if the branch with given address and size is
+/// against the boundary.
+static bool isAgainstBoundary(unsigned StartAddr, unsigned Size,
+                              unsigned BoundarySize) {
+  unsigned EndAddr = StartAddr + Size;
+  return EndAddr % BoundarySize == 0;
+}
+
+/// needPadding - Check if the branch with given address and size needs padding.
+static bool needPadding(unsigned StartAddr, unsigned Size,
+                        unsigned BoundarySize) {
+  return mayCrossBoundary(StartAddr, Size, BoundarySize) ||
+         isAgainstBoundary(StartAddr, Size, BoundarySize);
+}
+
+///  getPaddingSize - Get how many bytes need to be padded to align branch with
+///  given address if the branch cross or is against the boundary.
+static unsigned getPaddingSize(unsigned StartAddr, unsigned BoundarySize) {
+  return BoundarySize - (StartAddr % BoundarySize);
+}
+
+/// getInstSize - Get the size of encoded instruction in the fragment.
+// Can't this be replaced w/computeFragmentSize?
+static unsigned getInstSize(const MCFragment &F) {
+  switch (F.getKind()) {
+  default:
+    llvm_unreachable("Illegal fragment type");
+  case MCFragment::FT_Data:
+    return cast<MCDataFragment>(F).getContents().size();
+  case MCFragment::FT_Relaxable:
+    return cast<MCRelaxableFragment>(F).getContents().size();
+  case MCFragment::FT_CompactEncodedInst:
+    return cast<MCCompactEncodedInstFragment>(F).getContents().size();
+  }
+}
+
+/// Return the total size of all the fragments within the range specified by
+/// [Begin, End]
+static unsigned getSizeOfFragmentRange(const MCFragment *Begin, const MCFragment *End) {
+  unsigned Sum = 0;
+  while(true) {
+    Sum += getInstSize(*Begin);
+    if (Begin == End)
+      break;
+    Begin = Begin->getNextNode();
+  }
+  return Sum;
+}
+  
+
+bool MCAssembler::relaxBoundaryAlign(MCAsmLayout &Layout,
+                                     MCBoundaryAlignFragment &MF) {
+  auto *BranchFragment = MF.getFragment();
+  if (!BranchFragment)
+    return false;
+  auto *RegionBegin = MF.getNextNode();
+  unsigned BoundarySize = MF.getBoundarySize();
+  unsigned OldSize = MF.getSize();
+  unsigned AlignedSize = getSizeOfFragmentRange(RegionBegin, BranchFragment);
+  assert(AlignedSize <= BoundarySize);
+  unsigned AlignedOffset = Layout.getFragmentOffset(RegionBegin);
+  AlignedOffset -= OldSize;
+  dbgs() << AlignedSize << "@" << AlignedOffset << "\n";
+  unsigned NewSize = 0;
+  if (needPadding(AlignedOffset, AlignedSize, BoundarySize)) {
+    NewSize = getPaddingSize(AlignedOffset, BoundarySize);
+    dbgs() << NewSize << " " << BoundarySize << "\n";
+    assert(NewSize < BoundarySize);
+  }
+  MF.setSize(NewSize);
+  return (NewSize != OldSize);
+}
+
 bool MCAssembler::relaxDwarfLineAddr(MCAsmLayout &Layout,
                                      MCDwarfLineAddrFragment &DF) {
   MCContext &Context = Layout.getAssembler().getContext();
   uint64_t OldSize = DF.getContents().size();
   int64_t AddrDelta;
   bool Abs = DF.getAddrDelta().evaluateKnownAbsolute(AddrDelta, Layout);
   assert(Abs && "We created a line delta with an invalid expression");
   (void)Abs;
for (MCSection::iterator I = Sec.begin(), IE = Sec.end(); I != IE; ++I) {
     case MCFragment::FT_DwarfFrame:
       RelaxedFrag =
         relaxDwarfCallFrameFragment(Layout,
                                     *cast<MCDwarfCallFrameFragment>(I));
       break;
     case MCFragment::FT_LEB:
       RelaxedFrag = relaxLEB(Layout, *cast<MCLEBFragment>(I));
       break;
+    case MCFragment::FT_BoundaryAlign:
+      RelaxedFrag =
+          relaxBoundaryAlign(Layout, *cast<MCBoundaryAlignFragment>(I));
+      break;
     case MCFragment::FT_CVInlineLines:
       RelaxedFrag =
           relaxCVInlineLineTable(Layout, *cast<MCCVInlineLineTableFragment>(I));
       break;
     case MCFragment::FT_CVDefRange:
       RelaxedFrag = relaxCVDefRange(Layout, *cast<MCCVDefRangeFragment>(I));
       break;
     }

llvm/lib/MC/MCFragment.cpp

case FT_Dwarf:
       delete cast<MCDwarfLineAddrFragment>(this);
       return;
     case FT_DwarfFrame:
       delete cast<MCDwarfCallFrameFragment>(this);
       return;
     case FT_LEB:
       delete cast<MCLEBFragment>(this);
       return;
+    case FT_BoundaryAlign:
+      delete cast<MCBoundaryAlignFragment>(this);
+      return;
     case FT_SymbolId:
       delete cast<MCSymbolIdFragment>(this);
       return;
     case FT_CVInlineLines:
       delete cast<MCCVInlineLineTableFragment>(this);
       return;
     case FT_CVDefRange:
       delete cast<MCCVDefRangeFragment>(this);
LLVM_DUMP_METHOD void MCFragment::dump() const {
   case MCFragment::FT_CompactEncodedInst:
     OS << "MCCompactEncodedInstFragment"; break;
   case MCFragment::FT_Fill:  OS << "MCFillFragment"; break;
   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_BoundaryAlign: OS<<"MCBoundaryAlignFragment"; break;
   case MCFragment::FT_SymbolId:    OS << "MCSymbolIdFragment"; break;
   case MCFragment::FT_CVInlineLines: OS << "MCCVInlineLineTableFragment"; break;
   case MCFragment::FT_CVDefRange: OS << "MCCVDefRangeTableFragment"; break;
   case MCFragment::FT_Dummy: OS << "MCDummyFragment"; break;
   }
 
   OS << "<MCFragment " << (const void *)this << " LayoutOrder:" << LayoutOrder
      << " Offset:" << Offset << " HasInstructions:" << hasInstructions();
case MCFragment::FT_DwarfFrame:  {
     break;
   }
   case MCFragment::FT_LEB: {
     const MCLEBFragment *LF = cast<MCLEBFragment>(this);
     OS << "\n       ";
     OS << " Value:" << LF->getValue() << " Signed:" << LF->isSigned();
     break;
   }
+  case MCFragment::FT_BoundaryAlign: {
+    const MCBoundaryAlignFragment *MF =
+        cast<MCBoundaryAlignFragment>(this);
+    OS << "\n       ";
+    OS << " Size:" << MF->getSize();
+    OS << " AlignBoundarySize:" << MF->getBoundarySize();
+    OS << " Fragment:" << MF->getFragment();
+    break;
+  }
   case MCFragment::FT_SymbolId: {
     const MCSymbolIdFragment *F = cast<MCSymbolIdFragment>(this);
     OS << "\n       ";
     OS << " Sym:" << F->getSymbol();
     break;
   }
   case MCFragment::FT_CVInlineLines: {
     const auto *F = cast<MCCVInlineLineTableFragment>(this);

llvm/lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::EmitInstToFragment(const MCInst &Inst,
 
   SmallString<128> Code;
   raw_svector_ostream VecOS(Code);
   getAssembler().getEmitter().encodeInstruction(Inst, VecOS, IF->getFixups(),
                                                 STI);
   IF->getContents().append(Code.begin(), Code.end());
 }
 
+void MCObjectStreamer::EmitBoundaryAlign(unsigned BoundaryPow2) {
+  const unsigned Boundary = 1U << BoundaryPow2;
+  dbgs() << "EmitBoundaryAlign " << BoundaryPow2 << " " << Boundary << "\n";
+
+  if (PendingBA)
+    report_fatal_error("Nested .boundary_align regions not supported");
+
+  auto *F = new MCBoundaryAlignFragment(Boundary);
+  insert(F);
+  assert(!PendingBA);
+  PendingBA = F;
+}
+void MCObjectStreamer::EmitBoundaryAlignEnd() {
+  dbgs() << "EmitBoundaryAlignEnd \n ";
+  if (!PendingBA)
+    report_fatal_error("Missing .boundary_align before .boundary_align_end");
+
+  auto *F = PendingBA;
+  PendingBA = nullptr;
+
+  dbgs() << "Wiring \n";
+  F->dump();
+  dbgs() << "\n";
+  
+  MCFragment *CF = getCurrentFragment();
+  if (!CF)
+    return;
+  CF->dump();
+  dbgs() << "\n";
+  
+  // Link it for later relaxation - this allows the padding for alignment to
+  // actually be computed and emitted.
+  F->setFragment(CF);
+  
+  // Update the maximum alignment on the current section if necessary.
+  MCSection *Sec = getCurrentSectionOnly();
+  unsigned BoundarySize = F->getBoundarySize();
+  if (BoundarySize > Sec->getAlignment())
+    Sec->setAlignment(Align(BoundarySize));
+
+  // Break the last fragment so that more instructions can't be pushed into
+  // it. 
+  insert(new MCDataFragment());
+}
 #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);
 }

llvm/lib/MC/MCParser/AsmParser.cpp

enum DirectiveKind {
     DK_BALIGNW,
     DK_BALIGNL,
     DK_P2ALIGN,
     DK_P2ALIGNW,
     DK_P2ALIGNL,
     DK_ORG,
     DK_FILL,
     DK_ENDR,
+    DK_BOUNDARY_ALIGN,
+    DK_BOUNDARY_ALIGN_END,
     DK_BUNDLE_ALIGN_MODE,
     DK_BUNDLE_LOCK,
     DK_BUNDLE_UNLOCK,
     DK_ZERO,
     DK_EXTERN,
     DK_GLOBL,
     DK_GLOBAL,
     DK_LAZY_REFERENCE,
private:
   // macro directives
   bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);
   bool parseDirectiveExitMacro(StringRef Directive);
   bool parseDirectiveEndMacro(StringRef Directive);
   bool parseDirectiveMacro(SMLoc DirectiveLoc);
   bool parseDirectiveMacrosOnOff(StringRef Directive);
   // alternate macro mode directives
   bool parseDirectiveAltmacro(StringRef Directive);
+  // ".boundary_align", ".boundary_align_end"
+  bool parseDirectiveBoundaryAlign();
+  bool parseDirectiveBoundaryAlignEnd();
   // ".bundle_align_mode"
   bool parseDirectiveBundleAlignMode();
   // ".bundle_lock"
   bool parseDirectiveBundleLock();
   // ".bundle_unlock"
   bool parseDirectiveBundleUnlock();
 
   // ".space", ".skip"
if (IDVal.startswith(".") && IDVal != ".") {
     case DK_REPT:
       return parseDirectiveRept(IDLoc, IDVal);
     case DK_IRP:
       return parseDirectiveIrp(IDLoc);
     case DK_IRPC:
       return parseDirectiveIrpc(IDLoc);
     case DK_ENDR:
       return parseDirectiveEndr(IDLoc);
+    case DK_BOUNDARY_ALIGN:
+      return parseDirectiveBoundaryAlign();
+    case DK_BOUNDARY_ALIGN_END:
+      return parseDirectiveBoundaryAlignEnd();
     case DK_BUNDLE_ALIGN_MODE:
       return parseDirectiveBundleAlignMode();
     case DK_BUNDLE_LOCK:
       return parseDirectiveBundleLock();
     case DK_BUNDLE_UNLOCK:
       return parseDirectiveBundleUnlock();
     case DK_SLEB128:
       return parseDirectiveLEB128(true);
bool AsmParser::parseDirectivePurgeMacro(SMLoc DirectiveLoc) {
 
   getContext().undefineMacro(Name);
   DEBUG_WITH_TYPE("asm-macros", dbgs()
                                     << "Un-defining macro: " << Name << "\n");
   return false;
 }
 
 /// parseDirectiveBundleAlignMode
+/// ::= {.boundary_align} expression
+bool AsmParser::parseDirectiveBoundaryAlign() {
+  // Expect a single argument: an expression that evaluates to a constant
+  // in the inclusive range 0-30.
+  SMLoc ExprLoc = getLexer().getLoc();
+  int64_t AlignSizePow2;
+  if (checkForValidSection() || parseAbsoluteExpression(AlignSizePow2) ||
+      parseToken(AsmToken::EndOfStatement, "unexpected token after expression "
+                                           "in '.boundary_align' "
+                                           "directive") ||
+      check(AlignSizePow2 < 0 || AlignSizePow2 > 30, ExprLoc,
+            "invalid boundary size (expected between 0 and 30)"))
+    return true;
+
+  // Because of AlignSizePow2's verified range we can safely truncate it to
+  // unsigned.
+  getStreamer().EmitBoundaryAlign(static_cast<unsigned>(AlignSizePow2));
+  return false;
+}
+
+/// parseDirectiveBundleAlignMode
+/// ::= {.boundary_align_end}
+bool AsmParser::parseDirectiveBoundaryAlignEnd() {
+  getStreamer().EmitBoundaryAlignEnd();
+  return false;
+}
+
+/// parseDirectiveBundleAlignMode
 /// ::= {.bundle_align_mode} expression
 bool AsmParser::parseDirectiveBundleAlignMode() {
   // Expect a single argument: an expression that evaluates to a constant
   // in the inclusive range 0-30.
   SMLoc ExprLoc = getLexer().getLoc();
   int64_t AlignSizePow2;
   if (checkForValidSection() || parseAbsoluteExpression(AlignSizePow2) ||
       parseToken(AsmToken::EndOfStatement, "unexpected token after expression "
void AsmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".incbin"] = DK_INCBIN;
   DirectiveKindMap[".code16"] = DK_CODE16;
   DirectiveKindMap[".code16gcc"] = DK_CODE16GCC;
   DirectiveKindMap[".rept"] = DK_REPT;
   DirectiveKindMap[".rep"] = DK_REPT;
   DirectiveKindMap[".irp"] = DK_IRP;
   DirectiveKindMap[".irpc"] = DK_IRPC;
   DirectiveKindMap[".endr"] = DK_ENDR;
+  DirectiveKindMap[".boundary_align"] = DK_BOUNDARY_ALIGN;
+  DirectiveKindMap[".boundary_align_end"] = DK_BOUNDARY_ALIGN_END;
   DirectiveKindMap[".bundle_align_mode"] = DK_BUNDLE_ALIGN_MODE;
   DirectiveKindMap[".bundle_lock"] = DK_BUNDLE_LOCK;
   DirectiveKindMap[".bundle_unlock"] = DK_BUNDLE_UNLOCK;
   DirectiveKindMap[".if"] = DK_IF;
   DirectiveKindMap[".ifeq"] = DK_IFEQ;
   DirectiveKindMap[".ifge"] = DK_IFGE;
   DirectiveKindMap[".ifgt"] = DK_IFGT;
   DirectiveKindMap[".ifle"] = DK_IFLE;

llvm/lib/MC/MCStreamer.cpp

void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
                           SMLoc Loc) {}
 void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                       unsigned ValueSize,
                                       unsigned MaxBytesToEmit) {}
 void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
                                    unsigned MaxBytesToEmit) {}
 void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value,
                                    SMLoc Loc) {}
+void MCStreamer::EmitBoundaryAlign(unsigned BoundaryPow2) {}
+void MCStreamer::EmitBoundaryAlignEnd() {}
 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
 void MCStreamer::FinishImpl() {}
 void MCStreamer::EmitBundleUnlock() {}
 
 void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) {
   assert(Section && "Cannot switch to a null section!");
   MCSectionSubPair curSection = SectionStack.back().first;

llvm/test/MC/X86/align-branch-64.s

+  # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s | llvm-objdump -d --no-show-raw-insn - | FileCheck %s
+
+  # instruction sizes for reference:
+  #  callq is 5 bytes long
+  #  push %rax is 1 byte
+  #  jmp <near-label> is 2 bytes
+  #  jmp <far-label> is 5 bytes
+  #  ret N is 2 bytes
+
+  # These tests are checking the edge cases on the alignment computation
+
+  .text
+  # CHECK: test1:
+  # CHECK: 20: callq
+  .globl  test1
+  .p2align  5
+test1:
+  .rept 29
+  push %rax
+  .endr
+  .boundary_align 5
+  callq bar
+  .boundary_align_end
+
+  # CHECK: test2:
+  # CHECK: 60: callq
+  .globl  test2
+  .p2align  5
+test2:
+  .rept 31
+  push %rax
+  .endr
+  .boundary_align 5
+  callq bar
+  .boundary_align_end
+
+  # CHECK: test3:
+  # CHECK: a0: callq
+  .globl  test3
+  .p2align  5
+test3:
+  .rept 27
+  push %rax
+  .endr
+  .boundary_align 5
+  callq bar
+  .boundary_align_end
+
+  # next couple check instruction type coverage
+
+  # CHECK: test_jmp:
+  # CHECK: e0: jmp
+  .globl  test_jmp
+  .p2align  5
+test_jmp:
+  .rept 31
+  push %rax
+  .endr
+  .boundary_align 5
+  jmp bar
+  .boundary_align_end
+
+  # CHECK: test_ret:
+  # CHECK: 120: retq
+  .globl  test_ret
+  .p2align  5
+test_ret:
+  .rept 31
+  push %rax
+  .endr
+  .boundary_align 5
+  retq $0
+  .boundary_align_end
+
+  # check a case with a relaxable instruction
+  
+  # CHECK: test_jmp_far:
+  # CHECK: 160: jmp
+  .globl  test_jmp_far
+  .p2align  5
+test_jmp_far:
+  .rept 31
+  push %rax
+  .endr
+  .boundary_align 5
+  jmp baz
+  .boundary_align_end
+
+  # a local target (1 byte immediate)
+  # This is placed in the middle so that it's local for all tests
+  .type   bar,@function
+bar:
+  retq
+
+  # next batch of tests include multiple instructions within the region which
+  # needs to not cross the boundary.
+
+  # CHECK: test_fused_jcc1:
+  # CHECK: 1a0: test
+  .globl  test_fused_jcc1
+  .p2align  5
+test_fused_jcc1:
+  .rept 31
+  push %rax
+  .endr
+  .boundary_align 5
+  testq %rax, %rax
+  jnz bar
+  .boundary_align_end
+
+  # CHECK: test_fused_jcc2:
+  # CHECK: 1e0: test
+  .globl  test_fused_jcc2
+  .p2align  5
+test_fused_jcc2:
+  .rept 28
+  push %rax
+  .endr
+  .boundary_align 5
+  testq %rax, %rax
+  jnz bar
+  .boundary_align_end
+
+  # CHECK: test_fused_jcc3:
+  # CHECK: 220: test
+  .globl  test_fused_jcc3
+  .p2align  5
+test_fused_jcc3:
+  .rept 23
+  push %rax
+  .endr
+  .boundary_align 5
+  testq %rax, %rax
+  jnz baz
+  .boundary_align_end
+
+  # a far target (4 byte imm)
+  .section "unknown"
+  .type   baz,@function
+baz:
+  retq