Align branches within 32-Byte boundary(NOP padding)

[skan]

Summary

Microcode update for Jump Conditional Code Erratum may cause performance
loss for some workloads:

https://www.intel.com/content/www/us/en/support/articles/000055650.html

Here is the patch to mitigate performance impact by aligning branches
within 32-byte boundary. The impacted instructions are:

a. Conditional jump.
b. Fused conditional jump.
c. Unconditional jump.
d. Indirect jump.
e. Ret.
f. Call.

Add two options for llvm-mc:

1. -x86-align-branch-boundary=NUM aligns branches within NUM byte boundary.
2. -x86-align-branch=TYPE[+TYPE...] specifies types of branches to align.

to align branches within a 32-Byte boundary to reduce the potential performance
loss of the microcode update.

A new MCFragment type, MCBoundaryAlignFragment, is added, which may emit
NOP to align the fused/unfused branch.

alignBranchesBegin inserts MCBoundaryAlignFragment before instructions,
alignBranchesEnd marks the end of the branch to be aligned,
relaxBoundaryAlign grows or shrinks sizes of NOP to align the target branch.

Nop padding is disabled when the instruction may be rewritten by the linker,
such as TLS Call.

[jyknight]

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

404

This set of functions down to isIndirectBranch() seems unnecessary. Pushing one line

const MCInstrDesc &InstDesc = MCII.get(Inst.getOpcode());

into needAlign(const MCInst &Inst), and then just using InstDesc.isReturn() etc. would be fine.

449

please run something like "git clang-format HEAD~1" to re-format your patch.

453

Comment on why this is doing what it's doing?

693–694

Why?

llvm/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

106

"MF" is not a readable abbreviation here -- spell out "MacroFusion" instead. It was OK locally in the "X86MacroFusion.cpp" file, as the filename gave you a hint, but not here, where you have no such hint.

134

This function is also named poorly, after being moved to this more-generic location. "Classify" doesn't tell me anything about this being related to macro-fusion.

[skan]

Not insert nop or prefix if the previous item is hard code, which may be
used to hardcode an instruction, since there is no clear instruction boundary.

[jyknight]

Thanks for the comments, they help a little. But it's still somewhat confusing, so let me write down what seems to be happening:

• Before emitting every instruction, a new MCMachineDependentFragment is now emitted, of one of the multiple types:
  • For most instructions, that'll be BranchPrefix.
  • For things that need branch-alignment, it'll be BranchPadding, unless there's a fused conditional before, in which case it's BranchSplit
  • For fused conditionals, it'll be FusedJccPadding.
• After emitting an instruction that needs branch-alignment, all of those previously-emitted MCMachineDependentFragment are updated to point to the branch's fragment.
• Thus, every MCDataFragment now only contains a single instruction (this property is depended upon for getInstSize, at least).

All the MCMachineDependentFragments in a region bounded by a branch at the end and either a branch or a fragment-type which is not type in {FT_Data, FT_MachineDependent, FT_Relaxable, FT_CompactEncodedInst} at the beginning, will reference the ending branch instruction's fragment.

Then, when it comes time to do relaxation, every one of those machine-dependent-fragments has the opportunity to grow its instruction a little bit. The first instruction in a "block" will grow up to 5 segment prefixes (via modifying the BranchPrefix fragment), and then if more is needed, more prefixes will be added to the next instruction, and so on. Until you run out of instructions in the region. At which point the BranchPadding or FusedJccPadding types (right before the branch/fused-branch) will be able to emit nops to achieve the desired alignment.

An alternative would be to simply emit NOPs before branches as needed. That would be substantially simpler, since it would only require special handling for a branch or a fused-branch. I assume things were done this substantially-more-complex way in order to reduce performance cost of inserting NOP instructions? Are there numbers for how much better it is to use segment prefixes, vs a separate nop instruction? It seems a little bit surprising to me that it would be that important, but I don't know...

I'll note that the method here has the semantic issue of making it effectively impossible to ever evaluate an expression like ".if . - symbol == 24" (assuming we're emitting instructions), since every instruction can now change size. I suspect that will make it impossible to turn this on by default without breaking a lot of assembly code. Previously, only certain instructions, like branches or arithmetic ops with constant arguments of unknown value, could change size.

llvm/lib/MC/MCAssembler.cpp

1058

I don't think this is necessary. AFAICT, the symbols should already be in the right place -- pointing to the relax fragment, not the instruction itself, without this. And removing all this moveSymbol/updateSymbolMap code doesn't make any tests fail.

[craig.topper]

In D70157#1755927, @jyknight wrote:

Thanks for the comments, they help a little. But it's still somewhat confusing, so let me write down what seems to be happening:

• Before emitting every instruction, a new MCMachineDependentFragment is now emitted, of one of the multiple types:
  • For most instructions, that'll be BranchPrefix.
  • For things that need branch-alignment, it'll be BranchPadding, unless there's a fused conditional before, in which case it's BranchSplit
  • For fused conditionals, it'll be FusedJccPadding.
• After emitting an instruction that needs branch-alignment, all of those previously-emitted MCMachineDependentFragment are updated to point to the branch's fragment.
• Thus, every MCDataFragment now only contains a single instruction (this property is depended upon for getInstSize, at least).

All the MCMachineDependentFragments in a region bounded by a branch at the end and either a branch or a fragment-type which is not type in {FT_Data, FT_MachineDependent, FT_Relaxable, FT_CompactEncodedInst} at the beginning, will reference the ending branch instruction's fragment.

Then, when it comes time to do relaxation, every one of those machine-dependent-fragments has the opportunity to grow its instruction a little bit. The first instruction in a "block" will grow up to 5 segment prefixes (via modifying the BranchPrefix fragment), and then if more is needed, more prefixes will be added to the next instruction, and so on. Until you run out of instructions in the region. At which point the BranchPadding or FusedJccPadding types (right before the branch/fused-branch) will be able to emit nops to achieve the desired alignment.

An alternative would be to simply emit NOPs before branches as needed. That would be substantially simpler, since it would only require special handling for a branch or a fused-branch. I assume things were done this substantially-more-complex way in order to reduce performance cost of inserting NOP instructions? Are there numbers for how much better it is to use segment prefixes, vs a separate nop instruction? It seems a little bit surprising to me that it would be that important, but I don't know...

I don't have any numbers myself. I was only involved in some of the code review internally. My understanding is that NOP instructions would place extra nop uops into the DSB(the decoded uop buffer) and that limits the performance that can be recovered. By using redundant prefixes no extra uops are generated and more performance is recovered.

I'll note that the method here has the semantic issue of making it effectively impossible to ever evaluate an expression like ".if . - symbol == 24" (assuming we're emitting instructions), since every instruction can now change size. I suspect that will make it impossible to turn this on by default without breaking a lot of assembly code. Previously, only certain instructions, like branches or arithmetic ops with constant arguments of unknown value, could change size.

[efriedma]

llvm/include/llvm/MC/MCFragment.h

684

Global variables are forbidden in LLVM libraries; there could be multiple LLVMContexts in the same process.

[skan]

In D70157#1755927, @jyknight wrote:

Thanks for the comments, they help a little. But it's still somewhat confusing, so let me write down what seems to be happening:

• Before emitting every instruction, a new MCMachineDependentFragment is now emitted, of one of the multiple types:
  • For most instructions, that'll be BranchPrefix.
  • For things that need branch-alignment, it'll be BranchPadding, unless there's a fused conditional before, in which case it's BranchSplit
  • For fused conditionals, it'll be FusedJccPadding.
• After emitting an instruction that needs branch-alignment, all of those previously-emitted MCMachineDependentFragment are updated to point to the branch's fragment.
• Thus, every MCDataFragment now only contains a single instruction (this property is depended upon for getInstSize, at least).

All the MCMachineDependentFragments in a region bounded by a branch at the end and either a branch or a fragment-type which is not type in {FT_Data, FT_MachineDependent, FT_Relaxable, FT_CompactEncodedInst} at the beginning, will reference the ending branch instruction's fragment.

Then, when it comes time to do relaxation, every one of those machine-dependent-fragments has the opportunity to grow its instruction a little bit. The first instruction in a "block" will grow up to 5 segment prefixes (via modifying the BranchPrefix fragment), and then if more is needed, more prefixes will be added to the next instruction, and so on. Until you run out of instructions in the region. At which point the BranchPadding or FusedJccPadding types (right before the branch/fused-branch) will be able to emit nops to achieve the desired alignment.

An alternative would be to simply emit NOPs before branches as needed. That would be substantially simpler, since it would only require special handling for a branch or a fused-branch. I assume things were done this substantially-more-complex way in order to reduce performance cost of inserting NOP instructions? Are there numbers for how much better it is to use segment prefixes, vs a separate nop instruction? It seems a little bit surprising to me that it would be that important, but I don't know...

I'll note that the method here has the semantic issue of making it effectively impossible to ever evaluate an expression like ".if . - symbol == 24" (assuming we're emitting instructions), since every instruction can now change size. I suspect that will make it impossible to turn this on by default without breaking a lot of assembly code. Previously, only certain instructions, like branches or arithmetic ops with constant arguments of unknown value, could change size.

Thanks for your detailed and accurate analysis for my code! I am sorry that this should have been done by me.

llvm/lib/MC/MCAssembler.cpp

1058

Yes, I check it and you are right. I will removing all this moveSymbol/updateSymbolMap code.

[skan]

Three changes are made:

1. Remove moveSymbol/updateSymbolMap code since it is not necessary
2. Make variable AlignBoundarySize and variable AlignMaxPrefixSize not global
3. Disable nop padding before instruction with variant symbol operand since it may be rewritten by linker.

[skan]

Speed up if we only want to simply emit NOPs before branches as needed.

[skan]

In D70157#1755927, @jyknight wrote:

An alternative would be to simply emit NOPs before branches as needed. That would be substantially simpler, since it would only require special handling for a branch or a fused-branch. I assume things were done this substantially-more-complex way in order to reduce performance cost of inserting NOP instructions? Are there numbers for how much better it is to use segment prefixes, vs a separate nop instruction? It seems a little bit surprising to me that it would be that important, but I don't know...

I'll note that the method here has the semantic issue of making it effectively impossible to ever evaluate an expression like ".if . - symbol == 24" (assuming we're emitting instructions), since every instruction can now change size. I suspect that will make it impossible to turn this on by default without breaking a lot of assembly code. Previously, only certain instructions, like branches or arithmetic ops with constant arguments of unknown value, could change size.

Thanks for your remind! Now, if -malign-branch-prefix-size=0 is used, the method will only insert BranchPadding or FusedJccPadding before branches as needed, and insert BranchPrefix before the instruction which is macro fusible but not macro fused. In this condition, the operation is as simple as inserting nop only. Since more performance can be recovered by inserting prefixes than inserting nops, I believe I should support prefix padding.

[chandlerc]

(Just a reminder that we need to have both performance and code size numbers for this patch. And given that there are a few options, may need a few examples.)

[jyknight]

I have some other concerns about the code itself, but after pondering this a little bit, I'd like to instead bring up some rather more general concerns about the overall approach used here -- with some suggestions. (As these comments are not really comments on the _code_, but on the overall strategy, they also apply to the gnu binutils patch for this same feature.)

Of course, echoing chandler, it would be nice to see some performance numbers, otherwise it's not clear how useful any of this is.

Segment-prefix padding

The ability to pad instructions instead of adding a multibyte-NOP in order to create alignment seems like a generally-useful feature, which should be usable in other situations where we align within a function -- assuming that there is indeed a measurable performance benefit vs NOP instructions. E.g. we should do this for basic-block alignment, as well! As such, it feels like this feature ought to be split out, and implemented separately from the new branch-alignment functionality -- in a way which is usable for any kind of alignment request.

The way I'd imagine it working is to introduce a new pair of asm directives, to enable and disable segment-prefix padding in a certain range of instructions (let's say ".enable_instr_prefix_pad", ".disable_instr_prefix_pad". Within such an enabled range, the assembler would prefix instructions as required in order to handle later nominally-nop-emitting code alignment directives (such as the usual '.p2align 4, 0x90') .

Branch alignment

The primary goal of this patch, restricting the placement of branch instructions, is a performance optimization. Similar to loop alignment, the desire is to increase speed, at the cost of code-size. However, the way this feature has been designed is a global assembler flag. I find that not ideal, because it cannot take into account hotness of a block/function, as for example loop alignment code does. Basic-block alignment of loops is explicitly opt-in on an block-by-block basis -- the compiler simply emits a p2align directive where it needs, and the assembler honors that. And so, MachineBlockPlacement::alignBlocks has a bunch of conditions under which it will avoid emitting a p2align. This seems like a good model -- the assembler does what it's told by the compiler (or assembly-writer). Making the branch-instruction-alignment work similarly seems like it would be good.

IMO it would be nicest if there could be a directive that requests to specially-align the next instruction. However, the fused-jcc case makes that quite tricky, so perhaps this ought to also be a mode which can be enabled/disabled on a region as well.

Enabling by default

Previously, I'd mentioned that it seemed likely we couldn't actually enable branch-alignment by default because it'll probably break people's inline-asm and standalone asm files. That would be solved by making everything controllable within the asm file. The compiler could then insert the directives for its own code, and disable it around inline assembly. And standalone asm files could remain unaffected, unless they opt in. With that, we could actually enable the alignment by default, for compiled output in certain cpu-tuning modes, if it's warranted.

[reames]

I want to chime in support of jyknight's meta comments - particularly the one about the need to balance execution speed vs code size differently in hot vs cold code. For our use case, we have a very large amount of branch dense known cold paths, and being able to only align fast path branches would be a substantial space savings.

I also see value in having the prefix padding feature factored out generically. If that mechanism is truly measurably faster than multi-byte nops - which if I reading comments correctly, has been claimed but not documented or measured? - using it generically for other alignment purposes would likely be worthwhile.

I'd also like to see - probably in a separate patch - support for auto-detecting whether the host CPU needs this mitigation. Both -mcpu=native and various JITs will end up needing this, having the code centralized in one place would be good.

[fedor.sergeev]

Just FYI for now as I'm trying to dig futher...
I have been trying this fix in our downstream environment and managed to get a hang with this backtrace:

#0 needPadding (BoundarySize=<optimized out>, Size=<optimized out>, StartAddr=<optimized out>) at ./llvm/lib/MC/MCAssembler.cpp:1028
#1 llvm::MCAssembler::relaxMachineDependent (this=<optimized out>, Layout=..., MF=...) at ./llvm/lib/MC/MCAssembler.cpp:1077
#2 0x00007ffff1adc8b6 in llvm::MCAssembler::layoutSectionOnce (this=this@entry=0x7fff90580580, Layout=..., Sec=...) at ./orca/llvm/lib/MC/MCAssembler.cpp:1213
...

Working on getting upstream reproducer....

[fedor.sergeev]

In D70157#1767212, @fedor.sergeev wrote:

Working on getting upstream reproducer....

Hangs on a moderately small piece (~150 lines) of x86 assembly, filed a bug on it here:

https://bugs.llvm.org/show_bug.cgi?id=44215

[skan]

fix the bug

https://bugs.llvm.org/show_bug.cgi?id=44215

[chandlerc]

I'm seeing lots of updates to fix bugs, but no movement for many days on both my meta comments and (in some ways more importantly) James's meta comments. (And thanks Philip for chiming in too!)

Meanwhile, we really, really need to get this functionality in place. The entire story for minimizing the new microcode performance hit hinges on these patches, and I'm really worried by how little progress we're seeing here.

[craig.topper]

llvm/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

158

None of the AND/ADD/SUB instructions ending in mr are eligible for macrofusion as far as I know. Those all involve a load and a store which is not supported by macrofusion.

We also lost all the ADD*_DB instructions from the macrofusion list. I believe they are in the existing list incorrectly. So removing them is correct, but as far as I can see that change was not mentioned in the description of this patch.

Can we split the macrofusion refactoring out of this patch so we can review it separately and hopefully get it committed sooner than the other review feedback.

[annita.zhang]

In D70157#1768319, @chandlerc wrote:

I'm seeing lots of updates to fix bugs, but no movement for many days on both my meta comments and (in some ways more importantly) James's meta comments. (And thanks Philip for chiming in too!)

Meanwhile, we really, really need to get this functionality in place. The entire story for minimizing the new microcode performance hit hinges on these patches, and I'm really worried by how little progress we're seeing here.

Sorry for belated response. We're working hard to go through some paper work to get the performance data ready. I think maybe it's better to open a mailing thread in llvm-dev to post those performance data and discuss those suggestions.

The first data was posted in http://lists.llvm.org/pipermail/llvm-dev/2019-December/137413.html.

Thanks,
Annita

[skan]

Fix the macro fusion table. If the first source/destination operand of an instruction is memory, it is unfusible.

[skan]

llvm/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

158

Okay, I will upload another patch to correct the macrofusion table as soon as possible.

[craig.topper]

Can you please put the macro fusion changes in a separate phabricator review. I’ll review it in the morning US time and if it all looks good we can get that part committed while the other comments are being addressed.

[skan]

In D70157#1768389, @craig.topper wrote:

Can you please put the macro fusion changes in a separate phabricator review. I’ll review it in the morning US time and if it all looks good we can get that part committed while the other comments are being addressed.

Sure.

[skan]

We shouldn't try to insert prefix/nop t in a virtual section.

[skan]

Since hardcode only exists in text section, we should not insert HardCodeBegin/HardCodeEnd in other section, such as a virtual section.

[MaskRay]

I am still trying to understand the patch. Just made some comments about the tests.

llvm/include/llvm/MC/MCFragment.h

663

Don’t duplicate function or class name at the beginning of the comment (BranchPadding - ). (ref: https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments)

674

Full stop.

709

Move llvm_unreachable below the switch, otherwise clang will give a warning:

warning: default label in switch which covers all enumera

tion values [-Wcovered-switch-default]

Unfortunately all GCC (even 9) -Wall will warn warning: control reaches end of non-void function [-Wreturn-type] unless you place an unreachable statement.

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

522

Space after if

llvm/test/MC/X86/x86-64-align-branch-1a.s

2

1a~1g use the same source file. Move the source to Inputs/align-branch-1-64.s

According to the local naming convention, this test should probably be renamed to align-branch-1-64.s

8

Delete

12

Delete Disassembly of section .text:. Ditto below.

llvm/test/MC/X86/x86-64-align-branch-1b.s

5

Delete

11

I think 1a.s and 1b.s should be merged. FileCheck supports

--check-prefixes=CHECK,PREFIX5
--check-prefixes=CHECK,PREFIX1

CHECK: common part
CHECK-NEXT: common part
PREFIX5:
PREFIX5-NEXT:
PREFIX1:
PREFIX1-NEXT:
CHECK:
CHECK-NEXT:

% diff -U1 x86-64-align-branch-1[ab].s
 # CHECK: 0000000000000000 foo:
-# CHECK-NEXT:        0: 64 64 64 64 89 04 25 01 00 00 00 movl    %eax, %fs:1
-# CHECK-NEXT:        b: 55                               pushq   %rbp
-# CHECK-NEXT:        c: 55                               pushq   %rbp
-# CHECK-NEXT:        d: 55                               pushq   %rbp
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 2e 55                            pushq   %rbp
+# CHECK-NEXT:        a: 2e 55                            pushq   %rbp
+# CHECK-NEXT:        c: 2e 55                            pushq   %rbp
 # CHECK-NEXT:        e: 48 89 e5                         movq    %rsp, %rbp

Is there performance benefit to add 4 prefixes to the same instruction?

llvm/test/MC/X86/x86-64-align-branch-1c.s

3

The difference between 1a and 1c is that 1c does not allow "jmp", but in 1a no jmp instructions get a prefix in the test, so it is unclear why 1c has different output.

llvm/test/MC/X86/x86-64-align-branch-1d.s

5

Delete

llvm/test/MC/X86/x86-64-align-branch-1e.s

47

This is weird. Comparing this with 1d, 1e allows more instruction types, yet it inserts two NOPs which actually seems to degrade performance.

llvm/test/MC/X86/x86-64-align-branch-1f.s

9

No disassembly is needed. Just check that --x86-align-branch-boundary=0 and the default (no x86- specific options) have the identical output (cmp %t %t2)

llvm/test/MC/X86/x86-64-align-branch-1g.s

2

Merge 1e and 1g. State that -mcpu=x86-64 generates 66 90 instead of 90 90 (but why?)

4

Delete

8

Delete Disassembly of section .text:

[MaskRay]

I find another deficiency (infinite loop) with the current approach.

Say, there is a je 0 (0x0F 0x84 0x00 0x00 0x00 0x00) at byte 0x90. (0x90+6)%32 == 0, so it ends on a 32-byte boundary.
MF.getMaxPrefixSize() is 4, so the size of MCMachineDependentFragment may vary from 0 to 4.
If there are other MCMachineDependentFragment's in the section, some may shrink while some may expand.
In some cases the following loop will not converge

bool MCAssembler::layoutOnce(MCAsmLayout &Layout) {
  ++stats::RelaxationSteps;

  bool WasRelaxed = false;
  for (iterator it = begin(), ie = end(); it != ie; ++it) {
    MCSection &Sec = *it;
    while (layoutSectionOnce(Layout, Sec)) ///
      WasRelaxed = true;
  }

  return WasRelaxed;
}

// In MCAssembler::layoutSectionOnce,
  case MCFragment::FT_MachineDependent:
    RelaxedFrag =
        relaxMachineDependent(Layout, *cast<MCMachineDependentFragment>(I));
    break;

To give a concrete example, clang++ -fsanitize=memory compiler-rt/test/msan/cxa_atexit.cpp -mbranches-within-32B-boundaries does not converge. You may also try dtor-*.cpp in that directory.

A simple iterative algorithm is not guaranteed to converge. We probably can solve the layout problem with a dynamic programming algorithm:

f[i][j] = the minimum cost that layouts the first i instructions with j extra bytes (via NOPs or prefixes)
or
g[i][j] = the minimum inserted bytes that layouts the first i instructions with cost j

I am not clear which one is better. A simple greedy approach is to set an upper limit on the number of iterations when the section contains at least one MCMachineDependentFragment, i.e.

bool HasMCMachineDependentFragment = false;
int count = 5; // arbitrary. Please find an appropriate value.
while (layoutSectionOnce(Layout, Sec, HasMCMachineDependentFragment) && count > 0) {
  WasRelaxed = true;
  if (HasMCMachineDependentFragment)
    count--;
}

[MaskRay]

llvm/lib/MC/MCAssembler.cpp

1014

Division is slow. Pass in the power of 2 and use right shift instead.

You may change MCMachineDependentFragment::AlignBoundarySize (a power of 2) to a power.

1022

Ditto.

[skan]

In D70157#1769932, @MaskRay wrote:

I find another deficiency (infinite loop) with the current approach.

Say, there is a je 0 (0x0F 0x84 0x00 0x00 0x00 0x00) at byte 0x90. (0x90+6)%32 == 0, so it ends on a 32-byte boundary.
MF.getMaxPrefixSize() is 4, so the size of MCMachineDependentFragment may vary from 0 to 4.
If there are other MCMachineDependentFragment's in the section, some may shrink while some may expand.
In some cases the following loop will not converge

bool MCAssembler::layoutOnce(MCAsmLayout &Layout) {
  ++stats::RelaxationSteps;

  bool WasRelaxed = false;
  for (iterator it = begin(), ie = end(); it != ie; ++it) {
    MCSection &Sec = *it;
    while (layoutSectionOnce(Layout, Sec)) ///
      WasRelaxed = true;
  }

  return WasRelaxed;
}

// In MCAssembler::layoutSectionOnce,
  case MCFragment::FT_MachineDependent:
    RelaxedFrag =
        relaxMachineDependent(Layout, *cast<MCMachineDependentFragment>(I));
    break;

To give a concrete example, clang++ -fsanitize=memory compiler-rt/test/msan/cxa_atexit.cpp -mbranches-within-32B-boundaries does not converge. You may also try dtor-*.cpp in that directory.

A simple iterative algorithm is not guaranteed to converge. We probably can solve the layout problem with a dynamic programming algorithm:

f[i][j] = the minimum cost that layouts the first i instructions with j extra bytes (via NOPs or prefixes)
or
g[i][j] = the minimum inserted bytes that layouts the first i instructions with cost j

I am not clear which one is better. A simple greedy approach is to set an upper limit on the number of iterations when the section contains at least one MCMachineDependentFragment, i.e.

bool HasMCMachineDependentFragment = false;
int count = 5; // arbitrary. Please find an appropriate value.
while (layoutSectionOnce(Layout, Sec, HasMCMachineDependentFragment) && count > 0) {
  WasRelaxed = true;
  if (HasMCMachineDependentFragment)
    count--;
}

I guess you originally wanted to say (90 + 6)%32 == 0 instead of (0x90 +6)%32 == 0. With the last patch, the command

clang++ -fsanitize=memory compiler-rt/test/msan/cxa_atexit.cpp -mbranches-within-32B-boundaries does not converge, but this is not the fault of this simple iterative algorithm.

Let me briefly introduce this algorithm. Regardless of whether the prefix or nop is filled in, MCMachineDependentFragment is used to occupy a certain size of space to align the branch, and it has a pointer to the branch it is responsible for. Multiple MCMachineDependentFragments can work together to align a branch. For example, there are two MCMachineDependentFragment, M1 and M2 to align branch J1. In the first iteration, J1 needs 7 bytes of padding, so the size of M1 will grow to 7 as much as possible. However, M1 can only grow to 5 or smaller from some reason. At this time, M2 will grow as much as possible to 2. In the second iteration, when it's M1's turn to relax, we will subtract the size of M1 and M2 from the current address of J1 to get the size that J1 needs to padding, assuming it is 6, and then M1 will keep the size to 5 and the size of M2 will be reduced to 1. It is not difficult to see that among the MCFragment from M1 to J1, as long as the size of MCFragment other than M1 and M2 is fixed within a limited number of iterations, the sizes of M1 and M2 will be fixed within a limited number of iterations, that is, the iteration will converge.

As far as I know, the MCFragment used to store instructions includes MCDataFragment, MCRelaxableFragment and MCCompactEncodedFragment. MCDataFragment and MCCompactEncodedFragment have fixed sizes. MCRelaxableFragment is used to store instructions of variable size and will only grow and not shrink, as a result, its size will be fixed within a limited number of cycles . So as long as we ensure that there is only MCFragment that stores instructions between the instruction to be prefixed and the branch to be aligned, this iterative algorithm will converge.

The file cxa_atexit.s has more than one text section. The instruction to be prefixed and the branch to align may be in two different text sections. I forgot to check if there is a MCFragment not storing instruction between the them, which results in non-convergence. This bug has been fixed in the latest patch.

[skan]

llvm/test/MC/X86/x86-64-align-branch-1b.s

11

Thanks for the knowledge! There is no performance benefit to add 4 prefixes to the same instruction. The instruction movl %eax, %fs:1 has already has a prefix %fs (0x64), if option -x86-align-branch-prefix-size=5 is used, we could add 4 more prefixes at most. The branch to be aligned needs 3-byte padding, so 3 prefixes are added to the move instruction.

llvm/test/MC/X86/x86-64-align-branch-1c.s

3

# CHECK-NEXT:       45: 2e 89 45 fc                      movl    %eax, %cs:-4(%rbp)
# CHECK-NEXT:       49: 89 75 f4                         movl    %esi, -12(%rbp)
# CHECK-NEXT:       4c: 89 7d f8                         movl    %edi, -8(%rbp)
# CHECK-NEXT:       4f: 89 75 f4                         movl    %esi, -12(%rbp)
# CHECK-NEXT:       52: 89 75 f4                         movl    %esi, -12(%rbp)
# CHECK-NEXT:       55: 89 75 f4                         movl    %esi, -12(%rbp)
# CHECK-NEXT:       58: 89 75 f4                         movl    %esi, -12(%rbp)
# CHECK-NEXT:       5b: 89 75 f4                         movl    %esi, -12(%rbp)
# CHECK-NEXT:       5e: 5d                               popq    %rbp
# CHECK-NEXT:       5f: 5d                               popq    %rbp
# CHECK-NEXT:       60: eb 26                            jmp     {{.*}}

The prefix 2e is added at

45: 2e 89 45 fc                      movl    %eax, %cs:-4(%rbp)

llvm/test/MC/X86/x86-64-align-branch-1e.s

47

Not all the target cpu support long nop, you can find related code in X86AsmBackend::writeNopData.

[fedor.sergeev]

In D70157#1768310, @skan wrote:

fix the bug

https://bugs.llvm.org/show_bug.cgi?id=44215

FYI: I did close the bug as fixed after verifying that the fix works for me.

[reames]

We uncovered another functional issue with this patch, or at least, the interaction of this patch and other parts of LLVM. In our support for STATEPOINT, PATCHPOINT, and STACKMAP we use N-byte nop sequences for regions of code which might be patched out. It's important that these regions are exactly N bytes as concurrent patching which doesn't replace an integral number of instructions is ill-defined on X86-64. This patch causes the N-byte nop sequence to sometimes become (N+M) bytes which breaks the patching. I believe that the XRAY support may have a similar issue.

More generally, I'm worried about the legality of arbitrarily prefixing instructions from unknown sources. In the particular example we saw, we had something along the following:

.Ltmp0:
.p2align 3, 0x90
(16 byte nop sequence)
.Ltmp3:
jmp *%rax

In addition to the patching legality issue above, padding the nop sequence does something else interesting in this example. It changes the alignment of Ltmp3. Before, Ltmp3 was always 8 byte aligned, after prefixes are added, it's not. It's not clear to me exactly what the required semantics here are, but we at least had been assuming the alignment of Ltmp3 was guaranteed in this case. (That's actually how we found the patching issue.)

[reames]

I've been digging through the code for this for the last day or so. This is a new area for me, so it's possible I'm off base, but I have some concerns about the current design.

First, there appears to already be support for instruction bundling and alignment in the assembler today. I stumbled across the .bundle_align_mode, .bundle_start, and .bundle_end mechanism (https://lists.llvm.org/pipermail/llvm-dev/2012-December/056723.html) which seems to *heavily* overlap with this proposal. I suspect that the compiler support suggested by James and myself earlier in this thread could be implemented on to this existing mechanism.

Second, the new callbacks and infrastructure added appear to overlap heavily w/the MCCodePadding infrastructure. (Which, admitted, appears unused and untested.)

Third, I have not see a justification for why complexity for instruction prefix padding is necessary. All the effected CPUs support multi-byte nops, so we're talking about a *single micro op* difference between the nop form and prefix form. Can anyone point to a performance delta due to this? If not, I'd suggest we should start with the nop form, and then build the prefix form in a generic manner for all alignment varieties.

[jyknight]

In D70157#1771832, @reames wrote:

I've been digging through the code for this for the last day or so. This is a new area for me, so it's possible I'm off base, but I have some concerns about the current design.

First, there appears to already be support for instruction bundling and alignment in the assembler today. I stumbled across the .bundle_align_mode, .bundle_start, and .bundle_end mechanism (https://lists.llvm.org/pipermail/llvm-dev/2012-December/056723.html) which seems to *heavily* overlap with this proposal. I suspect that the compiler support suggested by James and myself earlier in this thread could be implemented on to this existing mechanism.

Second, the new callbacks and infrastructure added appear to overlap heavily w/the MCCodePadding infrastructure. (Which, admitted, appears unused and untested.)

My conclusion after looking at all of that was actually that I plan to propose removing both the MCCodePadding and all the bundle-padding infrastructure, not add new stuff on top of it -- the former is unused, and I believe the latter is only for Chrome's NaCL, which is deprecated, and fairly close to being removed. If we need something similar in the future, we should certainly look to both of those for inspiration, but I don't think we need to be constrained by them.

Third, I have not see a justification for why complexity for instruction prefix padding is necessary. All the effected CPUs support multi-byte nops, so we're talking about a *single micro op* difference between the nop form and prefix form. Can anyone point to a performance delta due to this? If not, I'd suggest we should start with the nop form, and then build the prefix form in a generic manner for all alignment varieties.

+1.

[MaskRay]

In D70157#1771841, @jyknight wrote:

In D70157#1771832, @reames wrote:

I've been digging through the code for this for the last day or so. This is a new area for me, so it's possible I'm off base, but I have some concerns about the current design.

First, there appears to already be support for instruction bundling and alignment in the assembler today. I stumbled across the .bundle_align_mode, .bundle_start, and .bundle_end mechanism (https://lists.llvm.org/pipermail/llvm-dev/2012-December/056723.html) which seems to *heavily* overlap with this proposal. I suspect that the compiler support suggested by James and myself earlier in this thread could be implemented on to this existing mechanism.

Second, the new callbacks and infrastructure added appear to overlap heavily w/the MCCodePadding infrastructure. (Which, admitted, appears unused and untested.)

My conclusion after looking at all of that was actually that I plan to propose removing both the MCCodePadding and all the bundle-padding infrastructure, not add new stuff on top of it -- the former is unused, and I believe the latter is only for Chrome's NaCL, which is deprecated, and fairly close to being removed. If we need something similar in the future, we should certainly look to both of those for inspiration, but I don't think we need to be constrained by them.

CC the author of D34393 - @opaparo for MCCodePadding. Intel folks may know how to contact @opaparo?

I also noticed that MCCodePadder.cpp is never updated (except a license change) after the initial check-in.

Third, I have not see a justification for why complexity for instruction prefix padding is necessary. All the effected CPUs support multi-byte nops, so we're talking about a *single micro op* difference between the nop form and prefix form. Can anyone point to a performance delta due to this? If not, I'd suggest we should start with the nop form, and then build the prefix form in a generic manner for all alignment varieties.

+1.

+1. Starting from just NOP padding sounds a simple and good first step. We can explore segment override prefixes in the future.

[reames]

In D70157#1771841, @jyknight wrote:

In D70157#1771832, @reames wrote:

I've been digging through the code for this for the last day or so. This is a new area for me, so it's possible I'm off base, but I have some concerns about the current design.

First, there appears to already be support for instruction bundling and alignment in the assembler today. I stumbled across the .bundle_align_mode, .bundle_start, and .bundle_end mechanism (https://lists.llvm.org/pipermail/llvm-dev/2012-December/056723.html) which seems to *heavily* overlap with this proposal. I suspect that the compiler support suggested by James and myself earlier in this thread could be implemented on to this existing mechanism.

Second, the new callbacks and infrastructure added appear to overlap heavily w/the MCCodePadding infrastructure. (Which, admitted, appears unused and untested.)

My conclusion after looking at all of that was actually that I plan to propose removing both the MCCodePadding and all the bundle-padding infrastructure, not add new stuff on top of it -- the former is unused, and I believe the latter is only for Chrome's NaCL, which is deprecated, and fairly close to being removed. If we need something similar in the future, we should certainly look to both of those for inspiration, but I don't think we need to be constrained by them.

I can definitely see removing the code padding stuff, since it's unused and untested.

As for the bundle mechanisms, why? It seems like exactly what we're going to want here. Regardless of the auto-detect feature, we're going to need a representation of a bundle which needs to be properly placed to avoid splitting, and the current code does that. Why not reuse the, presumable reasonable well tested, existing infrastructure? The only extra thing we seem to need is the ability to toggle off bundle formation for instruction types we don't care about. Since we're going to need an assembler spelling of that regardless, it seems like the current code is a decent baseline?

[MaskRay]

In D70157#1772019, @reames wrote:

In D70157#1771841, @jyknight wrote:

In D70157#1771832, @reames wrote:

I've been digging through the code for this for the last day or so. This is a new area for me, so it's possible I'm off base, but I have some concerns about the current design.

First, there appears to already be support for instruction bundling and alignment in the assembler today. I stumbled across the .bundle_align_mode, .bundle_start, and .bundle_end mechanism (https://lists.llvm.org/pipermail/llvm-dev/2012-December/056723.html) which seems to *heavily* overlap with this proposal. I suspect that the compiler support suggested by James and myself earlier in this thread could be implemented on to this existing mechanism.

Second, the new callbacks and infrastructure added appear to overlap heavily w/the MCCodePadding infrastructure. (Which, admitted, appears unused and untested.)

My conclusion after looking at all of that was actually that I plan to propose removing both the MCCodePadding and all the bundle-padding infrastructure, not add new stuff on top of it -- the former is unused, and I believe the latter is only for Chrome's NaCL, which is deprecated, and fairly close to being removed. If we need something similar in the future, we should certainly look to both of those for inspiration, but I don't think we need to be constrained by them.

I can definitely see removing the code padding stuff, since it's unused and untested.

As for the bundle mechanisms, why? It seems like exactly what we're going to want here. Regardless of the auto-detect feature, we're going to need a representation of a bundle which needs to be properly placed to avoid splitting, and the current code does that. Why not reuse the, presumable reasonable well tested, existing infrastructure? The only extra thing we seem to need is the ability to toggle off bundle formation for instruction types we don't care about. Since we're going to need an assembler spelling of that regardless, it seems like the current code is a decent baseline?

I created D71106 to delete MCCodePadder and accompanying classes.

[annita.zhang]

Third, I have not see a justification for why complexity for instruction prefix padding is necessary. All the effected CPUs support multi-byte nops, so we're talking about a *single micro op* difference between the nop form and prefix form. Can anyone point to a performance delta due to this? If not, I'd suggest we should start with the nop form, and then build the prefix form in a generic manner for all alignment varieties.

+1.

+1. Starting from just NOP padding sounds a simple and good first step. We can explore segment override prefixes in the future.

I think it's a good suggestion to start with NOP padding as the first step. In our previous experiment, we saw that the prefix padding was slight better than NOP padding, but not much. We will retest the NOP padding and go back to you.

[davezarzycki]

In D70157#1772227, @annita.zhang wrote:

Third, I have not see a justification for why complexity for instruction prefix padding is necessary. All the effected CPUs support multi-byte nops, so we're talking about a *single micro op* difference between the nop form and prefix form. Can anyone point to a performance delta due to this? If not, I'd suggest we should start with the nop form, and then build the prefix form in a generic manner for all alignment varieties.

+1.

+1. Starting from just NOP padding sounds a simple and good first step. We can explore segment override prefixes in the future.

I think it's a good suggestion to start with NOP padding as the first step. In our previous experiment, we saw that the prefix padding was slight better than NOP padding, but not much. We will retest the NOP padding and go back to you.

For whatever it may be worth: Agnor Fog's empirical research on x86 pipelines and his review of manufacturer optimization guidelines also concludes that prefixes are often preferable to NOPs on modern x86 processors. (See: https://www.agner.org/optimize/microarchitecture.pdf) This arguably isn't surprising given that the decoder needs to be good at finding instruction boundaries but the decoder isn't responsible for interpreting instructions, therefore NOPs of any size dilute decode bandwidth.

[reames]

Recording something so I don't forget it when we get back to the prefix padding version. The write up on the bundle align mode stuff mentions a concerning memory overhead for the feature. Since the basic implementation techniques are similar, we need to make sure we assess the memory overhead of the prefix padding implementation. See https://www.chromium.org/nativeclient/pnacl/aligned-bundling-support-in-llvm for context. I don't believe this is likely to be an issue for the nop padding variant.

[LuoYuanke]

In D70157#1773180, @reames wrote:

Recording something so I don't forget it when we get back to the prefix padding version. The write up on the bundle align mode stuff mentions a concerning memory overhead for the feature. Since the basic implementation techniques are similar, we need to make sure we assess the memory overhead of the prefix padding implementation. See https://www.chromium.org/nativeclient/pnacl/aligned-bundling-support-in-llvm for context. I don't believe this is likely to be an issue for the nop padding variant.

From the doc of https://www.chromium.org/nativeclient/pnacl/aligned-bundling-support-in-llvm the ".bundle_align_mode" ensure each instruction that following the directive don't cross the alignment boundary and ensure the first instruction following the directive be aligned, but in this patch we only require branch (jcc, jmp, ...) instruction don't cross the alignment boundary. Another remind, this patch avoid branch instruction hit the alignment boundary, and bundle syntax doesn't support that (see section 2.1 of https://www.intel.com/content/dam/support/us/en/documents/processors/mitigations-jump-conditional-code-erratum.pdf). So I don't think bundle syntax fit current requirement perfectly.

[annita.zhang]

In D70157#1760278, @jyknight wrote:

Branch alignment

The primary goal of this patch, restricting the placement of branch instructions, is a performance optimization. Similar to loop alignment, the desire is to increase speed, at the cost of code-size. However, the way this feature has been designed is a global assembler flag. I find that not ideal, because it cannot take into account hotness of a block/function, as for example loop alignment code does. Basic-block alignment of loops is explicitly opt-in on an block-by-block basis -- the compiler simply emits a p2align directive where it needs, and the assembler honors that. And so, MachineBlockPlacement::alignBlocks has a bunch of conditions under which it will avoid emitting a p2align. This seems like a good model -- the assembler does what it's told by the compiler (or assembly-writer). Making the branch-instruction-alignment work similarly seems like it would be good.

IMO it would be nicest if there could be a directive that requests to specially-align the next instruction. However, the fused-jcc case makes that quite tricky, so perhaps this ought to also be a mode which can be enabled/disabled on a region as well.

Yes, the primary goal of this patch is a performance optimization or mitigation. The intention is to provide a simple method for users to mitigate the performance impact of JCC MCU with less effort. We also provide users several options to tune the performance. But the basic idea is to make it easy for users to mitigate it and improve the performance.

Your proposal is a good idea. But I'm afraid it may not cover all the scenarios. Firstly, the proposal replies on compiler to detect the hotspots. But the compiler needs LTO and/or PGO to get the precise hot spots. Otherwise, if the compiler misses the hot spots which impact the application performance, the users have no way but have to insert the directives manually. Secondly, for the existing codes written in assembly, the compiler can't handle it. The users have to insert the directives by hand, which are pretty much work.

I think the current patch wants to give a simple and general solution to mitigate JCC MCU performance impact to both C/C++ and Assembly. And it doesn't need any source code change. I think your proposal will be a good enhancement on top of it.

[skan]

In D70157#1771771, @reames wrote:

We uncovered another functional issue with this patch, or at least, the interaction of this patch and other parts of LLVM. In our support for STATEPOINT, PATCHPOINT, and STACKMAP we use N-byte nop sequences for regions of code which might be patched out. It's important that these regions are exactly N bytes as concurrent patching which doesn't replace an integral number of instructions is ill-defined on X86-64. This patch causes the N-byte nop sequence to sometimes become (N+M) bytes which breaks the patching. I believe that the XRAY support may have a similar issue.

More generally, I'm worried about the legality of arbitrarily prefixing instructions from unknown sources. In the particular example we saw, we had something along the following:

.Ltmp0:
.p2align 3, 0x90
(16 byte nop sequence)
.Ltmp3:
jmp *%rax

In addition to the patching legality issue above, padding the nop sequence does something else interesting in this example. It changes the alignment of Ltmp3. Before, Ltmp3 was always 8 byte aligned, after prefixes are added, it's not. It's not clear to me exactly what the required semantics here are, but we at least had been assuming the alignment of Ltmp3 was guaranteed in this case. (That's actually how we found the patching issue.)

I could not reproduce the phenomenon that N-byte nop becomes (N+M) bytes with your example. So according to my understanding, I slightly modified your case. (If my understand is wrong, I hope you can point it out :-). )

    .text
    nop
.Ltmp0:
    .p2align 3, 0x90
    .rept 16
    nop
    .endr
.Ltmp3:
    movl  %eax, -4(%rsp)
    .rept 2
    nop
    .endr
    jmp .Ltmp0

The instruction jmp .Ltmp0 starts at byte 0x1e and ends at byte 0x20. If we align the jump with preifx, two prefixes will be added to the .rept2 16 nop .endr. After prefixes are added, the 16-byte nop becomes 18-byte nop, then the label '.Ltmp3' is not 8-byte aligned any more.

I doubt whether the assumption that '.Ltmp3' is 8-byte aligned is right, since the alignment is not explicitly required. For example, I think we can not assuming the instruction jmp .Ltmp0 always starts at byte 0x1e. And in fact, as long as the binary generated by the compiler does not have a one-to-one correspondence with the assembly code, at least one implict assumption of an instruction will be broken.

[fedor.sergeev]

In D70157#1774561, @skan wrote:

I could not reproduce the phenomenon that N-byte nop becomes (N+M) bytes with your example. So according to my understanding, I slightly modified your case. (If my understand is wrong, I hope you can point it out :-). )

    .text
    nop
.Ltmp0:
    .p2align 3, 0x90
    .rept 16
    nop
    .endr
.Ltmp3:
    movl  %eax, -4(%rsp)

In our case it was

andl $1, %eax

but it does not matter that much.

.rept 2
nop
.endr
jmp .Ltmp0

The instruction `jmp .Ltmp0` starts at byte 0x1e and ends at byte 0x20.

Again, in our particular case start of the sequence was at xxx8, so 8 + 16(our sequence) + 3(andl) + 5(jmp) == 32.

If we align the jump with preifx, two prefixes will be added to the .rept2 16 nop .endr. After prefixes are added, the 16-byte nop becomes 18-byte nop, then the label '.Ltmp3' is not 8-byte aligned any more.

Yes, thats what happened.

I doubt whether the assumption that '.Ltmp3' is 8-byte aligned is right, since the alignment is not explicitly required.

The point is that we have explicit requirement at the start and we have a lowering into 16-byte sequence that we need to be preserved exactly as it is.
Essentially what we need is a "protection" for this sequence from any changes by machinery that generates the binary code.
How can we protect a particular byte sequence from being changed by this branch aligner?

[annita.zhang]

The point is that we have explicit requirement at the start and we have a lowering into 16-byte sequence that we need to be preserved exactly as it is.
Essentially what we need is a "protection" for this sequence from any changes by machinery that generates the binary code.
How can we protect a particular byte sequence from being changed by this branch aligner?

No, in general we can't. The current solution is based on assembler to insert prefix or nop before the cross (or against) boundary branches. It can only ensure the explicit alignment specified by directive, but not any implicit alignment. I don't think any fixup based on assembler can do it. On the other hand, any code sequence after the alignment directive or even just in a function has some kind of implicit alignment. It's hard for assembler to tell which implicit alignment to preserve. The preferred way is to use explicit alignment directive to specify it.

For your scenario, a NOP padding is more controllable. NOP padding will be inserted just before the branch instructions (or macro fusion branch instructions). So if there's no branches (or macro fusion branches) in your code sequence, there will be no NOP inserted.

[fedor.sergeev]

In D70157#1775016, @annita.zhang wrote:

The point is that we have explicit requirement at the start and we have a lowering into 16-byte sequence that we need to be preserved exactly as it is.
Essentially what we need is a "protection" for this sequence from any changes by machinery that generates the binary code.
How can we protect a particular byte sequence from being changed by this branch aligner?

No, in general we can't. The current solution is based on assembler to insert prefix or nop before the cross (or against) boundary branches. It can only ensure the explicit alignment specified by directive, but not any implicit alignment. I don't think any fixup based on assembler can do it. On the other hand, any code sequence after the alignment directive or even just in a function has some kind of implicit alignment. It's hard for assembler to tell which implicit alignment to preserve. The preferred way is to use explicit alignment directive to specify it.

For your scenario, a NOP padding is more controllable. NOP padding will be inserted just before the branch instructions (or macro fusion branch instructions). So if there's no branches (or macro fusion branches) in your code sequence, there will be no NOP inserted.

What if I insert explicit align(8) right *after* the sequence?

[reames]

I just posted an alternate review (https://reviews.llvm.org/D71238) which attempts to carve out a minimum reviewable piece of complexity. The hope is that we can review that one quickly (as there are fewer interacting concerns), and then rebase this one (possibly splitting further).

I had previously suggested in review comments that we should reuse the infrastructure from .bundle_align_mode. When I sat down to actually implement that, I discovered that the code for that has a bunch of interacting assumptions about when fragments are constructed and used vs alignment boundaries. I got a version of this working, but the complexity was worrisome. I now suggest that we should take the rough approach sketched here (a separate fragment before the one being aligned), delete the essentially unused bundle mode code, and revisit a unified representation if needed for memory density at a later time. (i.e. my previous suggestion wasn't a good one)

[skan]

In D70157#1775481, @fedor.sergeev wrote:

In D70157#1775016, @annita.zhang wrote:

The point is that we have explicit requirement at the start and we have a lowering into 16-byte sequence that we need to be preserved exactly as it is.
Essentially what we need is a "protection" for this sequence from any changes by machinery that generates the binary code.
How can we protect a particular byte sequence from being changed by this branch aligner?

No, in general we can't. The current solution is based on assembler to insert prefix or nop before the cross (or against) boundary branches. It can only ensure the explicit alignment specified by directive, but not any implicit alignment. I don't think any fixup based on assembler can do it. On the other hand, any code sequence after the alignment directive or even just in a function has some kind of implicit alignment. It's hard for assembler to tell which implicit alignment to preserve. The preferred way is to use explicit alignment directive to specify it.

For your scenario, a NOP padding is more controllable. NOP padding will be inserted just before the branch instructions (or macro fusion branch instructions). So if there's no branches (or macro fusion branches) in your code sequence, there will be no NOP inserted.

What if I insert explicit align(8) right *after* the sequence?

If your insert explicit .align 8 after the sequence, and the sequence doesn't has any branch to be aligned, the current solution won't change the sequence.

[fedor.sergeev]

In D70157#1776424, @skan wrote:

What if I insert explicit align(8) right *after* the sequence?

If your insert explicit .align 8 after the sequence, and the sequence doesn't has any branch to be aligned, the current solution won't change the sequence.

Well, I kinda figure that from the code behavior right now, however is it really by design or just happens to work now?
Seeing that assembler becomes very intelligent now I would rather have a strict guarantee similar to "hardcode" thing that you have here that protects my sequence
rather than relying on a fact that in current settings moving my label by 8 does not appear to be profitable to assembler.

[skan]

In D70157#1777272, @fedor.sergeev wrote:

In D70157#1776424, @skan wrote:

What if I insert explicit align(8) right *after* the sequence?

If your insert explicit .align 8 after the sequence, and the sequence doesn't has any branch to be aligned, the current solution won't change the sequence.

Well, I kinda figure that from the code behavior right now, however is it really by design or just happens to work now?

It is by design, prefix won't be added to instruction if there is a align directive int the path to the target branch.

Seeing that assembler becomes very intelligent now I would rather have a strict guarantee similar to "hardcode" thing that you have here that protects my sequence
rather than relying on a fact that in current settings moving my label by 8 does not appear to be profitable to assembler.

It depends on what your real need is. If you just need your original implicit alignment to work, turning it into explicit alignment is enough. Or if you need a sequence not changed by
the assembler at all, maybe we need a new directive such as ".hard " or ".bundle".

[skan]

1. Replace divide and mod operation with bitwise operation
2. Refine help information

[annita.zhang]

In D70157#1768338, @annita.zhang wrote:

In D70157#1768319, @chandlerc wrote:

I'm seeing lots of updates to fix bugs, but no movement for many days on both my meta comments and (in some ways more importantly) James's meta comments. (And thanks Philip for chiming in too!)

Meanwhile, we really, really need to get this functionality in place. The entire story for minimizing the new microcode performance hit hinges on these patches, and I'm really worried by how little progress we're seeing here.

Sorry for belated response. We're working hard to go through some paper work to get the performance data ready. I think maybe it's better to open a mailing thread in llvm-dev to post those performance data and discuss those suggestions.

The first data was posted in http://lists.llvm.org/pipermail/llvm-dev/2019-December/137413.html.

Thanks,
Annita

More performance data was posted on http://lists.llvm.org/pipermail/llvm-dev/2019-December/137609.html and http://lists.llvm.org/pipermail/llvm-dev/2019-December/137610.html. Let's move on based on the data.

[skan]

1. rename getSegmentPrefixSize(const MCInst &MI) to countSegmentPrefix(const MCInst &MI).
2. remove unnecessary data member of X86AsmBackend std::vector<MCMachineDependentFragment *> PendingAlignmentFragments.
3. Make the message of assert in MCMachineDependentFragment more clear.

[annita.zhang]

More performance data was posted on http://lists.llvm.org/pipermail/llvm-dev/2019-December/137609.html and http://lists.llvm.org/pipermail/llvm-dev/2019-December/137610.html. Let's move on based on the data.

Based on the SPEC data, we observed 2.6% and 1.3% performance effect in INTRATE and FPRATE geomean respectively. Performance effect on individual components were observed up to 5.1%.

The tool SW mitigation can recover the geomean to within 99% of the original performance with prefix padding to jcc+jmp+fused. The maximum performance loss was reduced to within 2.2% of the original one.

The prefix padding can provide better performance as 0.3%~0.5% in geomean than nop padding on system with micro update. In individual cases, we observed up to 1.4% performance improvement in prefix padding. On a system w/o micro update, we observed 0.7% better performance of prefix padding on INTRATE geomean.

In this SPEC test, the prefix padding to jcc+jmp+fused and prefix padding to all branches has almost the same performance. However, we observed the latter prefix padding had a little bit better performance than the previous one in some cases at the cost of code size.

Since the performance delta in prefix padding and nop padding is incremental, starting from nop padding may be easier to implement as a first step, with additional prefix padding options to explore for additional performance optimizations.

And since the current update enables a relatively simple and general solution to mitigate JCC microcode update (MCU) performance effects to both C/C++ and Assembly without any source code change, we recommend it as a starting point. Then, the proposal for compiler to generate directives could enable further enhancements.

[reames]

In offline discussion, there was an agreement that we needed further coordination to make sure this patch moves forward quickly. For that reason, there will be a call happening today at 4pm Pacific. Interested parties are welcome to attend.

Zoom Meeting ID: 507-497-8898
https://azul.zoom.us/j/5074978898

Results of the meeting will be summarized and posted here.

[MaskRay]

Haven't looked into too many details yet but made some suggestions anyway...

llvm/include/llvm/MC/MCFragment.h

727

Store AlignBoundarySize as a shift value, then needPadding doesn't even need to call Log2_64().

llvm/lib/MC/MCFragment.cpp

432

const auto *. The type is obvious according to the right hand side.

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

101

An unknown value is just ignored, e.g. --x86-align-branch=unknown. I think there should be an error, but I haven't looked into the patch detail to confidently suggest how we should surface this error.

182

} else {

Should --x86-branches-within-32B-boundaries overwrite --x86-align-branch-boundary and --x86-align-branch and --x86-align-branch-prefix-size? My feeling is that it just provides a default value if either of the three options is not specified.

If you are going to remove addKind calls here, you can delete this member function.

193

space after if

No curly braces around simple statements.

637

isa<MCMachineDependentFragment>(F)

llvm/lib/Target/X86/X86InstrInfo.td

1020

Unintentional change not part of this patch?

llvm/test/MC/X86/align-branch-32-1a.s

1 ↗

(On Diff #234041)

Did an older version include 32-1b.s or 32-1c.s? Now they are missing.

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

1 ↗

(On Diff #234041)

Create test/MC/X86/Inputs/align-branch-64-1.s and reference it from 1[a-d].s via %S/Inputs/align-branch-64-1.s

[reames]

Noting another issue we found in local testing (with an older version of this patch). This interacts badly with the implicit exception mechanism in LLVM. For that mechanism, we end up generating assembly which looks more or less like this:
Ltmp:

cmp %rsi, (%rdi)
jcc <target>

And a side table which maps TLmp to another label so that a fault at Ltmp can be interpreted as an extremely expensive branch via signal handler.

The problem is that the auto-alignment of the fused branch causes padding to be introduced which separate the label and the faulting exception, breaking the mapping.

Essentially, this comes down to an implicit assumption that the label stays tightly bundled with the following instruction.

This can happen with either nop or prefix padding.

[chandlerc]

Just wanted to say thanks for the performance data! I know it was hard to get, but it is really, really useful to help folks evaluate these kinds of changes with actual data around the options available.

[skan]

llvm/lib/MC/MCFragment.cpp

432

Shall we keep consistent with the local code style? const MCLEBFragment *LF = cast<MCLEBFragment>(this); was used here.

[reames]

Here are the minutes from our phone call a few minutes ago.

Attendees: Andy Kaylor, Craig Topper, Annita Zhang, Tom Stellard, Chandler Carruth, Fedor Sergeev, Philip Reames, Yuanake Luo

Status Summary

Performance data has been posted to llvm-dev. We had a side discussion about nop encoding, and it was mentioned these numbers were collected from runs targeting skylake (i.e. not generic x86). This is similar to the result we (Azul) have collected and shared summaries of previously.

GNU patch has landed Friday - this mostly fixes assembler command line.

Discussion on Approach

Three major options debated:

Assembler only - as in the current patch, assembler does all work, only command line flag
Explicit Directive only - as proposed in my alternate patch, compiler decides exactly what instructions get aligned
Region based directives - as proposed in James' last comment on review, directives enable and disable auto-padding in assembler

Use cases identified:

compiler users
    important than assembler is self contained (i.e. don't have to know compiler options for reproduceability)
    inline assembly looks a lot like assembler users
legacy assembler
    important that existing assembly works unmodified
assembler users
    "try it and see" model vs selective enable vs selective disable
    likely need to support all three

Consensus was that the region based directives met use cases the best. In particular, desire to be able to overrule default (for say, inline assembly or a JITs patchability assumptions) and then restore default. Default assembler behavior remains unchanged.

Stawman syntax proposal

.align_branch_boundary disable/default
.align_branch_boundary enable N, instructions (fused, jcc, jmp, etc..)

We need to ensure a consensus on syntax is shared w/gnu. Annita agreed to coordinate this.

Compiler would essentially just wrap generated assembly in directives.

Issue noticed while writing this up: proposed syntax assumes a default has been set, but doesn't give a way to set one. This would seem to break the desired reproducibility property for compiled code. Revision needed.

Push/Pop semantics were suggested at one point, but were thought to be non-idiomatic?

Other Topics

We very quickly discussed nop vs prefix performance. There was a clear consensus in starting with nop only patch and evolving later as needed.

Next Steps

Annita will refresh current patch with two key changes. 1) Drop prefix support and simplify and 2) drop clang driver support for now. Desire is to minimize cycle time before next iteration so that feedback on approach can be given while reviewers are still around.

Philip will prototype directive parsing support. Annita and Yuo (??) to handle coordination on syntax.

Suggested patch split:

(current patch) command line option to set default, nop only version w/cleaned up code as much as possible
assembler directive support (draft by Philip in parallel)
(future) compiler patch to wrap by default

Side note to Annita: For you to remove "hard code", you'll have to have a placeholder for the enable/disable interface. That should probably be split and rebased in my patch.

[MaskRay]

In D70157#1787139, @reames wrote:

Here are the minutes from our phone call a few minutes ago.

Attendees: Andy Kaylor, Craig Topper, Annita Zhang, Tom Stellard, Chandler Carruth, Fedor Sergeev, Philip Reames, Yuanake Luo

Thanks for organization the meeting and making the summary.

Stawman syntax proposal

.align_branch_boundary disable/default
.align_branch_boundary enable N, instructions (fused, jcc, jmp, etc..)

...

Push/Pop semantics were suggested at one point, but were thought to be non-idiomatic?

There is a precedant: .pushsection/.popsection (MCStreamer::SectionStack). With .push_align_branch/.pop_align_branch, we probably don't need the 'switch-to-default' action.

I don't know how likely we may ever need nested states (e.g. an .include directive inside an .align_branch region where the included file has own idea about branch alignment), but .push/.pop does not seem to be more complex than disable/enable/default.

I confirm that the following 4 commits have been to the binutils-gdb repository (https://sourceware.org/ml/binutils/2019-12/msg00138.html https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=e379e5f385f874adb0b414f917adb1fc50e20de9).

gas: Add md_generic_table_relax_frag
i386: Align branches within a fixed boundary
i386: Add -mbranches-within-32B-boundaries
i386: Add tests for -malign-branch-boundary and -malign-branch

[annita.zhang]

In D70157#1787139, @reames wrote:

Here are the minutes from our phone call a few minutes ago.

Thanks for coordinating the meeting and having a clear summary. It helps a lot to accelerate the patch review. I really appreciate it!

Annita will refresh current patch with two key changes. 1) Drop prefix support and simplify and 2) drop clang driver support for now. Desire is to minimize cycle time before next iteration so that feedback on approach can be given while reviewers are still around.

Yes, we are working on it right now. Hopefully we can submit a new patch today or tomorrow.

Philip will prototype directive parsing support. Annita and Yuo (??) to handle coordination on syntax.

I suppose it's Annita and Fangrui

Side note to Annita: For you to remove "hard code", you'll have to have a placeholder for the enable/disable interface. That should probably be split and rebased in my patch.

Let's do it in your directive patch.

[skan]

In D70157#1786901, @reames wrote:

Noting another issue we found in local testing (with an older version of this patch). This interacts badly with the implicit exception mechanism in LLVM. For that mechanism, we end up generating assembly which looks more or less like this:
Ltmp:

cmp %rsi, (%rdi)
jcc <target>

And a side table which maps TLmp to another label so that a fault at Ltmp can be interpreted as an extremely expensive branch via signal handler.

The problem is that the auto-alignment of the fused branch causes padding to be introduced which separate the label and the faulting exception, breaking the mapping.

Essentially, this comes down to an implicit assumption that the label stays tightly bundled with the following instruction.

This can happen with either nop or prefix padding.

How about insert NOP before the label Ltmp?

[annita.zhang]

In D70157#1787160, @MaskRay wrote:

There is a precedant: .pushsection/.popsection (MCStreamer::SectionStack). With .push_align_branch/.pop_align_branch, we probably don't need the 'switch-to-default' action.

I don't know how likely we may ever need nested states (e.g. an .include directive inside an .align_branch region where the included file has own idea about branch alignment), but .push/.pop does not seem to be more complex than disable/enable/default.

I rethink about the directives and prefer the .push/.pop pair as @MaskRay suggested. To be specified, I'd suggest to use .push_align_branch_boundary and .pop_align_branch_boundary to align with MC command line options. They will cowork with the command line options and overwrite the options if both are existing.

To be clarified, I described the behavior of the directives from my understanding. Feel free to speak if you have difference opinion.

.push_align_branch_boundary [N,] [instruction,]*

This directive specifies the beginning of a region which will overwrite the value set by the command line or by the previous directive. It can represent either an enabling or disabling directive controlled by parameter N. 
N indicates to align the branches within N byte boundary. The default value is 32. If N is 0, it means the branch alignment is off within this region. 
Instruction specifies types of branches to align. The value is one or multiple values from fused, jcc, jmp, call, ret and indirect. The default value is fused, jcc and jmp. (may change later)

.pop_align_branch_boundary

This directive specifies the end of a region to align branch boundary. The status will be back to which was set by the previous directive or the one set by the command line if there's no previous directive existing.

I will coordinate with GNU binutils community once we discuss and have agreement with the directives.

[jyknight]

.push_align_branch_boundary [N,] [instruction,]*

I'd like to raise again the possibility of using a more general region directive to denote "It is allowable to add prefixes/nops before instructions in this region if the assembler wants to", as I'd started discussing in https://reviews.llvm.org/D71238#1786885 (but let's move the discussion here).

Whether this is OK or not on a particular piece of assembly-code is likely to be a generic property of the code, regardless of the purpose of the optimization. If we're going to have multiple assembler optimizations that can make use of this, it would be nice to express the "OK to pad" "not OK to pad" property only once, rather than once for each kind of optimization which might make such modifications.

In particular, I'd like to look ahead towards the potential implementation of two other features:

1. Allowing the assembler to prefix-pad instructions in order to avoid having to emit a NOP for p2align directives.
2. Allowing the assembler to do other instruction-padding performance optimizations to avoid other DSB cacheline limits.

To be concrete, I propose:
".autopad", ".noautopad": allow/disallow the assembler to emit padding via inserting a nop or prefix before any instruction, as needed.
".align_branch_boundary [N,] [instruction,]": Enable branch-boundary padding (per previous description).

In this scheme, I'd generally expect an ".align_branch_boundary" directive to be specified once at the beginning of the file, and ".autopad"/".noautopad" directives to be sprinkled throughout the file as required.

[skan]

Simplify

1. Drop prefix padding support
2. Drop clang driver support
3. Drop default align option -x86-branches-within-32B-boundaries
4. Drop hardcode support

Other

1. Throw an error if an illegal value is passed to option -x86-align-branch
2. Use llvm::Align instead of uint64_t to store the information about boundary
3. Remove test cases for prefix padding and add more test cases for NOP padding
4. Rename MCMachineDependentFragment to MCBoundaryAlignFragment

[reames]

In D70157#1787403, @annita.zhang wrote:

In D70157#1787160, @MaskRay wrote:

There is a precedant: .pushsection/.popsection (MCStreamer::SectionStack). With .push_align_branch/.pop_align_branch, we probably don't need the 'switch-to-default' action.

I don't know how likely we may ever need nested states (e.g. an .include directive inside an .align_branch region where the included file has own idea about branch alignment), but .push/.pop does not seem to be more complex than disable/enable/default.

I rethink about the directives and prefer the .push/.pop pair as @MaskRay suggested. To be specified, I'd suggest to use .push_align_branch_boundary and .pop_align_branch_boundary to align with MC command line options. They will cowork with the command line options and overwrite the options if both are existing.

I agree that we need the push/pop semantics.

To be clarified, I described the behavior of the directives from my understanding. Feel free to speak if you have difference opinion.

.push_align_branch_boundary [N,] [instruction,]*

This directive specifies the beginning of a region which will overwrite the value set by the command line or by the previous directive. It can represent either an enabling or disabling directive controlled by parameter N. 
N indicates to align the branches within N byte boundary. The default value is 32. If N is 0, it means the branch alignment is off within this region. 
Instruction specifies types of branches to align. The value is one or multiple values from fused, jcc, jmp, call, ret and indirect. The default value is fused, jcc and jmp. (may change later)

I'd remove the defaults. Let's just be explicit about what is being enabled/disabled.

[reames]

In D70157#1788025, @jyknight wrote:

.push_align_branch_boundary [N,] [instruction,]*

I'd like to raise again the possibility of using a more general region directive to denote "It is allowable to add prefixes/nops before instructions in this region if the assembler wants to", as I'd started discussing in https://reviews.llvm.org/D71238#1786885 (but let's move the discussion here).

James, I think this proposal is increasing the scope of this proposal too much. It also ignores some of the use cases identified and described in the writeup (i.e. the scoped semantics). I'm open to discussing such a feature more generally, but I'd prefer to see a more narrowly focused feature immediately.

[reames]

Specifically on the revised patch, I remain confused by the need for multiple subtypes. The need for fragments *between* the potentially fused instructions doesn't make sense to me. What I was expecting to see was the following:
BoundaryAlign w/target=the branch fragment
.. some possibly empty sequence of fragments (i.e. the test/cmp/etc..) ...
the branch fragment
a new data fragment if the branch fragment was a DF

(i.e. a single BounaryAlign fragment which aligns a payload which is defined as "next fragment to target fragment inclusive".)

To be specific, I'd expect to see the following for an example fused sequence:

1. BoundaryAlign w/Target = 3
2. DataFragment containing TEST RAX, RAX
3. RelaxeableFragment containing JNE symbo

Why do we need anything between the two fragments of the fused pair?

(As a reminder, I am new to this code. If I'm missing the obvious, please just point it out.)

[jyknight]

In D70157#1788418, @reames wrote:

In D70157#1788025, @jyknight wrote:

.push_align_branch_boundary [N,] [instruction,]*

I'd like to raise again the possibility of using a more general region directive to denote "It is allowable to add prefixes/nops before instructions in this region if the assembler wants to", as I'd started discussing in https://reviews.llvm.org/D71238#1786885 (but let's move the discussion here).

James, I think this proposal is increasing the scope of this proposal too much. It also ignores some of the use cases identified and described in the writeup (i.e. the scoped semantics). I'm open to discussing such a feature more generally, but I'd prefer to see a more narrowly focused feature immediately.

I do not intend that we expand the scope of the project to include any of the other features.

All I want is to slightly consider surrounding features when adding the new assembly syntax. The situations where we want to avoid modifying a certain block of code are extremely likely to apply to any nop-or-prefix-introducing code modifications -- not just modifications resulting from branch alignment. So if we can make the directives annotating where such changes are allowable (and conversely, where they are not) generally-applicable, with a very minimal amount of work, that would be nice.

I also don't understand what you mean by "it ignores [...] scoped semantics"?

[reames]

I've updated the draft assembler support in https://reviews.llvm.org/D71315 to match the proposal here. Again, this is very much WIP and mostly just to show proposed syntax/usage.

[skan]

In D70157#1788445, @reames wrote:

Specifically on the revised patch, I remain confused by the need for multiple subtypes. The need for fragments *between* the potentially fused instructions doesn't make sense to me. What I was expecting to see was the following:
BoundaryAlign w/target=the branch fragment
.. some possibly empty sequence of fragments (i.e. the test/cmp/etc..) ...
the branch fragment
a new data fragment if the branch fragment was a DF

(i.e. a single BounaryAlign fragment which aligns a payload which is defined as "next fragment to target fragment inclusive".)

To be specific, I'd expect to see the following for an example fused sequence:

1. BoundaryAlign w/Target = 3
2. DataFragment containing TEST RAX, RAX
3. RelaxeableFragment containing JNE symbo

Why do we need anything between the two fragments of the fused pair?

(As a reminder, I am new to this code. If I'm missing the obvious, please just point it out.)

JUMP is not always emiteed into MCRelaxableFragment, it also can be emitted into MCDataFragment and arithmetic ops with constant arguments of unknown value (e.g. ADD,AND) can be emitted into MCRelaxableFragment , you can find related code in MCObjectStreamer::EmitInstructionImpl, X86AsmBackend::mayNeedRelaxation. Let's say JCC is fused with TEST, there are four possible positions for JCC and CMP

1. JCC and CMP are in same MCDataFragment
2. JCC and CMP are in two different MCDataFragment
3. JCC and CMP are in two different MCRelaxableFragment
4. JCC in a MCRelaxableFragment, CMP is in a MCDataFragment

and since MCCompactEncodedInstFragment is not applicable yet, i don't what's its behaviour.

In order to compute the total size of CMP and JCC in MCAssembler::relaxBoundaryAlign, I insert a FusedJccSplit to force CMP and JCC in two fragments. Do you have any better idea?

[skan]

Simplify

Drop the subtype of MCBoundaryAlignFragment and add data member EmitNops to indicate whether NOPs should be emitted.

[skan]

1. rename MCBoundaryAlignFragment::hasEmitNop() to MCBoundaryAlignFragment::canEmitNop()

2. reduce the number of MCBoundaryAlignFragment emitted as possible

[skan]

Fix a typo in MCFragment::dump()

[skan]

move the code that checks if we can reuse the current MCBoundaryAlignFragment into the function X86AsmBackend::getOrCreateBoundaryAlignFragment

[skan]

Add more comment

[reames]

In D70157#1789159, @skan wrote:

In D70157#1788445, @reames wrote:

Specifically on the revised patch, I remain confused by the need for multiple subtypes. The need for fragments *between* the potentially fused instructions doesn't make sense to me. What I was expecting to see was the following:
BoundaryAlign w/target=the branch fragment
.. some possibly empty sequence of fragments (i.e. the test/cmp/etc..) ...
the branch fragment
a new data fragment if the branch fragment was a DF

(i.e. a single BounaryAlign fragment which aligns a payload which is defined as "next fragment to target fragment inclusive".)

To be specific, I'd expect to see the following for an example fused sequence:

1. BoundaryAlign w/Target = 3
2. DataFragment containing TEST RAX, RAX
3. RelaxeableFragment containing JNE symbo

Why do we need anything between the two fragments of the fused pair?

(As a reminder, I am new to this code. If I'm missing the obvious, please just point it out.)

JUMP is not always emiteed into MCRelaxableFragment, it also can be emitted into MCDataFragment and arithmetic ops with constant arguments of unknown value (e.g. ADD,AND) can be emitted into MCRelaxableFragment , you can find related code in MCObjectStreamer::EmitInstructionImpl, X86AsmBackend::mayNeedRelaxation. Let's say JCC is fused with TEST, there are four possible positions for JCC and CMP

1. JCC and CMP are in same MCDataFragment
2. JCC and CMP are in two different MCDataFragment
3. JCC and CMP are in two different MCRelaxableFragment
4. JCC in a MCRelaxableFragment, CMP is in a MCDataFragment

and since MCCompactEncodedInstFragment is not applicable yet, i don't what's its behaviour.

In order to compute the total size of CMP and JCC in MCAssembler::relaxBoundaryAlign, I insert a FusedJccSplit to force CMP and JCC in two fragments. Do you have any better idea?

I agree there are multiple cases here, see the original generic description instead of the specific example. The general question is why a *range* of fragments can't be defined. Computing the instruction size for the entire range then just requires walking from first to last fragment in the range summing the size of each. If both instructions are within the same data fragment, then no relaxation is needed, and the size of both is simply the size of the data fragment.

Unless I'm missing something here?

[reames]

LGTM. The patch isn't perfect, but this has reached the point where landing and iterating in tree is the fastest way to convergence. To be clear, this LGTM *only* applies to the current patch contents, and the *internal only* flag names this introduces. These may change before we expose this publicly.

Warts with the current patch we should iterate to address:

• Stylistic issues w.r.t. comments, naming, static vs member functions remain. None are show stoppers.
• Many of the tests can probably be simplified and condensed.
• The bundling scheme used is probably more complicated than needed (see previous suggestions).
• This patch doesn't include anyway to locally disable padding, and thus is *known incorrect* in some cases. As this remains off by default, this is not a blocker for commit.

p.s. I spoke w/James this morning, and we came up with some revisions in approach he's going to suggest separately. We did explicitly discuss the status of the current patch, and whether it needed further review cycles or could be iterated in tree. Normally, I'd wait for him to summarize that conversation publicly, but given the time delay and vacation schedules involved, I want to avoid loosing another day cycle.

llvm/include/llvm/MC/MCFragment.h

662

Please add a note that the size is lazily set during relaxation, and is not meaningful before that.

llvm/test/MC/X86/align-branch-32-1a.s

34 ↗

(On Diff #234697)

For testing alignment functionality, we can probably use a repl int3 pattern here. It would make the tests much more concise, and shouldn't effect the logic being (currently) tested.

[annita.zhang]

To be concrete, I propose:
".autopad", ".noautopad": allow/disallow the assembler to emit padding via inserting a nop or prefix before any instruction, as needed.
".align_branch_boundary [N,] [instruction,]": Enable branch-boundary padding (per previous description).

I had thought I sent the comments yesterday, but I didn't. :( I think my comments are aligned with the conclusion that Philip and Jame got. Wait for Jame's summary.

In general, I think it's a good idea to have generic directives to control the padding behavior in assembler. ".autopad", ".noautopad", ".align_branch_boundary" looks good except it can't handle the nested scenarios. I can imagine the nested cases in assembly file which includes another assembly file. If we want to handle it, we need to have a pair of directives for each above. It will make the semantics complicated. We need elaborately design it.
I'd echo what Philip said. We want a more focused and basic implementation here. We're very open to have more discussion on generic directives. However, I'd prefer it's a separate topic from this one.

[skan]

In D70157#1791347, @reames wrote:

The general question is why a *range* of fragments can't be defined. Computing the instruction size for the entire range then just requires walking from first to last fragment in the range summing the size of each. If both instructions are within the same data fragment, then no relaxation is needed, and the size of both is simply the size of the data fragment.

Unless I'm missing something here?

Thank you for your detailed explanation, the solution has been consistent with your suggestion now.

[MaskRay]

llvm/lib/MC/MCAssembler.cpp

1032

be relaxed

1036

uint64_t

1038

auto -> MCFragment

1042

unsigned -> int

1046

uint64_t

[skan]

llvm/lib/MC/MCAssembler.cpp

1042

Why use int here?

[skan]

1. Simplify the test cases.
2. Add some comments

[MaskRay]

llvm/lib/MC/MCAssembler.cpp

1042

The loop variable can only be 0 or 1. 0U 1U 2U the unsigned suffix are just redundant. int suffices. It also improves readability a bit by avoiding auto.

[skan]

Do you think this patch is ready to land? @MaskRay

[MaskRay]

In D70157#1792262, @skan wrote:

Do you think this patch is ready to land? @MaskRay

It is 00:35 here and I should confess that I haven't read through this yet.

There are some minor things like (1) pervasive auto (2) report_fatal_error in X86AlignBranchKind is not suitable. I expect the error is reported at a command line parsing stage. (3) I don't see how __tls_get_addr is referenced in code but somehow it magically appears in tests. It may be related to VK_NONE but there should be more tests for !VK_NONE cases. (4) More function-level comments are needed.

If it is not super urgent, probably want a couple of hours to get a response from @reames or @jyknight whether they think this can be committed as is, with iteration work in the future?

(Also note that @fedor.sergeev has requested changes. The convention is to wait for @fedor.sergeev to agree that this can be accepted... but there are vacation schedules involved.)

llvm/lib/MC/MCAssembler.cpp

1048

Align

[skan]

1. Add more tests for !VK_NONE cases.
2. Reduce pervasive auto

[reames]

I've gone ahead and landed the patch so that we can iterate in tree. See commit 14fc20ca62821b5f85582bf76a467d412248c248.

I've also landed a couple of follow up patches to address issues which would have otherwise required iteration on the review. See commits c148e2e2ef86f53391be459752511684424f331b, 4024d49edc1598a6f8017df541147b38bf1e2818, and 8b725f0459eee468ed7f9935fba3278fcb4997b1.

I still see some room for further cleanup (i.e. the fragment range scheme and tests), but what's in is of reasonable quality.

There's a couple follow up patches which are probably called for, but I think we can work on these in parallel now.

1. We need to settle on assembler syntax.
2. We need a patch for the x86 MI to MC translation to mark regions unsafe to pad. (Probably best to separate from the above for the moment.)
3. We can incrementally add support for prefix padding.

[MaskRay]

In D70157#1793280, @reames wrote:

I've gone ahead and landed the patch so that we can iterate in tree. See commit 14fc20ca62821b5f85582bf76a467d412248c248.

I've also landed a couple of follow up patches to address issues which would have otherwise required iteration on the review. See commits c148e2e2ef86f53391be459752511684424f331b, 4024d49edc1598a6f8017df541147b38bf1e2818, and 8b725f0459eee468ed7f9935fba3278fcb4997b1.

I still see some room for further cleanup (i.e. the fragment range scheme and tests), but what's in is of reasonable quality.

There's a couple follow up patches which are probably called for, but I think we can work on these in parallel now.

1. We need to settle on assembler syntax.
2. We need a patch for the x86 MI to MC translation to mark regions unsafe to pad. (Probably best to separate from the above for the moment.)
3. We can incrementally add support for prefix padding.

If you planned to clean up, you could have made the cleanups in the original land:) Though there would be a problem of proper contribution attribution. After Subversion->Git transition, we can actually run `git commit --amend --author=ask-author-to-provide-name-and- <email>' (Though changing the author may not be fair to your contribution to this commit... oh it is so difficult.) Anyway, it is nice to see this feature before Christmas and people can start investigating its impact now.

[annita.zhang]

In D70157#1793280, @reames wrote:

I've gone ahead and landed the patch so that we can iterate in tree. See commit 14fc20ca62821b5f85582bf76a467d412248c248.

I've also landed a couple of follow up patches to address issues which would have otherwise required iteration on the review. See commits c148e2e2ef86f53391be459752511684424f331b, 4024d49edc1598a6f8017df541147b38bf1e2818, and 8b725f0459eee468ed7f9935fba3278fcb4997b1.

I still see some room for further cleanup (i.e. the fragment range scheme and tests), but what's in is of reasonable quality.

There's a couple follow up patches which are probably called for, but I think we can work on these in parallel now.

1. We need to settle on assembler syntax.
2. We need a patch for the x86 MI to MC translation to mark regions unsafe to pad. (Probably best to separate from the above for the moment.)
3. We can incrementally add support for prefix padding.

Thanks for landing it! And happy holiday to all!

clang/include/clang/Driver/Options.td

 def mmcu_EQ : Joined<["-"], "mmcu=">, Group<m_Group>;
 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>;
 def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>;
 def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>;
 def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
 def malign_double : Flag<["-"], "malign-double">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Align doubles to two words in structs (x86 only)">;
+def malign_branch_boundary_EQ
+    : Joined<["-"], "malign-branch-boundary=">,
+      Group<m_Group>,
+      Flags<[DriverOption, HelpHidden]>,
+      HelpText<
+          "Control how the assembler should align branches with segment "
+          "prefixes or NOP. The boundary's size must be a power of 2. It "
+          "should be 0 or no less than 32. Branches will be aligned within "
+          "the boundary of specifies size. -malign-branch-boundary=0 "
+          "doesn't align branches.">;
+def malign_branch_EQ
+    : Joined<["-"], "malign-branch=">,
+      Group<m_Group>,
+      Flags<[DriverOption, HelpHidden]>,
+      HelpText<
+          "Specify types of branches to align (plus separated list of "
+          "types). The branches's types is combination of jcc, fused, "
+          "jmp, call, ret, indirect."
+          " jcc, which aligns conditional jumps; fused, which aligns fused "
+          "conditional jumps; jmp, which aligns unconditional jumps; call, "
+          "which aligns calls; ret, which aligns rets; indirect, which "
+          "aligns indirect jumps.">;
+def malign_branch_prefix_size_EQ
+    : Joined<["-"], "malign-branch-prefix-size=">,
+      Group<m_Group>,
+      Flags<[DriverOption, CC1Option, HelpHidden]>,
+      HelpText<"Specify the maximum number of prefixes on an instruction to "
+               "align branches. The number should be between 0 and 5.">;
+def mbranches_within_32B_boundaries
+    : Flag<["-"], "mbranches-within-32B-boundaries">,
+      Group<m_Group>,
+      Flags<[DriverOption]>,
+      HelpText<
+          "Aligns conditional jumps, fused conditional jumps, and "
+          "unconditional "
+          "jumps within 32 byte boundary with up to 5 segment prefixes on an "
+          "instruction. It is equivalent to -malign-branch-boundary=32, "
+          "-malign-branch=fused+jcc+jmp, -malign-branch-prefix-size=5.">;
+def mno_branches_within_32B_boundaries
+    : Flag<["-"], "mno-branches-within-32B-boundaries">,
+      Group<m_Group>,
+      Flags<[DriverOption]>,
+      HelpText<"Opposite to -mbranches-within-32B_boundaries.">;
 def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">;
 def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;
 def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>;
 def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>;
 def mhwmult_EQ : Joined<["-"], "mhwmult=">, Group<m_Group>;
 def mglobal_merge : Flag<["-"], "mglobal-merge">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Enable merging of globals">;
 def mhard_float : Flag<["-"], "mhard-float">, Group<m_Group>;

clang/lib/Driver/ToolChains/Clang.cpp

 #include "clang/Driver/SanitizerArgs.h"
 #include "clang/Driver/XRayArgs.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/YAMLParser.h"
 
 #ifdef LLVM_ON_UNIX
 #include <unistd.h> // For getuid().
 #endif

 }
 
 void Clang::AddSystemZTargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false))
     CmdArgs.push_back("-mbackchain");
 }
 
+static void AlignBranchesOptions(const Driver &D, const ArgList &Args,
+                                 ArgStringList &CmdArgs) {
+  if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_boundary_EQ)) {
+    StringRef Value = A->getValue();
+    unsigned Num;
+    if (!Value.getAsInteger(10, Num) && Num >= 32 && llvm::isPowerOf2_32(Num)) {
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back(
+          Args.MakeArgString("-x86-align-branch-boundary=" + Value));
+    } else {
+      D.Diag(diag::err_drv_unsupported_option_argument)
+          << A->getOption().getName() << Value;
+    }
+  }
+
+  if (const Arg *A = Args.getLastArg(options::OPT_malign_branch_EQ)) {
+    StringRef Value = A->getValue();
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back(Args.MakeArgString("-x86-align-branch=" + Value));
+  }
+
+  if (const Arg *A =
+          Args.getLastArg(options::OPT_malign_branch_prefix_size_EQ)) {
+    StringRef Value = A->getValue();
+    unsigned Num;
+    if (!Value.getAsInteger(10, Num) && Num <= 5) {
+      CmdArgs.push_back("-mllvm");
+      CmdArgs.push_back(
+          Args.MakeArgString("-x86-align-branch-prefix-size=" + Value));
+    } else {
+      D.Diag(diag::err_drv_unsupported_option_argument)
+          << A->getOption().getName() << Value;
+    }
+  }
+
+  if (Args.hasFlag(options::OPT_mbranches_within_32B_boundaries,
+                   options::OPT_mno_branches_within_32B_boundaries, false)) {
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back(
+        Args.MakeArgString("-x86-branches-within-32B-boundaries"));
+  }
+}
+
 void Clang::AddX86TargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs) const {
+  AlignBranchesOptions(getToolChain().getDriver(), Args, CmdArgs);
+
   if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
       Args.hasArg(options::OPT_mkernel) ||
       Args.hasArg(options::OPT_fapple_kext))
     CmdArgs.push_back("-disable-red-zone");
 
   if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs,
                     options::OPT_mno_tls_direct_seg_refs, true))
     CmdArgs.push_back("-mno-tls-direct-seg-refs");
void ClangAs::AddMIPSTargetArgs(const ArgList &Args,
   mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName);
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName.data());
 }
 
 void ClangAs::AddX86TargetArgs(const ArgList &Args,
                                ArgStringList &CmdArgs) const {
+  AlignBranchesOptions(getToolChain().getDriver(), Args, CmdArgs);
+
   if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
     StringRef Value = A->getValue();
     if (Value == "intel" || Value == "att") {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
     } else {
       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;

clang/test/Driver/intel-align-branch.c

+// RUN: %clang -target x86_64-unknown-unknown -malign-branch-boundary=32 -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-BOUNDARY
+// CHECK-BOUNDARY: "-mllvm" "-x86-align-branch-boundary=32"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=jcc -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-JCC
+// CHECK-JCC: "-mllvm" "-x86-align-branch=jcc"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=fused -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-FUSED
+// CHECK-FUSED: "-mllvm" "-x86-align-branch=fused"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=jmp -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-JMP
+// CHECK-JMP: "-mllvm" "-x86-align-branch=jmp"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=call -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-CALL
+// CHECK-CALL: "-mllvm" "-x86-align-branch=call"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=ret -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-RET
+// CHECK-RET: "-mllvm" "-x86-align-branch=ret"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=indirect -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-INDIRECT
+// CHECK-INDIRECT: "-mllvm" "-x86-align-branch=indirect"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=fused+jcc+jmp+ret+call+indirect -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-BRANCH
+// CHECK-BRANCH: "-mllvm" "-x86-align-branch=fused+jcc+jmp+ret+call+indirect"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch-prefix-size=5 -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-PREFIX
+// CHECK-PREFIX: "-mllvm" "-x86-align-branch-prefix-size=5"
+//
+// RUN: %clang -target x86_64-unknown-unknown -mbranches-within-32B-boundaries -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-TOTAL
+// CHECK-TOTAL: "-mllvm" "-x86-branches-within-32B-boundaries"
+//
+// RUN: %clang -target x86_64-unknown-unknown -mno-branches-within-32B-boundaries -mbranches-within-32B-boundaries -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-TOTAL2
+// CHECK-TOTAL2: "-mllvm" "-x86-branches-within-32B-boundaries"
+// RUN: %clang -target x86_64-unknown-unknown -mbranches-within-32B-boundaries -mno-branches-within-32B-boundaries -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-TOTAL3
+// CHECK-TOTAL3-NOT: "-mllvm" "-x86-branches-within-32B-boundaries"

clang/test/Driver/intel-align-branch.s

+// RUN: %clang -target x86_64-unknown-unknown -malign-branch-boundary=32 -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-BOUNDARY
+// CHECK-BOUNDARY: "-mllvm" "-x86-align-branch-boundary=32"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=jcc -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-JCC
+// CHECK-JCC: "-mllvm" "-x86-align-branch=jcc"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=fused -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-FUSED
+// CHECK-FUSED: "-mllvm" "-x86-align-branch=fused"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=jmp -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-JMP
+// CHECK-JMP: "-mllvm" "-x86-align-branch=jmp"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=call -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-CALL
+// CHECK-CALL: "-mllvm" "-x86-align-branch=call"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=ret -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-RET
+// CHECK-RET: "-mllvm" "-x86-align-branch=ret"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=indirect -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-INDIRECT
+// CHECK-INDIRECT: "-mllvm" "-x86-align-branch=indirect"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch=fused+jcc+jmp+ret+call+indirect -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-BRANCH
+// CHECK-BRANCH: "-mllvm" "-x86-align-branch=fused+jcc+jmp+ret+call+indirect"
+//
+// RUN: %clang -target x86_64-unknown-unknown -malign-branch-prefix-size=5 -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-PREFIX
+// CHECK-PREFIX: "-mllvm" "-x86-align-branch-prefix-size=5"
+//
+// RUN: %clang -target x86_64-unknown-unknown -mbranches-within-32B-boundaries -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-TOTAL
+// CHECK-TOTAL: "-mllvm" "-x86-branches-within-32B-boundaries"
+//
+// RUN: %clang -target x86_64-unknown-unknown -mno-branches-within-32B-boundaries -mbranches-within-32B-boundaries -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-TOTAL2
+// CHECK-TOTAL2: "-mllvm" "-x86-branches-within-32B-boundaries"
+// RUN: %clang -target x86_64-unknown-unknown -mbranches-within-32B-boundaries -mno-branches-within-32B-boundaries -### -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-TOTAL3
+// CHECK-TOTAL3-NOT: "-mllvm" "-x86-branches-within-32B-boundaries"

llvm/include/llvm/MC/MCAsmBackend.h

 
 public:
   MCAsmBackend(const MCAsmBackend &) = delete;
   MCAsmBackend &operator=(const MCAsmBackend &) = delete;
   virtual ~MCAsmBackend();
 
   const support::endianness Endian;
 
+  virtual void alignBranchesBegin(MCObjectStreamer &OS, const MCInst &Inst) {}
+  virtual void alignBranchesEnd(MCObjectStreamer &OS, const MCInst &Inst) {}
+
   /// lifetime management
   virtual void reset() {}
 
   /// Create a new MCObjectWriter instance for use by the assembler backend to
   /// emit the final object file.
   std::unique_ptr<MCObjectWriter>
   createObjectWriter(raw_pwrite_stream &OS) const;
 
public:
   virtual unsigned getMinimumNopSize() const { return 1; }
 
   /// Write an (optimal) nop sequence of Count bytes to the given output. If the
   /// target cannot generate such a sequence, it should return an error.
   ///
   /// \return - True on success.
   virtual bool writeNopData(raw_ostream &OS, uint64_t Count) const = 0;
 
+  /// Write a segment prefix sequence of Count bytes to the given output.
+  ///
+  /// \return - True on success.
+  virtual bool writeSegmentPrefixData(raw_ostream &OS, uint64_t Count,
+                                      char Prefix) const {
+    return true;
+  }
+
   /// Give backend an opportunity to finish layout after relaxation
   virtual void finishLayout(MCAssembler const &Asm,
                             MCAsmLayout &Layout) const {}
 
   /// Handle any target-specific assembler flags. By default, do nothing.
   virtual void handleAssemblerFlag(MCAssemblerFlag Flag) {}
 
   /// Generate the compact unwind encoding for the CFI instructions.

llvm/include/llvm/MC/MCAssembler.h

private:
   unsigned ELFHeaderEFlags;
 
   /// Used to communicate Linker Optimization Hint information between
   /// the Streamer and the .o writer
   MCLOHContainer LOHContainer;
 
   VersionInfoType VersionInfo;
 
+  /// A lookup table from fragments to no-variable symbols, whose offset is 0.
+  /// This table is empty if there is no branch to be aligned.
+  //
+  // FIXME: We really would like this in target specific code rather than here.
+  mutable DenseMap<const MCFragment *, std::vector<const MCSymbol *>>
+      DefiningSymbolMap;
+
   /// Evaluate a fixup to a relocatable expression and the value which should be
   /// placed into the fixup.
   ///
   /// \param Layout The layout to use for evaluation.
   /// \param Fixup The fixup to evaluate.
   /// \param DF The fragment the fixup is inside.
   /// \param Target [out] On return, the relocatable expression the fixup
   /// evaluates to.
private:
   /// Perform one layout iteration and return true if any offsets
   /// were adjusted.
   bool layoutOnce(MCAsmLayout &Layout);
 
   /// Perform one layout iteration of the given section and return true
   /// if any offsets were adjusted.
   bool layoutSectionOnce(MCAsmLayout &Layout, MCSection &Sec);
 
+  /// Scan the symbol table to update the lookup table from fragments to
+  /// no-variable symbols, whose offset is 0.
+  void updateSymbolMap() const;
+
+  /// Move symbol from the fragment Src to fragment Dst to avoid instructions
+  /// jump to the internal of an instruction.
+  void moveSymbol(const MCFragment *Src, MCFragment *Dst) const;
+
   bool relaxInstruction(MCAsmLayout &Layout, MCRelaxableFragment &IF);
 
   bool relaxPaddingFragment(MCAsmLayout &Layout, MCPaddingFragment &PF);
 
   bool relaxLEB(MCAsmLayout &Layout, MCLEBFragment &IF);
-
+  bool relaxMachineDependent(MCAsmLayout &Layout,
+                             MCMachineDependentFragment &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_MachineDependent,
     FT_Padding,
     FT_SymbolId,
     FT_CVInlineLines,
     FT_CVDefRange,
     FT_Dummy
   };
 
 private:
public:
   StringRef getFixedSizePortion() const { return FixedSizePortion; }
   /// @}
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_CVDefRange;
   }
 };
 
+class MCMachineDependentFragment : public MCFragment {
+public:
+  enum SubType : uint8_t {
+    // BranchPadding - The variable size frag to insert NOP before branch.
+    BranchPadding,
+    // BranchPrefix - The variable size frag to insert segment prefixes to an
+    // instruction.
+    BranchPrefix,
+    // BranchSplit - The 0 size frag to separate the instruction
+    // which is fused with the following conditional jump from fused jcc
+    BranchSplit,
+    // FusedJccPadding - The variable size frag to insert NOP before fused
+    // conditional jump.
+    FusedJccPadding
+  };
+
+  // AlignBoundarySize - The size of the boundary, within which the branches
+  // need to be aligned.
+  static unsigned AlignBoundarySize;
+  // AlignMaxPrefixSize - The maximum size of prefixes per instruction.
+  static unsigned AlignMaxPrefixSize;
+  // SubKind - The subtype of this fragment.
+  mutable SubType SubKind;
+
+private:
+  // Size - The size of the MCMachineDependentFragment.
+  unsigned Size = 0;
+  // Prefix - The value of the prefix to be emited if the subtype of this
+  // fragment is BranchPrefix.
+  char Prefix = 0;
+  // Branch - The fragment where the branch need to be aligned is.
+  const MCFragment *Branch = nullptr;
+  // ExistingSegmentPrefixSize - The size of existing segment prefixes of the
+  // first intruction in the next fragment.
+  unsigned ExistingSegmentPrefixSize = 0;
+
+public:
+  MCMachineDependentFragment(SubType SubKind, unsigned ExistingPrefixSize,
+                             MCSection *Sec = nullptr)
+      : MCFragment(FT_MachineDependent, false, Sec), SubKind(SubKind),
+        ExistingSegmentPrefixSize(ExistingPrefixSize) {}
+
+  StringRef getSubTypeName() const {
+    switch (SubKind) {
+    default:
+      llvm_unreachable("Unknown subtype of MCMachineDependentFragment");
+    case BranchPadding:
+      return "BranchPadding";
+    case BranchPrefix:
+      return "BranchPrefix";
+    case BranchSplit:
+      return "BranchSplit";
+    case FusedJccPadding:
+      return "FusedJccPadding";
+    }
+  }
+
+  void setSize(unsigned Value) {
+    assert(SubKind != BranchSplit &&
+           "Should not set the size of BranchSplit Fragment");
+    Size = Value;
+  }
+
+  uint64_t getSize() const { return Size; }
+
+  void setPrefix(char Value) {
+    assert(SubKind == BranchPrefix &&
+           "Unsupported subtype of MCMachineDependentFragment");
+    Prefix = Value;
+  }
+
+  char getPrefix() const {
+    assert(SubKind == BranchPrefix &&
+           "Unsupported subtype of MCMachineDependentFragment");
+    return Prefix;
+  }
+
+  unsigned getRemaingSegmentPrefix() const {
+    assert(SubKind == BranchPrefix &&
+           "Unsupported subtype of MCMachineDependentFragment");
+    return (AlignMaxPrefixSize >= ExistingSegmentPrefixSize)
+               ? (AlignMaxPrefixSize - ExistingSegmentPrefixSize)
+               : 0;
+  }
+
+  void setBranch(const MCFragment *Fragment) {
+    assert(SubKind != BranchSplit &&
+           "Unsupported subtype of MCMachineDependentFragment");
+    Branch = Fragment;
+  }
+
+  const MCFragment *getBranch() const {
+    assert(SubKind != BranchSplit &&
+           "Unsupported subtype of MCMachineDependentFragment");
+    return Branch;
+  }
+
+  static bool classof(const MCFragment *F) {
+    return F->getKind() == MCFragment::FT_MachineDependent;
+  }
+};
 } // end namespace llvm
 
 #endif // LLVM_MC_MCFRAGMENT_H

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_MachineDependent:
+    return cast<MCMachineDependentFragment>(F).getSize();
+
   case MCFragment::FT_Padding:
     return cast<MCPaddingFragment>(F).getSize();
 
   case MCFragment::FT_SymbolId:
     return 4;
 
   case MCFragment::FT_Align: {
     const MCAlignFragment &AF = cast<MCAlignFragment>(F);
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_MachineDependent: {
+    const MCMachineDependentFragment &MDF = cast<MCMachineDependentFragment>(F);
+    if (FragmentSize == 0)
+      break;
+    if (MDF.SubKind == MCMachineDependentFragment::BranchPrefix) {
+      if (!Asm.getBackend().writeSegmentPrefixData(OS, FragmentSize,
+                                                   MDF.getPrefix()))
+        report_fatal_error("unable to write segment prefix sequence of " +
+                           Twine(FragmentSize) + " bytes");
+    } else if (MDF.SubKind == MCMachineDependentFragment::BranchPadding ||
+               MDF.SubKind == MCMachineDependentFragment::FusedJccPadding) {
+      if (!Asm.getBackend().writeNopData(OS, FragmentSize))
+        report_fatal_error("unable to write nop sequence of " +
+                           Twine(FragmentSize) + " bytes");
+    }
+    break;
+  }
+
   case MCFragment::FT_Padding: {
     if (!Asm.getBackend().writeNopData(OS, FragmentSize))
       report_fatal_error("unable to write nop sequence of " +
                          Twine(FragmentSize) + " bytes");
     break;
   }
 
   case MCFragment::FT_SymbolId: {
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();
 }
 
+/// getFixedValue - Get the total size of the MachineDependentFragments from
+/// the fragment operand to the fragment where the target branch is.
+static unsigned getFixedValue(const MCMachineDependentFragment *MF) {
+  unsigned FixValue = 0;
+  const MCFragment *CurrFragment = MF;
+  const MCFragment *const BranchFragment = MF->getBranch();
+  while (CurrFragment && CurrFragment != BranchFragment) {
+    if (auto *MCF =
+            dyn_cast_or_null<MCMachineDependentFragment>(CurrFragment)) {
+      FixValue += MCF->getSize();
+    }
+    CurrFragment = CurrFragment->getNextNode();
+  }
+  return FixValue;
+}
+
+/// mayCrossBoundary - Check if the branch with given address and size crosses
+/// the boundary.
+static bool mayCrossBoundary(unsigned StartAddr, unsigned Size) {
+  unsigned EndAddr = StartAddr + Size;
+  return StartAddr / MCMachineDependentFragment::AlignBoundarySize !=
+         ((EndAddr - 1) / MCMachineDependentFragment::AlignBoundarySize);
+}
+
+/// isAgainstBoundary - Check if the branch with given address and size is
+/// against the boundary.
+static bool isAgainstBoundary(unsigned StartAddr, unsigned Size) {
+  unsigned EndAddr = StartAddr + Size;
+  return EndAddr % MCMachineDependentFragment::AlignBoundarySize == 0;
+}
+
+/// needPadding - Check if the branch with given address and size needs padding.
+static bool needPadding(unsigned StartAddr, unsigned Size) {
+  return mayCrossBoundary(StartAddr, Size) ||
+         isAgainstBoundary(StartAddr, Size);
+}
+
+///  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) {
+  return MCMachineDependentFragment::AlignBoundarySize -
+         (StartAddr % MCMachineDependentFragment::AlignBoundarySize);
+}
+
+/// getInstSize - Get the size of encoded instruction in the fragment.
+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();
+  }
+}
+
+/// If prefixes are inserted before an instruction, the symbol must be move
+/// to the beginning of the prefixes. There are two reasons for this. First,
+/// When prefixes are inserted before the first instruction of the .text
+/// section, the prefixes would appear in front of the .text if the symbol .text
+/// was not moved, which was obviously wrong. Second, the instruction would have
+/// two entry points, one is the beginning of prefixes when falled through, one
+/// is the address of the symbol, which would casuse performance regression.
+void MCAssembler::moveSymbol(const MCFragment *Src, MCFragment *Dst) const {
+  if (!(Src && Dst && Dst->getKind() == MCFragment::FT_MachineDependent))
+    return;
+  updateSymbolMap();
+  for (auto *Symb : DefiningSymbolMap[Src]) {
+    Symb->setFragment(Dst);
+  }
+  return;
+}
+
+void MCAssembler::updateSymbolMap() const {
+  if(!DefiningSymbolMap.empty()) return;
+  for (const MCSymbol &Symbol : symbols()) {
+    if (Symbol.isInSection() && !Symbol.isVariable() &&
+        Symbol.getOffset() == 0) {
+      DefiningSymbolMap[Symbol.getFragment()].push_back(&Symbol);
+    }
+  }
+  return;
+}
+
+bool MCAssembler::relaxMachineDependent(MCAsmLayout &Layout,
+                                        MCMachineDependentFragment &MF) {
+  // BranchSplit fragment should not relax since it is a zero-size fragment.
+  // The MCMachineDependentFragment which doesn't has a target branch to be
+  // aligned should not relax either.
+  if (MF.SubKind == MCMachineDependentFragment::BranchSplit || !MF.getBranch())
+    return false;
+  unsigned OldSize = MF.getSize();
+  const MCFragment *BranchFragment = MF.getBranch();
+  for (MCFragment *F = &MF; F != BranchFragment; F = F->getNextNode()) {
+    if (F->getKind() != MCFragment::FT_Data &&
+        F->getKind() != MCFragment::FT_MachineDependent &&
+        F->getKind() != MCFragment::FT_Relaxable &&
+        F->getKind() != MCFragment::FT_CompactEncodedInst) {
+      return false;
+    }
+  }
+  const MCMachineDependentFragment *HintFragment =
+      cast<MCMachineDependentFragment>(BranchFragment->getPrevNode());
+  unsigned AlignedSize = getInstSize(*BranchFragment);
+  unsigned AlignedOffset = Layout.getFragmentOffset(BranchFragment);
+  // If the branch is macro-fused, it's address and size need to be fixed.
+  if (HintFragment->SubKind == MCMachineDependentFragment::BranchSplit) {
+    unsigned CmpSize = getInstSize(*(HintFragment->getPrevNode()));
+    AlignedSize += CmpSize;
+    AlignedOffset -= CmpSize;
+  }
+  unsigned FixedValue = getFixedValue(&MF);
+  AlignedOffset -= FixedValue;
+  unsigned NewSize = 0;
+  if (needPadding(AlignedOffset, AlignedSize)) {
+    NewSize = getPaddingSize(AlignedOffset);
+  }
+  if (MF.SubKind == MCMachineDependentFragment::BranchPrefix) {
+    unsigned NextFragmentSize = getInstSize(*(MF.getNextNode()));
+    // If there is hard-coded assembly code, the size of the fragment may
+    // exceed 15. Prefixed shouldn't be inserted in this condition since the
+    // length of first instruction in the fragment is unknown.
+    if (NextFragmentSize >= 15)
+      NewSize = 0;
+    else {
+      NewSize = std::min(
+          {NewSize, 15 - NextFragmentSize, MF.getRemaingSegmentPrefix()});
+    }
+  }
+  if (NewSize != OldSize) {
+    MF.setSize(NewSize);
+    if (OldSize == 0) {
+      moveSymbol(MF.getNextNode(), &MF);
+    }
+    Layout.invalidateFragmentsFrom(&MF);
+    return true;
+  } else {
+    return false;
+  }
+}
+
 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_MachineDependent:
+      RelaxedFrag =
+          relaxMachineDependent(Layout, *cast<MCMachineDependentFragment>(I));
+      break;
     case MCFragment::FT_Padding:
       RelaxedFrag = relaxPaddingFragment(Layout, *cast<MCPaddingFragment>(I));
       break;
     case MCFragment::FT_CVInlineLines:
       RelaxedFrag =
           relaxCVInlineLineTable(Layout, *cast<MCCVInlineLineTableFragment>(I));
       break;
     case MCFragment::FT_CVDefRange:

llvm/lib/MC/MCFragment.cpp

 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
 #include <utility>
 
 using namespace llvm;
+unsigned MCMachineDependentFragment::AlignBoundarySize = 0;
+unsigned MCMachineDependentFragment::AlignMaxPrefixSize = 0;
 
 MCAsmLayout::MCAsmLayout(MCAssembler &Asm) : Assembler(Asm) {
   // Compute the section layout order. Virtual sections must go last.
   for (MCSection &Sec : Asm)
     if (!Sec.isVirtualSection())
       SectionOrder.push_back(&Sec);
   for (MCSection &Sec : Asm)
     if (Sec.isVirtualSection())
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_MachineDependent:
+      delete cast<MCMachineDependentFragment>(this);
+      return;
     case FT_Padding:
       delete cast<MCPaddingFragment>(this);
       return;
     case FT_SymbolId:
       delete cast<MCSymbolIdFragment>(this);
       return;
     case FT_CVInlineLines:
       delete cast<MCCVInlineLineTableFragment>(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_MachineDependent: OS<<"MCMachineDependentFragment"; break;
   case MCFragment::FT_Padding: OS << "MCPaddingFragment"; 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
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_MachineDependent: {
+    const MCMachineDependentFragment *MF =
+        cast<MCMachineDependentFragment>(this);
+    OS << "\n       ";
+    OS << " Subtype:" << MF->getSubTypeName() << " Size:" << MF->getSize();
+    break;
+  }
   case MCFragment::FT_Padding: {
     const MCPaddingFragment *F = cast<MCPaddingFragment>(this);
     OS << "\n       ";
     OS << " PaddingPoliciesMask:" << F->getPaddingPoliciesMask()
        << " IsInsertionPoint:" << F->isInsertionPoint()
        << " Size:" << F->getSize();
     OS << "\n       ";
     OS << " Inst:";

llvm/lib/MC/MCObjectStreamer.cpp

 
 bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
   return Sec.hasInstructions();
 }
 
 void MCObjectStreamer::EmitInstruction(const MCInst &Inst,
                                        const MCSubtargetInfo &STI) {
   getAssembler().getBackend().handleCodePaddingInstructionBegin(Inst);
+  getAssembler().getBackend().alignBranchesBegin(*this, Inst);
   EmitInstructionImpl(Inst, STI);
+  getAssembler().getBackend().alignBranchesEnd(*this, Inst);
   getAssembler().getBackend().handleCodePaddingInstructionEnd(Inst);
 }
 
 void MCObjectStreamer::EmitInstructionImpl(const MCInst &Inst,
                                            const MCSubtargetInfo &STI) {
   MCStreamer::EmitInstruction(Inst, STI);
 
   MCSection *Sec = getCurrentSectionOnly();

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCFixupKindInfo.h"
 #include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCMachObjectWriter.h"
+#include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/TargetRegistry.h"
+
 using namespace llvm;
 
 static unsigned getFixupKindSize(unsigned Kind) {
   switch (Kind) {
   default:
     llvm_unreachable("invalid fixup kind!");
   case FK_NONE:
     return 0;
static unsigned getFixupKindSize(unsigned Kind) {
   case FK_SecRel_8:
   case FK_Data_8:
   case X86::reloc_global_offset_table8:
     return 8;
   }
 }
 
 namespace {
+class X86AlignBranchKind {
+private:
+  uint8_t AlignBranchKind = 0;
+
+public:
+  enum Flag : uint8_t {
+    AlignBranchNone = 0,
+    AlignBranchFused = 1U << 0,
+    AlignBranchJcc = 1U << 1,
+    AlignBranchJmp = 1U << 2,
+    AlignBranchCall = 1U << 3,
+    AlignBranchRet = 1U << 4,
+    AlignBranchIndirect = 1U << 5
+  };
+
+  void operator=(const std::string &Val) {
+    if (Val.empty())
+      return;
+    SmallVector<StringRef, 6> BranchTypes;
+    StringRef(Val).split(BranchTypes, '+', -1, false);
+    for (auto BranchType : BranchTypes) {
+      if (BranchType == "fused")
+        addKind(AlignBranchFused);
+      else if (BranchType == "jcc")
+        addKind(AlignBranchJcc);
+      else if (BranchType == "jmp")
+        addKind(AlignBranchJmp);
+      else if (BranchType == "call")
+        addKind(AlignBranchCall);
+      else if (BranchType == "ret")
+        addKind(AlignBranchRet);
+      else if (BranchType == "indirect")
+        addKind(AlignBranchIndirect);
+    }
+  }
+
+  operator uint8_t() const { return AlignBranchKind; }
+  void addKind(Flag Value) { AlignBranchKind |= Value; }
+};
+
+X86AlignBranchKind X86AlignBranchKindLoc;
+
+cl::opt<unsigned> X86AlignBranchBoundary(
+    "x86-align-branch-boundary", cl::init(0), cl::Hidden,
+    cl::desc("Control how the assembler should align branches with segment "
+             "prefixes or NOP. The boundary's size must be a power of 2. It "
+             "should be 0 or no less than 32. Branches will be aligned within "
+             "the boundary of specifies size. -x86-align-branch-boundary=0 "
+             "doesn't align branches."));
+
+cl::opt<X86AlignBranchKind, true, cl::parser<std::string>> X86AlignBranch(
+    "x86-align-branch",
+    cl::desc("Specify types of branches to align (plus separated list of "
+             "types). The branches's types is combination of jcc, fused, "
+             "jmp, call, ret, indirect."),
+    cl::Hidden,
+    cl::value_desc(
+        "jcc, which aligns conditional jumps; fused, which aligns fused "
+        "conditional jumps; jmp, which aligns unconditional jumps; call, "
+        "which aligns calls; ret, which aligns rets; indirect, which "
+        "aligns indirect jumps."),
+    cl::location(X86AlignBranchKindLoc));
+
+cl::opt<unsigned> X86AlignBranchPrefixSize(
+    "x86-align-branch-prefix-size", cl::init(0), cl::Hidden,
+    cl::desc("Specify the maximum number of prefixes on an instruction to "
+             "align branches. The number should be between 0 and 5."));
+
+cl::opt<bool> X86AlignBranchWithin32BBoundaries(
+    "x86-branches-within-32B-boundaries", cl::init(false),
+    cl::desc(
+        "Aligns conditional jumps, fused conditional jumps, and unconditional "
+        "jumps within 32 byte boundary with up to 5 segment prefixes on an "
+        "instruction. It is equivalent to -x86-align-branch-boundary=32, "
+        "-x86-align-branch=fused+jcc+jmp, -x86-align-branch-prefix-size=5."));
 
 class X86ELFObjectWriter : public MCELFObjectTargetWriter {
 public:
   X86ELFObjectWriter(bool is64Bit, uint8_t OSABI, uint16_t EMachine,
                      bool HasRelocationAddend, bool foobar)
     : MCELFObjectTargetWriter(is64Bit, OSABI, EMachine, HasRelocationAddend) {}
 };
 
 class X86AsmBackend : public MCAsmBackend {
   const MCSubtargetInfo &STI;
+  const MCInstrInfo &MCII;
+  X86AlignBranchKind AlignBranchType;
+  unsigned AlignBoundarySize = 0;
+  unsigned AlignMaxPrefixSize = 0;
+
+  bool isTLSCall(const MCInst &MI) const;
+  bool isFirstMacroFusibleInst(const MCInst &Inst) const;
+  bool isMacroFused(const MCInst &Cmp, const MCInst &Jcc) const;
+  char choosePrefixValue(const MCInst &MI) const;
+  unsigned getSegmentPrefixSize(const MCInst &MI) const;
+  bool isRIPRelative(const MCInst &MI) const;
+
+  bool needAlign(const MCAssembler &Assembler, MCSection *Sec) const;
+  bool needAlignInst(const MCInst &Inst) const;
+  bool shouldAddPrefix(const MCInst& Inst) const;
+  std::vector<MCMachineDependentFragment *> PendingAlignmentFragments;
+  MCInst PrevInst;
+
 public:
   X86AsmBackend(const Target &T, const MCSubtargetInfo &STI)
-      : MCAsmBackend(support::little), STI(STI) {}
+      : MCAsmBackend(support::little), STI(STI),
+        MCII(*(T.createMCInstrInfo())) {
+    if (X86AlignBranchWithin32BBoundaries) {
+      AlignBoundarySize = 32;
+      AlignBranchType.addKind(X86AlignBranchKind::AlignBranchFused);
+      AlignBranchType.addKind(X86AlignBranchKind::AlignBranchJcc);
+      AlignBranchType.addKind(X86AlignBranchKind::AlignBranchJmp);
+      AlignMaxPrefixSize = 5;
+    } else {
+      AlignBoundarySize = X86AlignBranchBoundary;
+      AlignBranchType = X86AlignBranchKindLoc;
+      AlignMaxPrefixSize = X86AlignBranchPrefixSize;
+    }
+    MCMachineDependentFragment::AlignBoundarySize = AlignBoundarySize;
+    MCMachineDependentFragment::AlignMaxPrefixSize = AlignMaxPrefixSize;
+  }
+
+  void alignBranchesBegin(MCObjectStreamer &OS, const MCInst &Inst) override;
+  void alignBranchesEnd(MCObjectStreamer &OS, const MCInst &Inst) override;
 
   unsigned getNumFixupKinds() const override {
     return X86::NumTargetFixupKinds;
   }
 
   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
 
   const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override {
     const static MCFixupKindInfo Infos[X86::NumTargetFixupKinds] = {
public:
   bool fixupNeedsRelaxation(const MCFixup &Fixup, uint64_t Value,
                             const MCRelaxableFragment *DF,
                             const MCAsmLayout &Layout) const override;
 
   void relaxInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
                         MCInst &Res) const override;
 
   bool writeNopData(raw_ostream &OS, uint64_t Count) const override;
+  bool writeSegmentPrefixData(raw_ostream &OS, uint64_t Count,
+                              char Prefix) const override;
 };
 } // end anonymous namespace
 
 static unsigned getRelaxedOpcodeBranch(const MCInst &Inst, bool is16BitMode) {
   unsigned Op = Inst.getOpcode();
   switch (Op) {
   default:
     return Op;

 
 static unsigned getRelaxedOpcode(const MCInst &Inst, bool is16BitMode) {
   unsigned R = getRelaxedOpcodeArith(Inst);
   if (R != Inst.getOpcode())
     return R;
   return getRelaxedOpcodeBranch(Inst, is16BitMode);
 }
 
+static X86::CondCode getCondFromBranch(const MCInst &MI,
+                                       const MCInstrInfo &MCII) {
+  unsigned Opcode = MI.getOpcode();
+  switch (Opcode) {
+  default:
+    return X86::COND_INVALID;
+  case X86::JCC_1: {
+    const MCInstrDesc &Desc = MCII.get(Opcode);
+    return static_cast<X86::CondCode>(
+        MI.getOperand(Desc.getNumOperands() - 1).getImm());
+  }
+  }
+}
+
+static X86::SecondMacroFusionInstKind
+classifySecondInstInMacroFusion(const MCInst &MI, const MCInstrInfo &MCII) {
+  X86::CondCode CC = getCondFromBranch(MI, MCII);
+  return classifySecondCondCodeInMacroFusion(CC);
+}
+
+bool X86AsmBackend::isTLSCall(const MCInst &MI) const {
+  const MCInstrDesc &InstDesc = MCII.get(MI.getOpcode());
+  if (!InstDesc.isCall())
+    return false;
+  for (auto &Operand : MI) {
+    if (Operand.isExpr()) {
+      StringRef SymbolName =
+          cast<MCSymbolRefExpr>(*Operand.getExpr()).getSymbol().getName();
+      if (SymbolName.contains("__tls_get_addr"))
+        return true;
+    }
+  }
+  return false;
+}
+
+/// isFirstMacroFusibleInst - Check if the instruction is valid as the first
+/// instruction in macro fusion.
+bool X86AsmBackend::isFirstMacroFusibleInst(const MCInst &Inst) const {
+  // An Intel instruction with RIP relative addressing is not macro fusible.
+  if (isRIPRelative(Inst))
+    return false;
+  X86::FirstMacroFusionInstKind FIK =
+      X86::classifyFirstOpcodeInMacroFusion(Inst.getOpcode());
+  return FIK != X86::FirstMacroFusionInstKind::Invalid;
+}
+
+/// isMacroFused - Check if the two instructions are macro-fused.
+bool X86AsmBackend::isMacroFused(const MCInst &Cmp, const MCInst &Jcc) const {
+  const MCInstrDesc &InstDesc = MCII.get(Jcc.getOpcode());
+  if (!InstDesc.isConditionalBranch())
+    return false;
+  if (!isFirstMacroFusibleInst(Cmp))
+    return false;
+  const X86::FirstMacroFusionInstKind CmpKind =
+      X86::classifyFirstOpcodeInMacroFusion(Cmp.getOpcode());
+  const X86::SecondMacroFusionInstKind BranchKind =
+      classifySecondInstInMacroFusion(Jcc, MCII);
+  return X86::isMacroFused(CmpKind, BranchKind);
+}
+
+/// choosePrefixValue - Choose which prefix should be inserted before the
+/// instruction. The choice of prefixes are:
+///  a. Use the existing segment prefix if there is one.
+///  b. Use CS segment prefix in 64-bit mode.
+///  c. In 32-bit mode, use SS segment prefix with ESP/EBP base register and use
+///     DS segment prefix without ESP/EBP base register.
+char X86AsmBackend::choosePrefixValue(const MCInst &MI) const {
+  for (const auto &Operand : MI) {
+    if (Operand.isReg())
+      switch (Operand.getReg()) {
+      default:
+        break;
+      case X86::CS:
+        return 0x2e;
+      case X86::SS:
+        return 0x36;
+      case X86::DS:
+        return 0x3e;
+      case X86::ES:
+        return 0x26;
+      case X86::FS:
+        return 0x64;
+      case X86::GS:
+        return 0x65;
+      }
+  }
+  if (STI.getFeatureBits()[X86::Mode64Bit])
+    return 0x2e;
+
+  unsigned Opcode = MI.getOpcode();
+  const MCInstrDesc &Desc = MCII.get(Opcode);
+  uint64_t TSFlags = Desc.TSFlags;
+  int MemoryOperand = X86II::getMemoryOperandNo(TSFlags);
+  if (MemoryOperand >= 0) {
+    unsigned CurOp = X86II::getOperandBias(Desc);
+    unsigned BaseRegNum = MemoryOperand + CurOp + X86::AddrBaseReg;
+    unsigned BaseReg = MI.getOperand(BaseRegNum).getReg();
+    if (BaseReg == X86::ESP || BaseReg == X86::EBP)
+      return 0x36;
+  }
+  return 0x3e;
+}
+
+/// getSegmentPrefixSize - Count the existing segment prefixes of the
+/// instruction.
+unsigned X86AsmBackend::getSegmentPrefixSize(const MCInst &MI) const {
+  unsigned Size = 0;
+  for (const auto &Operand : MI) {
+    if (Operand.isReg()) {
+      unsigned Reg = Operand.getReg();
+      if (Reg == X86::CS || Reg == X86::SS || Reg == X86::DS ||
+          Reg == X86::ES || Reg == X86::FS || Reg == X86::GS)
+        ++Size;
+    }
+  }
+  return Size;
+}
+
+/// isRIPRelative - Check if the instruction operand is RIP relative addressing.
+bool X86AsmBackend::isRIPRelative(const MCInst &MI) const {
+  unsigned Opcode = MI.getOpcode();
+  const MCInstrDesc &Desc = MCII.get(Opcode);
+  uint64_t TSFlags = Desc.TSFlags;
+  unsigned CurOp = X86II::getOperandBias(Desc);
+  int MemoryOperand = X86II::getMemoryOperandNo(TSFlags);
+  if (MemoryOperand >= 0) {
+    unsigned BaseRegNum = MemoryOperand + CurOp + X86::AddrBaseReg;
+    unsigned BaseReg = MI.getOperand(BaseRegNum).getReg();
+    if (BaseReg == X86::RIP)
+      return true;
+  }
+  return false;
+}
+
+bool X86AsmBackend::needAlign(const MCAssembler &Assembler,
+                              MCSection *Sec) const {
+  // To be Done: Currently don't deal with Bundle cases.
+  if (Assembler.isBundlingEnabled() && Sec->isBundleLocked())
+    return false;
+
+  if (!(STI.getFeatureBits()[X86::Mode64Bit] ||
+        STI.getFeatureBits()[X86::Mode32Bit]))
+    return false;
+  return AlignBoundarySize != 0 &&
+         AlignBranchType != X86AlignBranchKind::AlignBranchNone;
+}
+
+/// needAlignInst - Check if the instruction operand needs to be aligned.
+/// Padding is disabled before tls_get_addr calls to keep TLS instruction
+/// sequence unchanged.
+bool X86AsmBackend::needAlignInst(const MCInst &Inst) const {
+  const MCInstrDesc &InstDesc = MCII.get(Inst.getOpcode());
+  return (InstDesc.isConditionalBranch() &&
+          (AlignBranchType & X86AlignBranchKind::AlignBranchJcc)) ||
+         (InstDesc.isUnconditionalBranch() &&
+          (AlignBranchType & X86AlignBranchKind::AlignBranchJmp)) ||
+         (InstDesc.isCall() && !isTLSCall(Inst) &&
+          (AlignBranchType & X86AlignBranchKind::AlignBranchCall)) ||
+         (InstDesc.isReturn() &&
+          (AlignBranchType & X86AlignBranchKind::AlignBranchRet)) ||
+         (InstDesc.isIndirectBranch() &&
+          (AlignBranchType & X86AlignBranchKind::AlignBranchIndirect));
+}
+
+// The longer the instruction, the easier it is to cross 32-Byte boundary. So
+// prefixes should not be inserted before branch, call or ret even if these
+// instructions are not asked to be aligned.
+bool X86AsmBackend::shouldAddPrefix(const MCInst &Inst) const {
+  const MCInstrDesc &InstDesc = MCII.get(Inst.getOpcode());
+  return !(InstDesc.isBranch() || InstDesc.isCall() || InstDesc.isReturn());
+}
+
+/// alignBranchesBegin - Insert MCMachineDependentFragment before instructions
+/// to align branches.
+void X86AsmBackend::alignBranchesBegin(MCObjectStreamer &OS,
+                                       const MCInst &Inst) {
+  MCAssembler &Assembler = OS.getAssembler();
+  MCSection *Sec = OS.getCurrentSectionOnly();
+
+  if (!needAlign(Assembler, Sec))
+    return;
+
+  MCFragment *CF = OS.getCurrentFragment();
+  MCFragment *PF = CF ? CF->getPrevNode() : nullptr;
+  bool IsPFFusedJccPadding = isa_and_nonnull<MCMachineDependentFragment>(PF) &&
+                             cast<MCMachineDependentFragment>(PF)->SubKind ==
+                                 MCMachineDependentFragment::FusedJccPadding;
+  bool IsFused = isMacroFused(PrevInst, Inst);
+  if (IsPFFusedJccPadding && !IsFused) {
+    // Turn the previous FusedJccPadding into BranchPrefix if the instruction is
+    // not macro fused indeed.
+    cast<MCMachineDependentFragment>(PF)->SubKind =
+        MCMachineDependentFragment::BranchPrefix;
+    cast<MCMachineDependentFragment>(PF)->setPrefix(
+        choosePrefixValue(PrevInst));
+  }
+  unsigned SegmentPrefixSize = getSegmentPrefixSize(Inst);
+  if (isFirstMacroFusibleInst(Inst) &&
+      (AlignBranchType & X86AlignBranchKind::AlignBranchFused)) {
+    // Insert FusedJccPadding if the instruction to be emitted is valid as
+    // first instruction in macro fusion. The inserted FusedJccPadding will
+    // turn to BranchPrefix later if the instruction is not macro fused indeed.
+    OS.insert(new MCMachineDependentFragment(
+        MCMachineDependentFragment::FusedJccPadding, SegmentPrefixSize));
+  } else if (IsPFFusedJccPadding && IsFused) {
+    // Insert BranchSplit between the first intruction in macro fusion and
+    // the second instruction in macro fusion.
+    OS.insert(new MCMachineDependentFragment(
+        MCMachineDependentFragment::BranchSplit, SegmentPrefixSize));
+  } else if (needAlignInst(Inst)) {
+    // Insert BranchPadding before the instruction need to be aligned.
+    OS.insert(new MCMachineDependentFragment(
+        MCMachineDependentFragment::BranchPadding, SegmentPrefixSize));
+  } else {
+    // Insert BranchPrefix to align the next branch.
+    OS.insert(new MCMachineDependentFragment(
+        MCMachineDependentFragment::BranchPrefix, SegmentPrefixSize));
+  }
+  MCMachineDependentFragment *NewCF =
+      cast<MCMachineDependentFragment>(OS.getCurrentFragment());
+  auto Kind = NewCF->SubKind;
+  if (Kind != MCMachineDependentFragment::BranchSplit) {
+    if (Kind == MCMachineDependentFragment::BranchPrefix) {
+      // Choose the value of the prefix by the instruction to be emited.
+      NewCF->setPrefix(choosePrefixValue(Inst));
+    }
+    if (Kind != MCMachineDependentFragment::BranchPrefix ||
+        shouldAddPrefix(Inst)) {
+      // Pend the BranchPrefix, BranchPadding and FusedJccPadding since we
+      // haven't known the fragment where the next branch is yet.
+      PendingAlignmentFragments.push_back(NewCF);
+    }
+  }
+  PrevInst = Inst;
+  return;
+}
+
+/// alignBranchesEnd - Set the target branches for BranchPrefix, BranchPadding
+/// and FusedJccPadding.
+void X86AsmBackend::alignBranchesEnd(MCObjectStreamer &OS, const MCInst &Inst) {
+  MCSection *Sec = OS.getCurrentSectionOnly();
+  MCAssembler &Assembler = OS.getAssembler();
+  if (!needAlign(Assembler, Sec))
+    return;
+  if (!needAlignInst(Inst))
+    return;
+  MCFragment *CF = OS.getCurrentFragment();
+  for (MCMachineDependentFragment *MDF : PendingAlignmentFragments) {
+    if (MDF->getParent() != Sec)
+      continue;
+    MDF->setBranch(CF);
+  }
+  PendingAlignmentFragments.clear();
+
+  // Update the maximum alignment on the current section if necessary.
+  if (AlignBoundarySize > Sec->getAlignment())
+    Sec->setAlignment(Align(AlignBoundarySize));
+}
+
 Optional<MCFixupKind> X86AsmBackend::getFixupKind(StringRef Name) const {
   if (STI.getTargetTriple().isOSBinFormatELF()) {
     if (STI.getTargetTriple().getArch() == Triple::x86_64) {
       if (Name == "R_X86_64_NONE")
         return FK_NONE;
     } else {
       if (Name == "R_386_NONE")
         return FK_NONE;
     }
   }
   return MCAsmBackend::getFixupKind(Name);
 }
 
 bool X86AsmBackend::shouldForceRelocation(const MCAssembler &,
                                           const MCFixup &Fixup,
                                           const MCValue &) {
   return Fixup.getKind() == FK_NONE;
 }
 
 bool X86AsmBackend::mayNeedRelaxation(const MCInst &Inst,
                                       const MCSubtargetInfo &STI) const {
   // Branches can always be relaxed in either mode.
   if (getRelaxedOpcodeBranch(Inst, false) != Inst.getOpcode())
if (RelaxedOp == Inst.getOpcode()) {
     OS << "\n";
     report_fatal_error("unexpected instruction to relax: " + OS.str());
   }
 
   Res = Inst;
   Res.setOpcode(RelaxedOp);
 }
 
+/// Write a sequence of segment prefixes to the output, covering \p Count
+/// bytes.
+/// \return - true on success, false on failure
+bool X86AsmBackend::writeSegmentPrefixData(raw_ostream &OS, uint64_t Count,
+                                    char Prefix) const {
+  // The function should only write segment prefixes.
+  // CS:0x2e, SS:0x36, DS:0x3e, ES:0x26, FS:0x64, GS:0x65
+  if (!(Prefix == 0x2e || Prefix == 0x36 || Prefix == 0x3e || Prefix == 0x26 ||
+        Prefix == 0x64 || Prefix == 0x65))
+    return false;
+  for (uint64_t i = 0; i < Count; ++i)
+    OS << Prefix;
+  return true;
+}
+
 /// Write a sequence of optimal nops to the output, covering \p Count
 /// bytes.
 /// \return - true on success, false on failure
 bool X86AsmBackend::writeNopData(raw_ostream &OS, uint64_t Count) const {
   static const char Nops[10][11] = {
     // nop
     "\x90",
     // xchg %ax,%ax

llvm/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

enum CondCode {
     // form a compound condition. They occur in code using FCMP_OEQ or FCMP_UNE,
     // which can't be represented on x86 with a single condition. These
     // are never used in MachineInstrs and are inverses of one another.
     COND_NE_OR_P,
     COND_E_AND_NP,
 
     COND_INVALID
   };
+
+  // The classification for the first instruction in macro fusion.
+  enum class FirstMacroFusionInstKind {
+    // TEST
+    Test,
+    // CMP
+    Cmp,
+    // AND
+    And,
+    // ADD, SUB
+    AddSub,
+    // INC, DEC
+    IncDec,
+    // Not valid as a first macro fusion instruction
+    Invalid
+  };
+
+  enum class SecondMacroFusionInstKind {
+    // JA, JB and variants.
+    AB,
+    // JE, JL, JG and variants.
+    ELG,
+    // JS, JP, JO and variants
+    SPO,
+    // Not a fusible jump.
+    Invalid,
+  };
+
+  /// classifyFirstOpcodeInMacroFusion - return the type of the first
+  /// instruction in macro-fusion.
+  inline FirstMacroFusionInstKind
+  classifyFirstOpcodeInMacroFusion(unsigned Opcode) {
+    switch (Opcode) {
+    default:
+      return FirstMacroFusionInstKind::Invalid;
+    // TEST
+    case X86::TEST16i16:
+    case X86::TEST16mr:
+    case X86::TEST16ri:
+    case X86::TEST16rr:
+    case X86::TEST32i32:
+    case X86::TEST32mr:
+    case X86::TEST32ri:
+    case X86::TEST32rr:
+    case X86::TEST64i32:
+    case X86::TEST64mr:
+    case X86::TEST64ri32:
+    case X86::TEST64rr:
+    case X86::TEST8i8:
+    case X86::TEST8mr:
+    case X86::TEST8ri:
+    case X86::TEST8rr:
+      return FirstMacroFusionInstKind::Test;
+    case X86::AND16i16:
+    case X86::AND16mr:
+    case X86::AND16ri:
+    case X86::AND16ri8:
+    case X86::AND16rm:
+    case X86::AND16rr:
+    case X86::AND16rr_REV:
+    case X86::AND32i32:
+    case X86::AND32mr:
+    case X86::AND32ri:
+    case X86::AND32ri8:
+    case X86::AND32rm:
+    case X86::AND32rr:
+    case X86::AND32rr_REV:
+    case X86::AND64i32:
+    case X86::AND64mr:
+    case X86::AND64ri32:
+    case X86::AND64ri8:
+    case X86::AND64rm:
+    case X86::AND64rr:
+    case X86::AND64rr_REV:
+    case X86::AND8i8:
+    case X86::AND8mr:
+    case X86::AND8ri:
+    case X86::AND8ri8:
+    case X86::AND8rm:
+    case X86::AND8rr:
+    case X86::AND8rr_REV:
+      return FirstMacroFusionInstKind::And;
+    // CMP
+    case X86::CMP16i16:
+    case X86::CMP16mr:
+    case X86::CMP16ri:
+    case X86::CMP16ri8:
+    case X86::CMP16rm:
+    case X86::CMP16rr:
+    case X86::CMP16rr_REV:
+    case X86::CMP32i32:
+    case X86::CMP32mr:
+    case X86::CMP32ri:
+    case X86::CMP32ri8:
+    case X86::CMP32rm:
+    case X86::CMP32rr:
+    case X86::CMP32rr_REV:
+    case X86::CMP64i32:
+    case X86::CMP64mr:
+    case X86::CMP64ri32:
+    case X86::CMP64ri8:
+    case X86::CMP64rm:
+    case X86::CMP64rr:
+    case X86::CMP64rr_REV:
+    case X86::CMP8i8:
+    case X86::CMP8mr:
+    case X86::CMP8ri:
+    case X86::CMP8ri8:
+    case X86::CMP8rm:
+    case X86::CMP8rr:
+    case X86::CMP8rr_REV:
+      return FirstMacroFusionInstKind::Cmp;
+    // ADD
+    case X86::ADD16i16:
+    case X86::ADD16mr:
+    case X86::ADD16ri:
+    case X86::ADD16ri8:
+    case X86::ADD16rm:
+    case X86::ADD16rr:
+    case X86::ADD16rr_REV:
+    case X86::ADD32i32:
+    case X86::ADD32mr:
+    case X86::ADD32ri:
+    case X86::ADD32ri8:
+    case X86::ADD32rm:
+    case X86::ADD32rr:
+    case X86::ADD32rr_REV:
+    case X86::ADD64i32:
+    case X86::ADD64mr:
+    case X86::ADD64ri32:
+    case X86::ADD64ri8:
+    case X86::ADD64rm:
+    case X86::ADD64rr:
+    case X86::ADD64rr_REV:
+    case X86::ADD8i8:
+    case X86::ADD8mr:
+    case X86::ADD8ri:
+    case X86::ADD8ri8:
+    case X86::ADD8rm:
+    case X86::ADD8rr:
+    case X86::ADD8rr_REV:
+    // SUB
+    case X86::SUB16i16:
+    case X86::SUB16mr:
+    case X86::SUB16ri:
+    case X86::SUB16ri8:
+    case X86::SUB16rm:
+    case X86::SUB16rr:
+    case X86::SUB16rr_REV:
+    case X86::SUB32i32:
+    case X86::SUB32mr:
+    case X86::SUB32ri:
+    case X86::SUB32ri8:
+    case X86::SUB32rm:
+    case X86::SUB32rr:
+    case X86::SUB32rr_REV:
+    case X86::SUB64i32:
+    case X86::SUB64mr:
+    case X86::SUB64ri32:
+    case X86::SUB64ri8:
+    case X86::SUB64rm:
+    case X86::SUB64rr:
+    case X86::SUB64rr_REV:
+    case X86::SUB8i8:
+    case X86::SUB8mr:
+    case X86::SUB8ri:
+    case X86::SUB8ri8:
+    case X86::SUB8rm:
+    case X86::SUB8rr:
+    case X86::SUB8rr_REV:
+      return FirstMacroFusionInstKind::AddSub;
+    // INC
+    case X86::INC16r:
+    case X86::INC16r_alt:
+    case X86::INC32r:
+    case X86::INC32r_alt:
+    case X86::INC64r:
+    case X86::INC8r:
+    // DEC
+    case X86::DEC16r:
+    case X86::DEC16r_alt:
+    case X86::DEC32r:
+    case X86::DEC32r_alt:
+    case X86::DEC64r:
+    case X86::DEC8r:
+      return FirstMacroFusionInstKind::IncDec;
+    }
+  }
+
+  /// classifySecondCondCodeInMacroFusion - return the type of the second
+  /// instruction in macro-fusion.
+  inline SecondMacroFusionInstKind
+  classifySecondCondCodeInMacroFusion(X86::CondCode CC) {
+    if (CC == X86::COND_INVALID)
+      return SecondMacroFusionInstKind::Invalid;
+
+    switch (CC) {
+    default:
+      return SecondMacroFusionInstKind::Invalid;
+    // JE,JZ
+    case X86::COND_E:
+    // JNE,JNZ
+    case X86::COND_NE:
+    // JL,JNGE
+    case X86::COND_L:
+    // JLE,JNG
+    case X86::COND_LE:
+    // JG,JNLE
+    case X86::COND_G:
+    // JGE,JNL
+    case X86::COND_GE:
+      return SecondMacroFusionInstKind::ELG;
+    // JB,JC
+    case X86::COND_B:
+    // JNA,JBE
+    case X86::COND_BE:
+    // JA,JNBE
+    case X86::COND_A:
+    // JAE,JNC,JNB
+    case X86::COND_AE:
+      return SecondMacroFusionInstKind::AB;
+    // JS
+    case X86::COND_S:
+    // JNS
+    case X86::COND_NS:
+    // JP,JPE
+    case X86::COND_P:
+    // JNP,JPO
+    case X86::COND_NP:
+    // JO
+    case X86::COND_O:
+    // JNO
+    case X86::COND_NO:
+      return SecondMacroFusionInstKind::SPO;
+    }
+  }
+
+  inline bool isMacroFused(FirstMacroFusionInstKind FirstKind,
+                           SecondMacroFusionInstKind SecondKind) {
+    switch (FirstKind) {
+    case X86::FirstMacroFusionInstKind::Test:
+    case X86::FirstMacroFusionInstKind::And:
+      return true;
+    case X86::FirstMacroFusionInstKind::Cmp:
+    case X86::FirstMacroFusionInstKind::AddSub:
+      return SecondKind == X86::SecondMacroFusionInstKind::AB ||
+             SecondKind == X86::SecondMacroFusionInstKind::ELG;
+    case X86::FirstMacroFusionInstKind::IncDec:
+      return SecondKind == X86::SecondMacroFusionInstKind::ELG;
+    case X86::FirstMacroFusionInstKind::Invalid:
+      return false;
+    }
+    llvm_unreachable("unknown fusion type");
+  }
 } // end namespace X86;
 
 /// X86II - This namespace holds all of the target specific flags that
 /// instruction info tracks.
 ///
 namespace X86II {
   /// Target Operand Flag enum.
   enum TOF {

llvm/lib/Target/X86/X86InstrInfo.td

 // Pattern fragments.
 //
 
 // X86 specific condition code. These correspond to CondCode in
 // X86InstrInfo.h. They must be kept in synch.
 def X86_COND_O   : PatLeaf<(i8 0)>;
 def X86_COND_NO  : PatLeaf<(i8 1)>;
 def X86_COND_B   : PatLeaf<(i8 2)>;  // alt. COND_C
-def X86_COND_AE  : PatLeaf<(i8 3)>;  // alt. COND_NC
+def X86_COND_AE  : PatLeaf<(i8 3)>;  // alt. COND_NC,COND_NB
 def X86_COND_E   : PatLeaf<(i8 4)>;  // alt. COND_Z
 def X86_COND_NE  : PatLeaf<(i8 5)>;  // alt. COND_NZ
 def X86_COND_BE  : PatLeaf<(i8 6)>;  // alt. COND_NA
 def X86_COND_A   : PatLeaf<(i8 7)>;  // alt. COND_NBE
 def X86_COND_S   : PatLeaf<(i8 8)>;
 def X86_COND_NS  : PatLeaf<(i8 9)>;
 def X86_COND_P   : PatLeaf<(i8 10)>; // alt. COND_PE
 def X86_COND_NP  : PatLeaf<(i8 11)>; // alt. COND_PO

llvm/lib/Target/X86/X86MacroFusion.cpp

 //===- X86MacroFusion.cpp - X86 Macro Fusion ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file This file contains the X86 implementation of the DAG scheduling
 /// mutation to pair instructions back to back.
 //
 //===----------------------------------------------------------------------===//
 
+#include "MCTargetDesc/X86BaseInfo.h"
 #include "X86MacroFusion.h"
 #include "X86Subtarget.h"
 #include "llvm/CodeGen/MacroFusion.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 
 using namespace llvm;
 
-namespace {
-
-// The classification for the first instruction.
-enum class FirstInstrKind { Test, Cmp, And, ALU, IncDec, Invalid };
-
-// The classification for the second instruction (jump).
-enum class JumpKind {
-  // JE, JL, JG and variants.
-  ELG,
-  // JA, JB and variants.
-  AB,
-  // JS, JP, JO and variants.
-  SPO,
-  // Not a fusable jump.
-  Invalid,
-};
-
-} // namespace
-
-static FirstInstrKind classifyFirst(const MachineInstr &MI) {
-  switch (MI.getOpcode()) {
-  default:
-    return FirstInstrKind::Invalid;
-  case X86::TEST8rr:
-  case X86::TEST16rr:
-  case X86::TEST32rr:
-  case X86::TEST64rr:
-  case X86::TEST8ri:
-  case X86::TEST16ri:
-  case X86::TEST32ri:
-  case X86::TEST64ri32:
-  case X86::TEST8mr:
-  case X86::TEST16mr:
-  case X86::TEST32mr:
-  case X86::TEST64mr:
-    return FirstInstrKind::Test;
-  case X86::AND16ri:
-  case X86::AND16ri8:
-  case X86::AND16rm:
-  case X86::AND16rr:
-  case X86::AND32ri:
-  case X86::AND32ri8:
-  case X86::AND32rm:
-  case X86::AND32rr:
-  case X86::AND64ri32:
-  case X86::AND64ri8:
-  case X86::AND64rm:
-  case X86::AND64rr:
-  case X86::AND8ri:
-  case X86::AND8rm:
-  case X86::AND8rr:
-    return FirstInstrKind::And;
-  case X86::CMP16ri:
-  case X86::CMP16ri8:
-  case X86::CMP16rm:
-  case X86::CMP16rr:
-  case X86::CMP16mr:
-  case X86::CMP32ri:
-  case X86::CMP32ri8:
-  case X86::CMP32rm:
-  case X86::CMP32rr:
-  case X86::CMP32mr:
-  case X86::CMP64ri32:
-  case X86::CMP64ri8:
-  case X86::CMP64rm:
-  case X86::CMP64rr:
-  case X86::CMP64mr:
-  case X86::CMP8ri:
-  case X86::CMP8rm:
-  case X86::CMP8rr:
-  case X86::CMP8mr:
-    return FirstInstrKind::Cmp;
-  case X86::ADD16ri:
-  case X86::ADD16ri8:
-  case X86::ADD16ri8_DB:
-  case X86::ADD16ri_DB:
-  case X86::ADD16rm:
-  case X86::ADD16rr:
-  case X86::ADD16rr_DB:
-  case X86::ADD32ri:
-  case X86::ADD32ri8:
-  case X86::ADD32ri8_DB:
-  case X86::ADD32ri_DB:
-  case X86::ADD32rm:
-  case X86::ADD32rr:
-  case X86::ADD32rr_DB:
-  case X86::ADD64ri32:
-  case X86::ADD64ri32_DB:
-  case X86::ADD64ri8:
-  case X86::ADD64ri8_DB:
-  case X86::ADD64rm:
-  case X86::ADD64rr:
-  case X86::ADD64rr_DB:
-  case X86::ADD8ri:
-  case X86::ADD8ri_DB:
-  case X86::ADD8rm:
-  case X86::ADD8rr:
-  case X86::ADD8rr_DB:
-  case X86::SUB16ri:
-  case X86::SUB16ri8:
-  case X86::SUB16rm:
-  case X86::SUB16rr:
-  case X86::SUB32ri:
-  case X86::SUB32ri8:
-  case X86::SUB32rm:
-  case X86::SUB32rr:
-  case X86::SUB64ri32:
-  case X86::SUB64ri8:
-  case X86::SUB64rm:
-  case X86::SUB64rr:
-  case X86::SUB8ri:
-  case X86::SUB8rm:
-  case X86::SUB8rr:
-    return FirstInstrKind::ALU;
-  case X86::INC16r:
-  case X86::INC32r:
-  case X86::INC64r:
-  case X86::INC8r:
-  case X86::DEC16r:
-  case X86::DEC32r:
-  case X86::DEC64r:
-  case X86::DEC8r:
-    return FirstInstrKind::IncDec;
-  }
+static X86::FirstMacroFusionInstKind classifyFirst(const MachineInstr &MI) {
+  return X86::classifyFirstOpcodeInMacroFusion(MI.getOpcode());
 }
 
-static JumpKind classifySecond(const MachineInstr &MI) {
+static X86::SecondMacroFusionInstKind classifySecond(const MachineInstr &MI) {
   X86::CondCode CC = X86::getCondFromBranch(MI);
-  if (CC == X86::COND_INVALID)
-    return JumpKind::Invalid;
-
-  switch (CC) {
-  default:
-    return JumpKind::Invalid;
-  case X86::COND_E:
-  case X86::COND_NE:
-  case X86::COND_L:
-  case X86::COND_LE:
-  case X86::COND_G:
-  case X86::COND_GE:
-    return JumpKind::ELG;
-  case X86::COND_B:
-  case X86::COND_BE:
-  case X86::COND_A:
-  case X86::COND_AE:
-    return JumpKind::AB;
-  case X86::COND_S:
-  case X86::COND_NS:
-  case X86::COND_P:
-  case X86::COND_NP:
-  case X86::COND_O:
-  case X86::COND_NO:
-    return JumpKind::SPO;
-  }
+  return X86::classifySecondCondCodeInMacroFusion(CC);
 }
 
 /// Check if the instr pair, FirstMI and SecondMI, should be fused
 /// together. Given SecondMI, when FirstMI is unspecified, then check if
 /// SecondMI may be part of a fused pair at all.
 static bool shouldScheduleAdjacent(const TargetInstrInfo &TII,
                                    const TargetSubtargetInfo &TSI,
                                    const MachineInstr *FirstMI,
                                    const MachineInstr &SecondMI) {
   const X86Subtarget &ST = static_cast<const X86Subtarget &>(TSI);
 
   // Check if this processor supports any kind of fusion.
   if (!(ST.hasBranchFusion() || ST.hasMacroFusion()))
     return false;
 
-  const JumpKind BranchKind = classifySecond(SecondMI);
+  const X86::SecondMacroFusionInstKind BranchKind = classifySecond(SecondMI);
 
-  if (BranchKind == JumpKind::Invalid)
+  if (BranchKind == X86::SecondMacroFusionInstKind::Invalid)
     return false; // Second cannot be fused with anything.
 
   if (FirstMI == nullptr)
     return true; // We're only checking whether Second can be fused at all.
 
-  const FirstInstrKind TestKind = classifyFirst(*FirstMI);
+  const X86::FirstMacroFusionInstKind TestKind = classifyFirst(*FirstMI);
 
   if (ST.hasBranchFusion()) {
     // Branch fusion can merge CMP and TEST with all conditional jumps.
-    return (TestKind == FirstInstrKind::Cmp ||
-            TestKind == FirstInstrKind::Test);
+    return (TestKind == X86::FirstMacroFusionInstKind::Cmp ||
+            TestKind == X86::FirstMacroFusionInstKind::Test);
   }
 
   if (ST.hasMacroFusion()) {
-    // Macro Fusion rules are a bit more complex. See Agner Fog's
-    // Microarchitecture table 9.2 "Instruction Fusion".
-    switch (TestKind) {
-    case FirstInstrKind::Test:
-    case FirstInstrKind::And:
-      return true;
-    case FirstInstrKind::Cmp:
-    case FirstInstrKind::ALU:
-      return BranchKind == JumpKind::ELG || BranchKind == JumpKind::AB;
-    case FirstInstrKind::IncDec:
-      return BranchKind == JumpKind::ELG;
-    case FirstInstrKind::Invalid:
-      return false;
-    }
+    return X86::isMacroFused(TestKind, BranchKind);
   }
 
-  llvm_unreachable("unknown branch fusion type");
+  llvm_unreachable("unknown fusion type");
 }
 
 namespace llvm {
 
 std::unique_ptr<ScheduleDAGMutation>
 createX86MacroFusionDAGMutation () {
   return createBranchMacroFusionDAGMutation(shouldScheduleAdjacent);
 }
 
 } // end namespace llvm

llvm/test/MC/X86/i386-align-branch-1a.s

+# Check option --x86-branches-within-32B-boundaries is equivalent to the combination of options --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d - > %t
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 65 65 65 a3 01 00 00 00          movl    %eax, %gs:1
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 55                               pushl   %ebp
+# CHECK-NEXT:        b: 55                               pushl   %ebp
+# CHECK-NEXT:        c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        e: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       20: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       22: 74 5e                            je      {{.*}}
+# CHECK-NEXT:       24: 3e 89 73 f4                      movl    %esi, %ds:-12(%ebx)
+# CHECK-NEXT:       28: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2b: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3d: 5d                               popl    %ebp
+# CHECK-NEXT:       3e: 5d                               popl    %ebp
+# CHECK-NEXT:       3f: 5d                               popl    %ebp
+# CHECK-NEXT:       40: 74 40                            je      {{.*}}
+# CHECK-NEXT:       42: 5d                               popl    %ebp
+# CHECK-NEXT:       43: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       45: 36 89 44 24 fc                   movl    %eax, %ss:-4(%esp)
+# CHECK-NEXT:       4a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       4d: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       50: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       53: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       56: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       59: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5f: 5d                               popl    %ebp
+# CHECK-NEXT:       60: eb 26                            jmp     {{.*}}
+# CHECK-NEXT:       62: eb 24                            jmp     {{.*}}
+# CHECK-NEXT:       64: eb 22                            jmp     {{.*}}
+# CHECK-NEXT:       66: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       69: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       6c: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       6f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       72: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       75: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       78: 5d                               popl    %ebp
+# CHECK-NEXT:       79: 5d                               popl    %ebp
+# CHECK-NEXT:       7a: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       7c: 74 04                            je      {{.*}}
+# CHECK-NEXT:       7e: 90                               nop
+# CHECK-NEXT:       7f: 90                               nop
+# CHECK-NEXT:       80: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       82: 8b 45 f4                         movl    -12(%ebp), %eax
+# CHECK-NEXT:       85: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       88: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       8e: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       94: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       9a: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       a0: 89 75 0c                         movl    %esi, 12(%ebp)
+# CHECK-NEXT:       a3: e9 fc ff ff ff                   jmp     {{.*}}
+# CHECK-NEXT:       a8: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ae: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b4: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ba: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       c0: 89 75 00                         movl    %esi, (%ebp)
+# CHECK-NEXT:       c3: 74 c3                            je      {{.*}}
+# CHECK-NEXT:       c5: 74 c1                            je      {{.*}}
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl    %eax, %gs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  cmp  %eax, %ebp
+  je  .L_2
+  movl  %esi, -12(%ebx)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  popl  %ebp
+  je  .L_2
+  popl  %ebp
+  je  .L_2
+  movl  %eax, -4(%esp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  cmp  %eax, %ebp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%ebp), %eax
+  movl  %eax, -4(%ebp)
+.L_3:
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, 12(%ebp)
+  jmp  bar
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, (%ebp)
+  je .L_3
+  je .L_3
+

llvm/test/MC/X86/i386-align-branch-1b.s

+# Check the size of segment prefixes is limited with option --x86-align-branch-prefix-size=NUM
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=1 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 65 a3 01 00 00 00                movl    %eax, %gs:1
+# CHECK-NEXT:        6: 3e 55                            pushl   %ebp
+# CHECK-NEXT:        8: 3e 55                            pushl   %ebp
+# CHECK-NEXT:        a: 55                               pushl   %ebp
+# CHECK-NEXT:        b: 55                               pushl   %ebp
+# CHECK-NEXT:        c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        e: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       20: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       22: 74 5e                            je      {{.*}}
+# CHECK-NEXT:       24: 3e 89 73 f4                      movl    %esi, %ds:-12(%ebx)
+# CHECK-NEXT:       28: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2b: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3d: 5d                               popl    %ebp
+# CHECK-NEXT:       3e: 5d                               popl    %ebp
+# CHECK-NEXT:       3f: 5d                               popl    %ebp
+# CHECK-NEXT:       40: 74 40                            je      {{.*}}
+# CHECK-NEXT:       42: 5d                               popl    %ebp
+# CHECK-NEXT:       43: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       45: 36 89 44 24 fc                   movl    %eax, %ss:-4(%esp)
+# CHECK-NEXT:       4a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       4d: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       50: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       53: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       56: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       59: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5f: 5d                               popl    %ebp
+# CHECK-NEXT:       60: eb 26                            jmp     {{.*}}
+# CHECK-NEXT:       62: eb 24                            jmp     {{.*}}
+# CHECK-NEXT:       64: eb 22                            jmp     {{.*}}
+# CHECK-NEXT:       66: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       69: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       6c: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       6f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       72: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       75: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       78: 5d                               popl    %ebp
+# CHECK-NEXT:       79: 5d                               popl    %ebp
+# CHECK-NEXT:       7a: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       7c: 74 04                            je      {{.*}}
+# CHECK-NEXT:       7e: 90                               nop
+# CHECK-NEXT:       7f: 90                               nop
+# CHECK-NEXT:       80: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       82: 8b 45 f4                         movl    -12(%ebp), %eax
+# CHECK-NEXT:       85: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       88: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       8e: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       94: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       9a: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       a0: 89 75 0c                         movl    %esi, 12(%ebp)
+# CHECK-NEXT:       a3: e9 fc ff ff ff                   jmp     {{.*}}
+# CHECK-NEXT:       a8: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ae: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b4: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ba: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       c0: 89 75 00                         movl    %esi, (%ebp)
+# CHECK-NEXT:       c3: 74 c3                            je      {{.*}}
+# CHECK-NEXT:       c5: 74 c1                            je      {{.*}}
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl    %eax, %gs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  cmp  %eax, %ebp
+  je  .L_2
+  movl  %esi, -12(%ebx)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  popl  %ebp
+  je  .L_2
+  popl  %ebp
+  je  .L_2
+  movl  %eax, -4(%esp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  cmp  %eax, %ebp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%ebp), %eax
+  movl  %eax, -4(%ebp)
+.L_3:
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, 12(%ebp)
+  jmp  bar
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, (%ebp)
+  je .L_3
+  je .L_3
+

llvm/test/MC/X86/i386-align-branch-1c.s

+# Check only fused conditional jumps and conditional jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 65 65 65 a3 01 00 00 00          movl    %eax, %gs:1
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 55                               pushl   %ebp
+# CHECK-NEXT:        b: 55                               pushl   %ebp
+# CHECK-NEXT:        c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        e: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       20: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       22: 74 5b                            je      {{.*}}
+# CHECK-NEXT:       24: 3e 89 73 f4                      movl    %esi, %ds:-12(%ebx)
+# CHECK-NEXT:       28: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2b: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3d: 5d                               popl    %ebp
+# CHECK-NEXT:       3e: 5d                               popl    %ebp
+# CHECK-NEXT:       3f: 5d                               popl    %ebp
+# CHECK-NEXT:       40: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       42: 5d                               popl    %ebp
+# CHECK-NEXT:       43: 74 3a                            je      {{.*}}
+# CHECK-NEXT:       45: 89 44 24 fc                      movl    %eax, -4(%esp)
+# CHECK-NEXT:       49: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       4c: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       4f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       52: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       55: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       58: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5e: 5d                               popl    %ebp
+# CHECK-NEXT:       5f: eb 24                            jmp     {{.*}}
+# CHECK-NEXT:       61: eb 22                            jmp     {{.*}}
+# CHECK-NEXT:       63: eb 20                            jmp     {{.*}}
+# CHECK-NEXT:       65: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       68: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       6b: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       6e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       71: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       74: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       77: 5d                               popl    %ebp
+# CHECK-NEXT:       78: 5d                               popl    %ebp
+# CHECK-NEXT:       79: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       7b: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7d: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       7f: 8b 45 f4                         movl    -12(%ebp), %eax
+# CHECK-NEXT:       82: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       85: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       8b: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       91: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       97: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       9d: 89 75 0c                         movl    %esi, 12(%ebp)
+# CHECK-NEXT:       a0: e9 fc ff ff ff                   jmp     {{.*}}
+# CHECK-NEXT:       a5: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ab: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b1: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b7: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       bd: 89 75 00                         movl    %esi, (%ebp)
+# CHECK-NEXT:       c0: 74 c3                            je      {{.*}}
+# CHECK-NEXT:       c2: 74 c1                            je      {{.*}}
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl    %eax, %gs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  cmp  %eax, %ebp
+  je  .L_2
+  movl  %esi, -12(%ebx)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  popl  %ebp
+  je  .L_2
+  popl  %ebp
+  je  .L_2
+  movl  %eax, -4(%esp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  cmp  %eax, %ebp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%ebp), %eax
+  movl  %eax, -4(%ebp)
+.L_3:
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, 12(%ebp)
+  jmp  bar
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, (%ebp)
+  je .L_3
+  je .L_3
+

llvm/test/MC/X86/i386-align-branch-1d.s

+# Check only conditional jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=jcc --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=jcc --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 65 a3 01 00 00 00                movl    %eax, %gs:1
+# CHECK-NEXT:        6: 55                               pushl   %ebp
+# CHECK-NEXT:        7: 55                               pushl   %ebp
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        c: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1e: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       20: 74 5a                            je      {{.*}}
+# CHECK-NEXT:       22: 89 73 f4                         movl    %esi, -12(%ebx)
+# CHECK-NEXT:       25: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       28: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 5d                               popl    %ebp
+# CHECK-NEXT:       3b: 5d                               popl    %ebp
+# CHECK-NEXT:       3c: 5d                               popl    %ebp
+# CHECK-NEXT:       3d: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       3f: 5d                               popl    %ebp
+# CHECK-NEXT:       40: 74 3a                            je      {{.*}}
+# CHECK-NEXT:       42: 89 44 24 fc                      movl    %eax, -4(%esp)
+# CHECK-NEXT:       46: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       49: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       4c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       4f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       52: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       55: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       58: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5b: 5d                               popl    %ebp
+# CHECK-NEXT:       5c: eb 24                            jmp     {{.*}}
+# CHECK-NEXT:       5e: eb 22                            jmp     {{.*}}
+# CHECK-NEXT:       60: eb 20                            jmp     {{.*}}
+# CHECK-NEXT:       62: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       65: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       68: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       6b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       6e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       71: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       74: 5d                               popl    %ebp
+# CHECK-NEXT:       75: 5d                               popl    %ebp
+# CHECK-NEXT:       76: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       78: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7a: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       7c: 8b 45 f4                         movl    -12(%ebp), %eax
+# CHECK-NEXT:       7f: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       82: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       88: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       8e: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       94: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       9a: 89 75 0c                         movl    %esi, 12(%ebp)
+# CHECK-NEXT:       9d: e9 fc ff ff ff                   jmp     {{.*}}
+# CHECK-NEXT:       a2: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       a8: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ae: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b4: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ba: 89 75 00                         movl    %esi, (%ebp)
+# CHECK-NEXT:       bd: 74 c3                            je      {{.*}}
+# CHECK-NEXT:       bf: 90                               nop
+# CHECK-NEXT:       c0: 74 c0                            je      {{.*}}
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl    %eax, %gs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  cmp  %eax, %ebp
+  je  .L_2
+  movl  %esi, -12(%ebx)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  popl  %ebp
+  je  .L_2
+  popl  %ebp
+  je  .L_2
+  movl  %eax, -4(%esp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  cmp  %eax, %ebp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%ebp), %eax
+  movl  %eax, -4(%ebp)
+.L_3:
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, 12(%ebp)
+  jmp  bar
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, (%ebp)
+  je .L_3
+  je .L_3
+

llvm/test/MC/X86/i386-align-branch-1e.s

+# Check only conditional jumps and unconditional jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=jcc+jmp --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=jcc+jmp --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 65 a3 01 00 00 00                movl    %eax, %gs:1
+# CHECK-NEXT:        6: 55                               pushl   %ebp
+# CHECK-NEXT:        7: 55                               pushl   %ebp
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        c: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1e: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       20: 74 5c                            je      {{.*}}
+# CHECK-NEXT:       22: 89 73 f4                         movl    %esi, -12(%ebx)
+# CHECK-NEXT:       25: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       28: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 5d                               popl    %ebp
+# CHECK-NEXT:       3b: 5d                               popl    %ebp
+# CHECK-NEXT:       3c: 5d                               popl    %ebp
+# CHECK-NEXT:       3d: 74 3f                            je      {{.*}}
+# CHECK-NEXT:       3f: 5d                               popl    %ebp
+# CHECK-NEXT:       40: 74 3c                            je      {{.*}}
+# CHECK-NEXT:       42: 89 44 24 fc                      movl    %eax, -4(%esp)
+# CHECK-NEXT:       46: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       49: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       4c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       4f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       52: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       55: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       58: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5b: 5d                               popl    %ebp
+# CHECK-NEXT:       5c: eb 27                            jmp     {{.*}}
+# CHECK-NEXT:       5e: 90                               nop
+# CHECK-NEXT:       5f: 90                               nop
+# CHECK-NEXT:       60: eb 23                            jmp     {{.*}}
+# CHECK-NEXT:       62: eb 21                            jmp     {{.*}}
+# CHECK-NEXT:       64: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       67: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       6a: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       6d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       70: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       73: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       76: 5d                               popl    %ebp
+# CHECK-NEXT:       77: 5d                               popl    %ebp
+# CHECK-NEXT:       78: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       7a: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7c: eb 07                            jmp     {{.*}}
+# CHECK-NEXT:       7e: 36 8b 45 f4                      movl    %ss:-12(%ebp), %eax
+# CHECK-NEXT:       82: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       85: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       8b: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       91: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       97: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       9d: 89 75 0c                         movl    %esi, 12(%ebp)
+# CHECK-NEXT:       a0: e9 fc ff ff ff                   jmp     {{.*}}
+# CHECK-NEXT:       a5: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ab: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b1: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b7: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       bd: 89 75 00                         movl    %esi, (%ebp)
+# CHECK-NEXT:       c0: 74 c3                            je      {{.*}}
+# CHECK-NEXT:       c2: 74 c1                            je      {{.*}}
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl    %eax, %gs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  cmp  %eax, %ebp
+  je  .L_2
+  movl  %esi, -12(%ebx)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  popl  %ebp
+  je  .L_2
+  popl  %ebp
+  je  .L_2
+  movl  %eax, -4(%esp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  cmp  %eax, %ebp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%ebp), %eax
+  movl  %eax, -4(%ebp)
+.L_3:
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, 12(%ebp)
+  jmp  bar
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, (%ebp)
+  je .L_3
+  je .L_3
+

llvm/test/MC/X86/i386-align-branch-1f.s

+# Check no branches is aligned with option --x86-align-branch-boundary=0 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=0 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 65 a3 01 00 00 00                movl    %eax, %gs:1
+# CHECK-NEXT:        6: 55                               pushl   %ebp
+# CHECK-NEXT:        7: 55                               pushl   %ebp
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        c: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1e: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       20: 74 5a                            je      {{.*}}
+# CHECK-NEXT:       22: 89 73 f4                         movl    %esi, -12(%ebx)
+# CHECK-NEXT:       25: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       28: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 5d                               popl    %ebp
+# CHECK-NEXT:       3b: 5d                               popl    %ebp
+# CHECK-NEXT:       3c: 5d                               popl    %ebp
+# CHECK-NEXT:       3d: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       3f: 5d                               popl    %ebp
+# CHECK-NEXT:       40: 74 3a                            je      {{.*}}
+# CHECK-NEXT:       42: 89 44 24 fc                      movl    %eax, -4(%esp)
+# CHECK-NEXT:       46: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       49: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       4c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       4f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       52: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       55: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       58: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5b: 5d                               popl    %ebp
+# CHECK-NEXT:       5c: eb 24                            jmp     {{.*}}
+# CHECK-NEXT:       5e: eb 22                            jmp     {{.*}}
+# CHECK-NEXT:       60: eb 20                            jmp     {{.*}}
+# CHECK-NEXT:       62: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       65: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       68: 89 7d f8                         movl    %edi, -8(%ebp)
+# CHECK-NEXT:       6b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       6e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       71: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       74: 5d                               popl    %ebp
+# CHECK-NEXT:       75: 5d                               popl    %ebp
+# CHECK-NEXT:       76: 39 c5                            cmpl    %eax, %ebp
+# CHECK-NEXT:       78: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7a: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       7c: 8b 45 f4                         movl    -12(%ebp), %eax
+# CHECK-NEXT:       7f: 89 45 fc                         movl    %eax, -4(%ebp)
+# CHECK-NEXT:       82: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       88: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       8e: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       94: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       9a: 89 75 0c                         movl    %esi, 12(%ebp)
+# CHECK-NEXT:       9d: e9 fc ff ff ff                   jmp     {{.*}}
+# CHECK-NEXT:       a2: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       a8: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ae: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       b4: 89 b5 50 fb ff ff                movl    %esi, -1200(%ebp)
+# CHECK-NEXT:       ba: 89 75 00                         movl    %esi, (%ebp)
+# CHECK-NEXT:       bd: 74 c3                            je      {{.*}}
+# CHECK-NEXT:       bf: 74 c1                            je      {{.*}}
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl    %eax, %gs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  cmp  %eax, %ebp
+  je  .L_2
+  movl  %esi, -12(%ebx)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  popl  %ebp
+  je  .L_2
+  popl  %ebp
+  je  .L_2
+  movl  %eax, -4(%esp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %edi, -8(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  popl  %ebp
+  popl  %ebp
+  cmp  %eax, %ebp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%ebp), %eax
+  movl  %eax, -4(%ebp)
+.L_3:
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, 12(%ebp)
+  jmp  bar
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, -1200(%ebp)
+  movl  %esi, (%ebp)
+  je .L_3
+  je .L_3
+

llvm/test/MC/X86/i386-align-branch-2a.s

+# Check indirect jumps and calls are not aligned with option --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 or with option --x86-branches-within-32B-boundaries
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:        6: 55                               pushl   %ebp
+# CHECK-NEXT:        7: 55                               pushl   %ebp
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1e: ff e0                            jmpl    *%eax
+# CHECK-NEXT:       20: 55                               pushl   %ebp
+# CHECK-NEXT:       21: 55                               pushl   %ebp
+# CHECK-NEXT:       22: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       28: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       2a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       30: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       33: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       36: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       39: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3c: ff d0                            calll   *%eax
+# CHECK-NEXT:       3e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       41: 55                               pushl   %ebp
+# CHECK-NEXT:       42: 55                               pushl   %ebp
+# CHECK-NEXT:       43: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       49: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       4b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       4e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       51: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       57: e8 a4 ff ff ff                   calll   {{.*}}
+# CHECK-NEXT:       5c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5f: 55                               pushl   %ebp
+# CHECK-NEXT:       60: 55                               pushl   %ebp
+# CHECK-NEXT:       61: 55                               pushl   %ebp
+# CHECK-NEXT:       62: 55                               pushl   %ebp
+# CHECK-NEXT:       63: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       69: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       6b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       6e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       71: ff 15 00 00 00 00                calll   *0
+# CHECK-NEXT:       77: 55                               pushl   %ebp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  jmp  *%eax
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call *%eax
+  movl  %esi, -12(%ebp)
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call  foo
+  movl  %esi, -12(%ebp)
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call  *foo
+  pushl  %ebp

llvm/test/MC/X86/i386-align-branch-2b.s

+# Check only indirect jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=indirect  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=indirect  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 64 64 64 a3 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 55                               pushl   %ebp
+# CHECK-NEXT:        b: 55                               pushl   %ebp
+# CHECK-NEXT:        c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       20: ff e0                            jmpl    *%eax
+# CHECK-NEXT:       22: 55                               pushl   %ebp
+# CHECK-NEXT:       23: 55                               pushl   %ebp
+# CHECK-NEXT:       24: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       2a: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       2c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       32: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       35: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       38: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3e: ff d0                            calll   *%eax
+# CHECK-NEXT:       40: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       43: 55                               pushl   %ebp
+# CHECK-NEXT:       44: 55                               pushl   %ebp
+# CHECK-NEXT:       45: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       4b: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       4d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       50: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       53: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       56: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       59: e8 a2 ff ff ff                   calll   {{.*}}
+# CHECK-NEXT:       5e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       61: 55                               pushl   %ebp
+# CHECK-NEXT:       62: 55                               pushl   %ebp
+# CHECK-NEXT:       63: 55                               pushl   %ebp
+# CHECK-NEXT:       64: 55                               pushl   %ebp
+# CHECK-NEXT:       65: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       6b: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       6d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       70: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       73: ff 15 00 00 00 00                calll   *0
+# CHECK-NEXT:       79: 55                               pushl   %ebp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  jmp  *%eax
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call *%eax
+  movl  %esi, -12(%ebp)
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call  foo
+  movl  %esi, -12(%ebp)
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call  *foo
+  pushl  %ebp

llvm/test/MC/X86/i386-align-branch-2c.s

+# Check only indirect jumps and calls are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=indirect+call  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=indirect+call  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 64 64 64 a3 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 55                               pushl   %ebp
+# CHECK-NEXT:        b: 55                               pushl   %ebp
+# CHECK-NEXT:        c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       20: ff e0                            jmpl    *%eax
+# CHECK-NEXT:       22: 3e 3e 55                         pushl   %ebp
+# CHECK-NEXT:       25: 55                               pushl   %ebp
+# CHECK-NEXT:       26: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       2c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       40: ff d0                            calll   *%eax
+# CHECK-NEXT:       42: 36 36 36 36 36 89 75 f4          movl    %esi, %ss:-12(%ebp)
+# CHECK-NEXT:       4a: 55                               pushl   %ebp
+# CHECK-NEXT:       4b: 55                               pushl   %ebp
+# CHECK-NEXT:       4c: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       52: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       57: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       5d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       60: e8 9b ff ff ff                   calll   {{.*}}
+# CHECK-NEXT:       65: 36 36 36 36 36 89 75 f4          movl    %esi, %ss:-12(%ebp)
+# CHECK-NEXT:       6d: 3e 55                            pushl   %ebp
+# CHECK-NEXT:       6f: 55                               pushl   %ebp
+# CHECK-NEXT:       70: 55                               pushl   %ebp
+# CHECK-NEXT:       71: 55                               pushl   %ebp
+# CHECK-NEXT:       72: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       78: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       7a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       7d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       80: ff 15 00 00 00 00                calll   *0
+# CHECK-NEXT:       86: 55                               pushl   %ebp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  jmp  *%eax
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call *%eax
+  movl  %esi, -12(%ebp)
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call  foo
+  movl  %esi, -12(%ebp)
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call  *foo
+  pushl  %ebp

llvm/test/MC/X86/i386-align-branch-3a.s

+# Check NOP padding is disabled before tls_get_addr calls
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=call  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:        6: 55                               pushl   %ebp
+# CHECK-NEXT:        7: 55                               pushl   %ebp
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1e: e8 fc ff ff ff                   calll   {{.*}}
+# CHECK-NEXT:       23: 55                               pushl   %ebp
+# CHECK-NEXT:       24: 55                               pushl   %ebp
+# CHECK-NEXT:       25: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       2b: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       2d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       30: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       33: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       36: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       39: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3c: ff 91 00 00 00 00                calll   *(%ecx)
+# CHECK-NEXT:       42: 89 75 f4                         movl    %esi, -12(%ebp)
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call    ___tls_get_addr
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  call *___tls_get_addr@GOT(%ecx)
+  movl  %esi, -12(%ebp)

llvm/test/MC/X86/i386-align-branch-4a.s

+# Check rets are not aligned with option --x86-branches-within-32B-boundaries or with option --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:        6: 55                               pushl   %ebp
+# CHECK-NEXT:        7: 55                               pushl   %ebp
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 55                               pushl   %ebp
+# CHECK-NEXT:        b: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       10: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       13: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       16: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       19: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1c: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1f: c3                               retl
+# CHECK-NEXT:       20: 55                               pushl   %ebp
+# CHECK-NEXT:       21: 55                               pushl   %ebp
+# CHECK-NEXT:       22: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       28: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       2a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       2d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       30: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       33: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       36: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       39: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3c: c2 1e 00                         retl    $30
+# CHECK-NEXT:       3f: 89 75 f4                         movl    %esi, -12(%ebp)
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  ret
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  ret    $30
+  movl  %esi, -12(%ebp)

llvm/test/MC/X86/i386-align-branch-4b.s

+# Check only rets are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=ret  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=ret  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: 64 64 a3 01 00 00 00             movl    %eax, %fs:1
+# CHECK-NEXT:        7: 55                               pushl   %ebp
+# CHECK-NEXT:        8: 55                               pushl   %ebp
+# CHECK-NEXT:        9: 55                               pushl   %ebp
+# CHECK-NEXT:        a: 55                               pushl   %ebp
+# CHECK-NEXT:        b: 55                               pushl   %ebp
+# CHECK-NEXT:        c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       20: c3                               retl
+# CHECK-NEXT:       21: 3e 3e 3e 55                      pushl   %ebp
+# CHECK-NEXT:       25: 55                               pushl   %ebp
+# CHECK-NEXT:       26: 64 a3 01 00 00 00                movl    %eax, %fs:1
+# CHECK-NEXT:       2c: 89 e5                            movl    %esp, %ebp
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       3d: 89 75 f4                         movl    %esi, -12(%ebp)
+# CHECK-NEXT:       40: c2 1e 00                         retl    $30
+# CHECK-NEXT:       43: 89 75 f4                         movl    %esi, -12(%ebp)
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  pushl  %ebp
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  ret
+  pushl  %ebp
+  pushl  %ebp
+  movl  %eax, %fs:0x1
+  movl  %esp, %ebp
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  movl  %esi, -12(%ebp)
+  ret    $30
+  movl  %esi, -12(%ebp)

llvm/test/MC/X86/i386-align-branch-5a.s

+# Check no nop or prefix is inserted if no branch cross or is against the boundary
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown %s | llvm-objdump -d  - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 foo:
+# CHECK-NEXT:        0: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:        3: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:        6: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:        9: 89 d1                            movl    %edx, %ecx
+# CHECK-NEXT:        b: 31 c0                            xorl    %eax, %eax
+# CHECK-NEXT:        d: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       10: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       13: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       16: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       19: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       1c: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       1f: f6 c2 02                         testb   $2, %dl
+# CHECK-NEXT:       22: f3 ab                            rep     stosl    %eax, %es:(%edi)
+# CHECK-NEXT:       24: 75 dd                            jne     {{.*}}
+# CHECK-NEXT:       26: 31 c0                            xorl    %eax, %eax
+# CHECK-NEXT:       28: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       2b: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       2e: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       31: 89 d1                            movl    %edx, %ecx
+# CHECK-NEXT:       33: 31 c0                            xorl    %eax, %eax
+# CHECK-NEXT:       35: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       38: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       3b: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       3e: f6 c2 02                         testb   $2, %dl
+# CHECK-NEXT:       41: e8 fc ff ff ff                   calll   {{.*}}
+# CHECK-NEXT:       46: 75 e3                            jne     {{.*}}
+# CHECK-NEXT:       48: 31 c0                            xorl    %eax, %eax
+
+    .text
+    .p2align 4,,15
+foo:
+    shrl    $2, %ecx
+.L1:
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    movl    %edx, %ecx
+    xorl    %eax, %eax
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    testb    $2, %dl
+    rep stosl
+    jne    .L1
+    xorl    %eax, %eax
+    shrl    $2, %ecx
+.L2:
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    movl    %edx, %ecx
+    xorl    %eax, %eax
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    testb    $2, %dl
+    call    bar
+    jne    .L2
+    xorl    %eax, %eax
+

llvm/test/MC/X86/i386-align-branch-6a.s

+# Check no prefix is inserted before the fragment whose size is no less than 15
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=1 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 main:
+# CHECK-NEXT:        0: 3e 55                            pushl    %ebp
+# CHECK-NEXT:        2: 89 e5                            movl     %esp, %ebp
+# CHECK-COUNT-28:       90                               nop
+# CHECK-NEXT:       20: eb 00                            jmp    0 <infiniteLoop>
+# CHECK: 00000022 infiniteLoop:
+# CHECK-NEXT:       22: eb dc                            jmp    -36 <main>
+
+    .text
+    .globl infiniteLoop
+main:
+    pushl %ebp
+    movl  %esp, %ebp
+    .rept 27
+    .byte 0x90
+    .endr
+    jmp infiniteLoop
+infiniteLoop:
+    jmp main

llvm/test/MC/X86/i386-align-branch-7a.s

+# Check the macro fusion table
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple i386-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+# CHECK: Disassembly of section .text:
+# CHECK: 00000000 main:
+# CHECK-NEXT:        0: 55                               pushl    %ebp
+# CHECK-NEXT:        1: 54                               pushl    %esp
+# CHECK-NEXT:        2: eb 17                            jmp      23 <infiniteLoop>
+# CHECK-COUNT-23:       90                               nop
+# CHECK: 0000001b infiniteLoop:
+# CHECK-NEXT:       1b: 3e 3e 55                         pushl    %ebp
+# CHECK-NEXT:       1e: 39 c5                            cmpl     %eax, %ebp
+# CHECK-NEXT:       20: 78 de                            js       {{.*}}
+# CHECK-COUNT-25:       90                               nop
+# CHECK-NEXT:       3b: 3e 3e 55                         pushl    %ebp
+# CHECK-NEXT:       3e: 39 c5                            cmpl     %eax, %ebp
+# CHECK-NEXT:       40: 70 be                            jo       {{.*}}
+# CHECK-COUNT-25:       90                               nop
+# CHECK-NEXT:       5b: 3e 3e 55                         pushl    %ebp
+# CHECK-NEXT:       5e: 01 c5                            addl     %eax, %ebp
+# CHECK-NEXT:       60: 71 9e                            jno      {{.*}}
+# CHECK-COUNT-25:       90                               nop
+# CHECK-NEXT:       7b: 3e 3e 55                         pushl    %ebp
+# CHECK-NEXT:       7e: 29 c5                            subl     %eax, %ebp
+# CHECK-NEXT:       80: 0f 8b 7a ff ff ff                jnp      {{.*}}
+# CHECK-COUNT-21:       90                               nop
+# CHECK-NEXT:       9b: 3e 3e 3e 55                      pushl    %ebp
+# CHECK-NEXT:       9f: 42                               incl     %edx
+# CHECK-NEXT:       a0: 0f 82 5a ff ff ff                jb      {{.*}}
+# CHECK-COUNT-21:       90                               nop
+# CHECK-NEXT:       bb: 3e 3e 3e 55                      pushl    %ebp
+# CHECK-NEXT:       bf: 4a                               decl     %edx
+# CHECK-NEXT:       c0: 0f 86 3a ff ff ff                jbe     {{.*}}
+
+    .text
+    .globl infiniteLoop
+main:
+    pushl  %ebp
+    pushl  %esp
+    jmp infiniteLoop
+
+    .p2align  4
+    .rept 11
+    .byte 0x90
+    .endr
+infiniteLoop:
+    pushl  %ebp
+    cmp  %eax, %ebp
+    js main
+    .p2align  4
+    .rept 11
+    .byte 0x90
+    .endr
+    pushl  %ebp
+    cmp  %eax, %ebp
+    jo  main
+    .p2align  4
+    .rept 11
+    .byte 0x90
+    .endr
+    pushl  %ebp
+    add  %eax, %ebp
+    jno  main
+    .p2align  4
+    .rept 11
+    .byte 0x90
+    .endr
+    pushl  %ebp
+    sub  %eax, %ebp
+    jpo  main
+    .p2align  4
+    .rept 11
+    .byte 0x90
+    .endr
+    pushl  %ebp
+    inc  %edx
+    jb  main
+    .p2align  4
+    .rept 11
+    .byte 0x90
+    .endr
+    pushl  %ebp
+    dec  %edx
+    jna  main

llvm/test/MC/X86/x86-64-align-branch-1a.s

+# Check option --x86-branches-within-32B-boundaries is equivalent to the combination of options --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 64 64 64 89 04 25 01 00 00 00 movl    %eax, %fs:1
+# CHECK-NEXT:        b: 55                               pushq   %rbp
+# CHECK-NEXT:        c: 55                               pushq   %rbp
+# CHECK-NEXT:        d: 55                               pushq   %rbp
+# CHECK-NEXT:        e: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       20: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       23: 74 5d                            je      {{.*}}
+# CHECK-NEXT:       25: 2e 89 75 f4                      movl    %esi, %cs:-12(%rbp)
+# CHECK-NEXT:       29: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2c: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       2f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       32: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       35: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       38: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3e: 5d                               popq    %rbp
+# CHECK-NEXT:       3f: 5d                               popq    %rbp
+# CHECK-NEXT:       40: 74 40                            je      {{.*}}
+# CHECK-NEXT:       42: 5d                               popq    %rbp
+# CHECK-NEXT:       43: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       45: 2e 89 45 fc                      movl    %eax, %cs:-4(%rbp)
+# CHECK-NEXT:       49: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       4c: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       4f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       52: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       55: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       58: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5e: 5d                               popq    %rbp
+# CHECK-NEXT:       5f: 5d                               popq    %rbp
+# CHECK-NEXT:       60: eb 26                            jmp     {{.*}}
+# CHECK-NEXT:       62: eb 24                            jmp     {{.*}}
+# CHECK-NEXT:       64: eb 22                            jmp     {{.*}}
+# CHECK-NEXT:       66: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       69: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       6c: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       6f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       72: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       75: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       78: 5d                               popq    %rbp
+# CHECK-NEXT:       79: 5d                               popq    %rbp
+# CHECK-NEXT:       7a: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       7d: 74 03                            je      {{.*}}
+# CHECK-NEXT:       7f: 90                               nop
+# CHECK-NEXT:       80: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       82: 8b 45 f4                         movl    -12(%rbp), %eax
+# CHECK-NEXT:       85: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       88: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       8e: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       94: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       9a: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a0: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a6: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       ac: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b2: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b8: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       be: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       c4: eb c2                            jmp     {{.*}}
+# CHECK-NEXT:       c6: 5d                               popq    %rbp
+# CHECK-NEXT:       c7: c3                               retq
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  cmp  %rax, %rbp
+  je  .L_2
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  je  .L_2
+  popq  %rbp
+  je  .L_2
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  cmp  %rax, %rbp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%rbp), %eax
+  movl  %eax, -4(%rbp)
+.L_3:
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  jmp  .L_3
+  popq  %rbp
+  retq

llvm/test/MC/X86/x86-64-align-branch-1b.s

+# Check the size of segment prefixes is limited with option --x86-align-branch-prefix-size=NUM
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=1 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 2e 55                            pushq   %rbp
+# CHECK-NEXT:        a: 2e 55                            pushq   %rbp
+# CHECK-NEXT:        c: 2e 55                            pushq   %rbp
+# CHECK-NEXT:        e: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       20: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       23: 74 5d                            je      {{.*}}
+# CHECK-NEXT:       25: 2e 89 75 f4                      movl    %esi, %cs:-12(%rbp)
+# CHECK-NEXT:       29: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2c: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       2f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       32: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       35: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       38: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3e: 5d                               popq    %rbp
+# CHECK-NEXT:       3f: 5d                               popq    %rbp
+# CHECK-NEXT:       40: 74 40                            je      {{.*}}
+# CHECK-NEXT:       42: 5d                               popq    %rbp
+# CHECK-NEXT:       43: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       45: 2e 89 45 fc                      movl    %eax, %cs:-4(%rbp)
+# CHECK-NEXT:       49: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       4c: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       4f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       52: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       55: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       58: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5e: 5d                               popq    %rbp
+# CHECK-NEXT:       5f: 5d                               popq    %rbp
+# CHECK-NEXT:       60: eb 26                            jmp     {{.*}}
+# CHECK-NEXT:       62: eb 24                            jmp     {{.*}}
+# CHECK-NEXT:       64: eb 22                            jmp     {{.*}}
+# CHECK-NEXT:       66: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       69: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       6c: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       6f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       72: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       75: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       78: 5d                               popq    %rbp
+# CHECK-NEXT:       79: 5d                               popq    %rbp
+# CHECK-NEXT:       7a: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       7d: 74 03                            je      {{.*}}
+# CHECK-NEXT:       7f: 90                               nop
+# CHECK-NEXT:       80: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       82: 8b 45 f4                         movl    -12(%rbp), %eax
+# CHECK-NEXT:       85: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       88: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       8e: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       94: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       9a: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a0: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a6: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       ac: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b2: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b8: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       be: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       c4: eb c2                            jmp     {{.*}}
+# CHECK-NEXT:       c6: 5d                               popq    %rbp
+# CHECK-NEXT:       c7: c3                               retq
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  cmp  %rax, %rbp
+  je  .L_2
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  je  .L_2
+  popq  %rbp
+  je  .L_2
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  cmp  %rax, %rbp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%rbp), %eax
+  movl  %eax, -4(%rbp)
+.L_3:
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  jmp  .L_3
+  popq  %rbp
+  retq

llvm/test/MC/X86/x86-64-align-branch-1c.s

+# Check only fused conditional jumps and conditional jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 64 64 64 89 04 25 01 00 00 00 movl    %eax, %fs:1
+# CHECK-NEXT:        b: 55                               pushq   %rbp
+# CHECK-NEXT:        c: 55                               pushq   %rbp
+# CHECK-NEXT:        d: 55                               pushq   %rbp
+# CHECK-NEXT:        e: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       20: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       23: 74 5b                            je      {{.*}}
+# CHECK-NEXT:       25: 2e 89 75 f4                      movl    %esi, %cs:-12(%rbp)
+# CHECK-NEXT:       29: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2c: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       2f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       32: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       35: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       38: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3e: 5d                               popq    %rbp
+# CHECK-NEXT:       3f: 5d                               popq    %rbp
+# CHECK-NEXT:       40: 74 3e                            je      {{.*}}
+# CHECK-NEXT:       42: 5d                               popq    %rbp
+# CHECK-NEXT:       43: 74 3b                            je      {{.*}}
+# CHECK-NEXT:       45: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       48: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       4b: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       4e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       51: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       57: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5d: 5d                               popq    %rbp
+# CHECK-NEXT:       5e: 5d                               popq    %rbp
+# CHECK-NEXT:       5f: eb 25                            jmp    {{.*}}
+# CHECK-NEXT:       61: eb 23                            jmp    {{.*}}
+# CHECK-NEXT:       63: eb 21                            jmp    {{.*}}
+# CHECK-NEXT:       65: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       68: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       6b: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       6e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       71: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       74: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       77: 5d                               popq    %rbp
+# CHECK-NEXT:       78: 5d                               popq    %rbp
+# CHECK-NEXT:       79: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       7c: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7e: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       80: 8b 45 f4                         movl    -12(%rbp), %eax
+# CHECK-NEXT:       83: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       86: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       8c: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       92: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       98: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       9e: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a4: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       aa: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b0: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b6: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       bc: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       c2: eb c2                            jmp     {{.*}}
+# CHECK-NEXT:       c4: 5d                               popq    %rbp
+# CHECK-NEXT:       c5: c3                               retq
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  cmp  %rax, %rbp
+  je  .L_2
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  je  .L_2
+  popq  %rbp
+  je  .L_2
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  cmp  %rax, %rbp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%rbp), %eax
+  movl  %eax, -4(%rbp)
+.L_3:
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  jmp  .L_3
+  popq  %rbp
+  retq

llvm/test/MC/X86/x86-64-align-branch-1d.s

+# Check only conditional jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=jcc --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=jcc  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       20: 74 5b                            je      {{.*}}
+# CHECK-NEXT:       22: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       25: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       28: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3a: 5d                               popq    %rbp
+# CHECK-NEXT:       3b: 5d                               popq    %rbp
+# CHECK-NEXT:       3c: 74 3f                            je      {{.*}}
+# CHECK-NEXT:       3e: 2e 5d                            popq    %rbp
+# CHECK-NEXT:       40: 74 3b                            je      {{.*}}
+# CHECK-NEXT:       42: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       45: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       48: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       4b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       4e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       51: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       57: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5a: 5d                               popq    %rbp
+# CHECK-NEXT:       5b: 5d                               popq    %rbp
+# CHECK-NEXT:       5c: eb 25                            jmp     {{.*}}
+# CHECK-NEXT:       5e: eb 23                            jmp     {{.*}}
+# CHECK-NEXT:       60: eb 21                            jmp     {{.*}}
+# CHECK-NEXT:       62: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       65: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       68: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       6b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       6e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       71: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       74: 5d                               popq    %rbp
+# CHECK-NEXT:       75: 5d                               popq    %rbp
+# CHECK-NEXT:       76: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       79: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7b: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       7d: 8b 45 f4                         movl    -12(%rbp), %eax
+# CHECK-NEXT:       80: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       83: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       89: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       8f: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       95: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       9b: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a1: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a7: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       ad: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b3: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b9: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       bf: eb c2                            jmp     {{.*}}
+# CHECK-NEXT:       c1: 5d                               popq    %rbp
+# CHECK-NEXT:       c2: c3                               retq
+
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  cmp  %rax, %rbp
+  je  .L_2
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  je  .L_2
+  popq  %rbp
+  je  .L_2
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  cmp  %rax, %rbp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%rbp), %eax
+  movl  %eax, -4(%rbp)
+.L_3:
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  jmp  .L_3
+  popq  %rbp
+  retq

llvm/test/MC/X86/x86-64-align-branch-1e.s

+# Check only conditional jumps and unconditional jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=jcc+jmp --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       20: 74 5d                            je      {{.*}}
+# CHECK-NEXT:       22: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       25: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       28: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3a: 5d                               popq    %rbp
+# CHECK-NEXT:       3b: 5d                               popq    %rbp
+# CHECK-NEXT:       3c: 74 41                            je      {{.*}}
+# CHECK-NEXT:       3e: 2e 5d                            popq    %rbp
+# CHECK-NEXT:       40: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       42: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       45: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       48: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       4b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       4e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       51: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       57: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5a: 5d                               popq    %rbp
+# CHECK-NEXT:       5b: 5d                               popq    %rbp
+# CHECK-NEXT:       5c: eb 27                            jmp     {{.*}}
+# CHECK-NEXT:       5e: 90                               nop
+# CHECK-NEXT:       5f: 90                               nop
+# CHECK-NEXT:       60: eb 23                            jmp     {{.*}}
+# CHECK-NEXT:       62: eb 21                            jmp     {{.*}}
+# CHECK-NEXT:       64: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       67: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       6a: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       6d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       70: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       73: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       76: 5d                               popq    %rbp
+# CHECK-NEXT:       77: 5d                               popq    %rbp
+# CHECK-NEXT:       78: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       7b: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7d: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       7f: 8b 45 f4                         movl    -12(%rbp), %eax
+# CHECK-NEXT:       82: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       85: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       8b: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       91: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       97: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       9d: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a3: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a9: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       af: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b5: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       bb: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       c1: eb c2                            jmp     {{.*}}
+# CHECK-NEXT:       c3: 5d                               popq    %rbp
+# CHECK-NEXT:       c4: c3                               retq
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  cmp  %rax, %rbp
+  je  .L_2
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  je  .L_2
+  popq  %rbp
+  je  .L_2
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  cmp  %rax, %rbp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%rbp), %eax
+  movl  %eax, -4(%rbp)
+.L_3:
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  jmp  .L_3
+  popq  %rbp
+  retq

llvm/test/MC/X86/x86-64-align-branch-1f.s

+# Check no branches is aligned with option --x86-align-branch-boundary=0 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=0 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       20: 74 5a                            je      {{.*}}
+# CHECK-NEXT:       22: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       25: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       28: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3a: 5d                               popq    %rbp
+# CHECK-NEXT:       3b: 5d                               popq    %rbp
+# CHECK-NEXT:       3c: 74 3e                            je      {{.*}}
+# CHECK-NEXT:       3e: 5d                               popq    %rbp
+# CHECK-NEXT:       3f: 74 3b                            je      {{.*}}
+# CHECK-NEXT:       41: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       44: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       47: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       4a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       4d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       50: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       53: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       56: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       59: 5d                               popq    %rbp
+# CHECK-NEXT:       5a: 5d                               popq    %rbp
+# CHECK-NEXT:       5b: eb 25                            jmp     {{.*}}
+# CHECK-NEXT:       5d: eb 23                            jmp     {{.*}}
+# CHECK-NEXT:       5f: eb 21                            jmp     {{.*}}
+# CHECK-NEXT:       61: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       64: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       67: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       6a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       6d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       70: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       73: 5d                               popq    %rbp
+# CHECK-NEXT:       74: 5d                               popq    %rbp
+# CHECK-NEXT:       75: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       78: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7a: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       7c: 8b 45 f4                         movl    -12(%rbp), %eax
+# CHECK-NEXT:       7f: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       82: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       88: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       8e: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       94: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       9a: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a0: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a6: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       ac: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b2: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b8: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       be: eb c2                            jmp     {{.*}}
+# CHECK-NEXT:       c0: 5d                               popq    %rbp
+# CHECK-NEXT:       c1: c3                               retq
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  cmp  %rax, %rbp
+  je  .L_2
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  je  .L_2
+  popq  %rbp
+  je  .L_2
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  cmp  %rax, %rbp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%rbp), %eax
+  movl  %eax, -4(%rbp)
+.L_3:
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  jmp  .L_3
+  popq  %rbp
+  retq

llvm/test/MC/X86/x86-64-align-branch-1g.s

+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 -mcpu=x86-64 --x86-align-branch=jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       20: 74 5d                            je      {{.*}}
+# CHECK-NEXT:       22: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       25: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       28: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3a: 5d                               popq    %rbp
+# CHECK-NEXT:       3b: 5d                               popq    %rbp
+# CHECK-NEXT:       3c: 74 41                            je      {{.*}}
+# CHECK-NEXT:       3e: 2e 5d                            popq    %rbp
+# CHECK-NEXT:       40: 74 3d                            je      {{.*}}
+# CHECK-NEXT:       42: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       45: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       48: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       4b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       4e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       51: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       57: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5a: 5d                               popq    %rbp
+# CHECK-NEXT:       5b: 5d                               popq    %rbp
+# CHECK-NEXT:       5c: eb 27                            jmp     {{.*}}
+# CHECK-NEXT:       5e: 66 90                            nop
+# CHECK-NEXT:       60: eb 23                            jmp     {{.*}}
+# CHECK-NEXT:       62: eb 21                            jmp     {{.*}}
+# CHECK-NEXT:       64: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       67: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       6a: 89 7d f8                         movl    %edi, -8(%rbp)
+# CHECK-NEXT:       6d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       70: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       73: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       76: 5d                               popq    %rbp
+# CHECK-NEXT:       77: 5d                               popq    %rbp
+# CHECK-NEXT:       78: 48 39 c5                         cmpq    %rax, %rbp
+# CHECK-NEXT:       7b: 74 02                            je      {{.*}}
+# CHECK-NEXT:       7d: eb 06                            jmp     {{.*}}
+# CHECK-NEXT:       7f: 8b 45 f4                         movl    -12(%rbp), %eax
+# CHECK-NEXT:       82: 89 45 fc                         movl    %eax, -4(%rbp)
+# CHECK-NEXT:       85: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       8b: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       91: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       97: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       9d: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a3: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       a9: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       af: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       b5: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       bb: 89 b5 50 fb ff ff                movl    %esi, -1200(%rbp)
+# CHECK-NEXT:       c1: eb c2                            jmp     {{.*}}
+# CHECK-NEXT:       c3: 5d                               popq    %rbp
+# CHECK-NEXT:       c4: c3                               retq
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  cmp  %rax, %rbp
+  je  .L_2
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  je  .L_2
+  popq  %rbp
+  je  .L_2
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  jmp  .L_3
+  jmp  .L_3
+  jmp  .L_3
+  movl  %eax, -4(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %edi, -8(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  popq  %rbp
+  popq  %rbp
+  cmp  %rax, %rbp
+  je  .L_2
+  jmp  .L_3
+.L_2:
+  movl  -12(%rbp), %eax
+  movl  %eax, -4(%rbp)
+.L_3:
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  movl  %esi, -1200(%rbp)
+  jmp  .L_3
+  popq  %rbp
+  retq

llvm/test/MC/X86/x86-64-align-branch-2a.s

+# Check indirect jumps and calls are not aligned with option --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 or with option --x86-branches-within-32B-boundaries
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused-jcc-jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 55                               pushq   %rbp
+# CHECK-NEXT:        c: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1e: ff e0                            jmpq    *%rax
+# CHECK-NEXT:       20: 55                               pushq   %rbp
+# CHECK-NEXT:       21: 55                               pushq   %rbp
+# CHECK-NEXT:       22: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       2a: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       2d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       30: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       33: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       36: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       39: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3c: ff d0                            callq   *%rax
+# CHECK-NEXT:       3e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       41: 55                               pushq   %rbp
+# CHECK-NEXT:       42: 55                               pushq   %rbp
+# CHECK-NEXT:       43: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       4b: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       4e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       51: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       57: e8 a4 ff ff ff                   callq   {{.*}}
+# CHECK-NEXT:       5c: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5f: 55                               pushq   %rbp
+# CHECK-NEXT:       60: 55                               pushq   %rbp
+# CHECK-NEXT:       61: 55                               pushq   %rbp
+# CHECK-NEXT:       62: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       6a: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       6d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       70: ff 14 25 00 00 00 00             callq   *0
+# CHECK-NEXT:       77: 55                               pushq   %rbp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  jmp  *%rax
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call *%rax
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call  foo
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  call  *foo
+  pushq  %rbp

llvm/test/MC/X86/x86-64-align-branch-2b.s

+# Check only indirect jumps are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=indirect  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=indirect  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 64 64 89 04 25 01 00 00 00    movl    %eax, %fs:1
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 55                               pushq   %rbp
+# CHECK-NEXT:        c: 55                               pushq   %rbp
+# CHECK-NEXT:        d: 55                               pushq   %rbp
+# CHECK-NEXT:        e: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       20: ff e0                            jmpq    *%rax
+# CHECK-NEXT:       22: 55                               pushq   %rbp
+# CHECK-NEXT:       23: 55                               pushq   %rbp
+# CHECK-NEXT:       24: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       2c: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       2f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       32: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       35: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       38: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3e: ff d0                            callq   *%rax
+# CHECK-NEXT:       40: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       43: 55                               pushq   %rbp
+# CHECK-NEXT:       44: 55                               pushq   %rbp
+# CHECK-NEXT:       45: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       4d: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       50: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       53: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       56: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       59: e8 a2 ff ff ff                   callq   {{.*}}
+# CHECK-NEXT:       5e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       61: 55                               pushq   %rbp
+# CHECK-NEXT:       62: 55                               pushq   %rbp
+# CHECK-NEXT:       63: 55                               pushq   %rbp
+# CHECK-NEXT:       64: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       6c: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       6f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       72: ff 14 25 00 00 00 00             callq   *0
+# CHECK-NEXT:       79: 55                               pushq   %rbp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  jmp  *%rax
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call *%rax
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call  foo
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  call  *foo
+  pushq  %rbp

llvm/test/MC/X86/x86-64-align-branch-2c.s

+# Check only calls are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=call  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=call  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 55                               pushq   %rbp
+# CHECK-NEXT:        c: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1e: ff e0                            jmpq    *%rax
+# CHECK-NEXT:       20: 55                               pushq   %rbp
+# CHECK-NEXT:       21: 55                               pushq   %rbp
+# CHECK-NEXT:       22: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       2a: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       2d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       30: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       33: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       36: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       39: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3c: ff d0                            callq   *%rax
+# CHECK-NEXT:       3e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       41: 55                               pushq   %rbp
+# CHECK-NEXT:       42: 55                               pushq   %rbp
+# CHECK-NEXT:       43: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       4b: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       4e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       51: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       54: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       57: e8 a4 ff ff ff                   callq   {{.*}}
+# CHECK-NEXT:       5c: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5f: 55                               pushq   %rbp
+# CHECK-NEXT:       60: 55                               pushq   %rbp
+# CHECK-NEXT:       61: 55                               pushq   %rbp
+# CHECK-NEXT:       62: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       6a: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       6d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       70: ff 14 25 00 00 00 00             callq   *0
+# CHECK-NEXT:       77: 55                               pushq   %rbp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  jmp  *%rax
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call *%rax
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call  foo
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  call  *foo
+  pushq  %rbp

llvm/test/MC/X86/x86-64-align-branch-2d.s

+# Check only indirect jumps and calls are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=indirect+call  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=indirect+call  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 64 64 89 04 25 01 00 00 00    movl    %eax, %fs:1
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 55                               pushq   %rbp
+# CHECK-NEXT:        c: 55                               pushq   %rbp
+# CHECK-NEXT:        d: 55                               pushq   %rbp
+# CHECK-NEXT:        e: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       20: ff e0                            jmpq    *%rax
+# CHECK-NEXT:       22: 2e 2e 55                         pushq   %rbp
+# CHECK-NEXT:       25: 55                               pushq   %rbp
+# CHECK-NEXT:       26: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       2e: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       40: ff d0                            callq   *%rax
+# CHECK-NEXT:       42: 2e 2e 2e 2e 2e 89 75 f4          movl    %esi, %cs:-12(%rbp)
+# CHECK-NEXT:       4a: 55                               pushq   %rbp
+# CHECK-NEXT:       4b: 55                               pushq   %rbp
+# CHECK-NEXT:       4c: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       54: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       57: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       5d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       60: e8 9b ff ff ff                   callq   {{.*}}
+# CHECK-NEXT:       65: 2e 2e 2e 2e 2e 89 75 f4          movl    %esi, %cs:-12(%rbp)
+# CHECK-NEXT:       6d: 2e 2e 55                         pushq   %rbp
+# CHECK-NEXT:       70: 55                               pushq   %rbp
+# CHECK-NEXT:       71: 55                               pushq   %rbp
+# CHECK-NEXT:       72: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       7a: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       7d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       80: ff 14 25 00 00 00 00             callq   *0
+# CHECK-NEXT:       87: 55                               pushq   %rbp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  jmp  *%rax
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call *%rax
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call  foo
+  movl  %esi, -12(%rbp)
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  call  *foo
+  pushq  %rbp

llvm/test/MC/X86/x86-64-align-branch-3a.s

+# Check NOP padding is disabled before tls_get_addr calls
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=call  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 55                               pushq   %rbp
+# CHECK-NEXT:        c: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        f: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       12: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       15: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       18: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1e: e8 00 00 00 00                   callq   0 <foo+0x23>
+# CHECK-NEXT:       23: 55                               pushq   %rbp
+# CHECK-NEXT:       24: 55                               pushq   %rbp
+# CHECK-NEXT:       25: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       2d: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:       30: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       33: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       36: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       39: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3c: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3f: ff 15 00 00 00 00                callq   *(%rip)
+# CHECK-NEXT:       45: 89 75 f4                         movl    %esi, -12(%rbp)
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call    __tls_get_addr
+  pushq  %rbp
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  call    *__tls_get_addr@GOTPCREL(%rip)
+  movl  %esi, -12(%rbp)

llvm/test/MC/X86/x86-64-align-branch-4a.s

+# Check rets are not aligned with option --x86-branches-within-32B-boundaries or with option --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=fused+jcc+jmp  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - >%t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:        8: 55                               pushq   %rbp
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       10: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       13: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       16: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       19: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1c: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1f: c3                               retq
+# CHECK-NEXT:       20: 55                               pushq   %rbp
+# CHECK-NEXT:       21: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       29: 55                               pushq   %rbp
+# CHECK-NEXT:       2a: 55                               pushq   %rbp
+# CHECK-NEXT:       2b: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3d: c2 1e 00                         retq    $30
+# CHECK-NEXT:       40: 55                               pushq   %rbp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  ret
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  ret $30
+  pushq  %rbp

llvm/test/MC/X86/x86-64-align-branch-4b.s

+# Check only rets are aligned with option --x86-align-branch-boundary=32 --x86-align-branch=ret  --x86-align-branch-prefix-size=5
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-align-branch-boundary=32 --x86-align-branch=ret  --x86-align-branch-prefix-size=5 %s | llvm-objdump -d  - | FileCheck %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: 64 64 89 04 25 01 00 00 00       movl    %eax, %fs:1
+# CHECK-NEXT:        9: 55                               pushq   %rbp
+# CHECK-NEXT:        a: 55                               pushq   %rbp
+# CHECK-NEXT:        b: 48 89 e5                         movq    %rsp, %rbp
+# CHECK-NEXT:        e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       11: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       14: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       17: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       1d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       20: c3                               retq
+# CHECK-NEXT:       21: 2e 2e 55                         pushq   %rbp
+# CHECK-NEXT:       24: 64 89 04 25 01 00 00 00          movl    %eax, %fs:1
+# CHECK-NEXT:       2c: 55                               pushq   %rbp
+# CHECK-NEXT:       2d: 55                               pushq   %rbp
+# CHECK-NEXT:       2e: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       31: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       34: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       37: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3a: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       3d: 89 75 f4                         movl    %esi, -12(%rbp)
+# CHECK-NEXT:       40: c2 1e 00                         retq    $30
+# CHECK-NEXT:       43: 55                               pushq   %rbp
+
+  .text
+  .globl  foo
+  .p2align  4
+foo:
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  movq  %rsp, %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  ret
+  pushq  %rbp
+  movl  %eax, %fs:0x1
+  pushq  %rbp
+  pushq  %rbp
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  movl  %esi, -12(%rbp)
+  ret $30
+  pushq  %rbp

llvm/test/MC/X86/x86-64-align-branch-5a.s

+# Check no nop or prefix is inserted if no branch cross or is against the boundary
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown --x86-branches-within-32B-boundaries %s | llvm-objdump -d  - > %t
+# RUN: llvm-mc -filetype=obj -triple x86_64-unknown-unknown %s | llvm-objdump -d  - > %t2
+# RUN: cmp %t %t2
+# RUN: FileCheck --input-file=%t %s
+
+# CHECK: file format {{.*}}
+
+
+
+# CHECK: Disassembly of section .text:
+# CHECK: 0000000000000000 foo:
+# CHECK-NEXT:        0: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:        3: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:        6: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:        9: 89 d1                            movl    %edx, %ecx
+# CHECK-NEXT:        b: 31 c0                            xorl    %eax, %eax
+# CHECK-NEXT:        d: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       10: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       13: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       16: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       19: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       1c: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       1f: f6 c2 02                         testb   $2, %dl
+# CHECK-NEXT:       22: f3 ab                            rep     stosl    %eax, %es:(%rdi)
+# CHECK-NEXT:       24: 75 dd                            jne     {{.*}}
+# CHECK-NEXT:       26: 31 c0                            xorl    %eax, %eax
+# CHECK-NEXT:       28: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       2b: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       2e: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       31: 89 d1                            movl    %edx, %ecx
+# CHECK-NEXT:       33: 31 c0                            xorl    %eax, %eax
+# CHECK-NEXT:       35: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       38: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       3b: c1 e9 02                         shrl    $2, %ecx
+# CHECK-NEXT:       3e: f6 c2 02                         testb   $2, %dl
+# CHECK-NEXT:       41: e8 00 00 00 00                   callq   {{.*}}
+# CHECK-NEXT:       46: 75 e3                            jne     {{.*}}
+# CHECK-NEXT:       48: 31 c0                            xorl    %eax, %eax
+
+    .text
+    .p2align 4,,15
+foo:
+    shrl    $2, %ecx
+.L1:
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    movl    %edx, %ecx
+    xorl    %eax, %eax
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    testb    $2, %dl
+    rep stosl
+    jne    .L1
+    xorl    %eax, %eax
+    shrl    $2, %ecx
+.L2:
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    movl    %edx, %ecx
+    xorl    %eax, %eax
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    shrl    $2, %ecx
+    testb    $2, %dl
+    call    bar
+    jne    .L2
+    xorl    %eax, %eax