[X86] Print %st(0) as %st to match what gcc inline asm uses as the clobber name to make MS inline asm work correctly

[craig.topper]

Summary

When calculating clobbers for MS style inline assembly we fail if the asm clobbers stack top because we print st(0) and try to pass it through the gcc register name check. This was found with when I attempted to make a emms/femms clobber all ST registers. If you use emms/femms in MS inline asm we print the wrong clobber name

This also matches what objdump disassembly prints.

[rnk]

This is a pretty big change. I feel like it would be reasonable to add some logic to ParseStmtAsm.cpp in clang to do this translation, rather than changing how we print %st / %st(0) everywhere.

What does GCC's -S output look like?

[craig.topper]

gcc prints %st https://godbolt.org/z/3CXLvj

[rnk]

In D57621#1381623, @craig.topper wrote:

gcc prints %st https://godbolt.org/z/3CXLvj

Then let's ship it. :) I'm sure someone will break. Maybe wait a day to see if there are other opinions.

llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp

if (RegNo == X86::RIZ || RegNo == X86::RIP ||
       Parser.Lex(); // Eat register name.
       return Error(StartLoc,
                    "register %" + RegName + " is only available in 64-bit mode",
                    SMRange(StartLoc, EndLoc));
     }
   }
 
   // Parse "%st" as "%st(0)" and "%st(1)", which is multiple tokens.
-  if (RegNo == 0 && (Tok.getString() == "st" || Tok.getString() == "ST")) {
-    RegNo = X86::ST0;
+  if (RegNo == X86::ST0) {
     Parser.Lex(); // Eat 'st'
 
     // Check to see if we have '(4)' after %st.
     if (getLexer().isNot(AsmToken::LParen))
       return false;
     // Lex the paren.
     getParser().Lex();
 

llvm/trunk/lib/Target/X86/X86InstrFPStack.td

 class FPrST0PInst<Format fp, string asm>
   : FPI<0xDE, fp, (outs), (ins RST:$op), asm>;
 
 // NOTE: GAS and apparently all other AT&T style assemblers have a broken notion
 // of some of the 'reverse' forms of the fsub and fdiv instructions.  As such,
 // we have to put some 'r's in and take them out of weird places.
 let SchedRW = [WriteFAdd], Defs = [FPSW] in {
 def ADD_FST0r   : FPST0rInst <MRM0r, "fadd\t$op">;
-def ADD_FrST0   : FPrST0Inst <MRM0r, "fadd\t{%st(0), $op|$op, st(0)}">;
+def ADD_FrST0   : FPrST0Inst <MRM0r, "fadd\t{%st, $op|$op, st}">;
 def ADD_FPrST0  : FPrST0PInst<MRM0r, "faddp\t$op">;
 def SUBR_FST0r  : FPST0rInst <MRM5r, "fsubr\t$op">;
-def SUB_FrST0   : FPrST0Inst <MRM5r, "fsub{r}\t{%st(0), $op|$op, st(0)}">;
+def SUB_FrST0   : FPrST0Inst <MRM5r, "fsub{r}\t{%st, $op|$op, st}">;
 def SUB_FPrST0  : FPrST0PInst<MRM5r, "fsub{r}p\t$op">;
 def SUB_FST0r   : FPST0rInst <MRM4r, "fsub\t$op">;
-def SUBR_FrST0  : FPrST0Inst <MRM4r, "fsub{|r}\t{%st(0), $op|$op, st(0)}">;
+def SUBR_FrST0  : FPrST0Inst <MRM4r, "fsub{|r}\t{%st, $op|$op, st}">;
 def SUBR_FPrST0 : FPrST0PInst<MRM4r, "fsub{|r}p\t$op">;
 } // SchedRW
 let SchedRW = [WriteFCom], Defs = [FPSW] in {
 def COM_FST0r   : FPST0rInst <MRM2r, "fcom\t$op">;
 def COMP_FST0r  : FPST0rInst <MRM3r, "fcomp\t$op">;
 } // SchedRW
 let SchedRW = [WriteFMul], Defs = [FPSW] in {
 def MUL_FST0r   : FPST0rInst <MRM1r, "fmul\t$op">;
-def MUL_FrST0   : FPrST0Inst <MRM1r, "fmul\t{%st(0), $op|$op, st(0)}">;
+def MUL_FrST0   : FPrST0Inst <MRM1r, "fmul\t{%st, $op|$op, st}">;
 def MUL_FPrST0  : FPrST0PInst<MRM1r, "fmulp\t$op">;
 } // SchedRW
 let SchedRW = [WriteFDiv], Defs = [FPSW] in {
 def DIVR_FST0r  : FPST0rInst <MRM7r, "fdivr\t$op">;
-def DIV_FrST0   : FPrST0Inst <MRM7r, "fdiv{r}\t{%st(0), $op|$op, st(0)}">;
+def DIV_FrST0   : FPrST0Inst <MRM7r, "fdiv{r}\t{%st, $op|$op, st}">;
 def DIV_FPrST0  : FPrST0PInst<MRM7r, "fdiv{r}p\t$op">;
 def DIV_FST0r   : FPST0rInst <MRM6r, "fdiv\t$op">;
-def DIVR_FrST0  : FPrST0Inst <MRM6r, "fdiv{|r}\t{%st(0), $op|$op, st(0)}">;
+def DIVR_FrST0  : FPrST0Inst <MRM6r, "fdiv{|r}\t{%st, $op|$op, st}">;
 def DIVR_FPrST0 : FPrST0PInst<MRM6r, "fdiv{|r}p\t$op">;
 } // SchedRW
 
 // Unary operations.
 multiclass FPUnary<SDNode OpNode, Format fp, string asmstring> {
 def _Fp32  : FpIf32<(outs RFP32:$dst), (ins RFP32:$src), OneArgFPRW,
                  [(set RFP32:$dst, (OpNode RFP32:$src))]>;
 def _Fp64  : FpIf64<(outs RFP64:$dst), (ins RFP64:$src), OneArgFPRW,

 defm CMOVNBE: FPCMov<X86_COND_A>;
 defm CMOVNE : FPCMov<X86_COND_NE>;
 defm CMOVNP : FPCMov<X86_COND_NP>;
 } // Uses = [EFLAGS], Constraints = "$src1 = $dst"
 
 let Predicates = [HasCMov] in {
 // These are not factored because there's no clean way to pass DA/DB.
 def CMOVB_F  : FPI<0xDA, MRM0r, (outs), (ins RST:$op),
-                  "fcmovb\t{$op, %st(0)|st(0), $op}">;
+                  "fcmovb\t{$op, %st|st, $op}">;
 def CMOVBE_F : FPI<0xDA, MRM2r, (outs), (ins RST:$op),
-                  "fcmovbe\t{$op, %st(0)|st(0), $op}">;
+                  "fcmovbe\t{$op, %st|st, $op}">;
 def CMOVE_F  : FPI<0xDA, MRM1r, (outs), (ins RST:$op),
-                  "fcmove\t{$op, %st(0)|st(0), $op}">;
+                  "fcmove\t{$op, %st|st, $op}">;
 def CMOVP_F  : FPI<0xDA, MRM3r, (outs), (ins RST:$op),
-                  "fcmovu\t{$op, %st(0)|st(0), $op}">;
+                  "fcmovu\t{$op, %st|st, $op}">;
 def CMOVNB_F : FPI<0xDB, MRM0r, (outs), (ins RST:$op),
-                  "fcmovnb\t{$op, %st(0)|st(0), $op}">;
+                  "fcmovnb\t{$op, %st|st, $op}">;
 def CMOVNBE_F: FPI<0xDB, MRM2r, (outs), (ins RST:$op),
-                  "fcmovnbe\t{$op, %st(0)|st(0), $op}">;
+                  "fcmovnbe\t{$op, %st|st, $op}">;
 def CMOVNE_F : FPI<0xDB, MRM1r, (outs), (ins RST:$op),
-                  "fcmovne\t{$op, %st(0)|st(0), $op}">;
+                  "fcmovne\t{$op, %st|st, $op}">;
 def CMOVNP_F : FPI<0xDB, MRM3r, (outs), (ins RST:$op),
-                  "fcmovnu\t{$op, %st(0)|st(0), $op}">;
+                  "fcmovnu\t{$op, %st|st, $op}">;
 } // Predicates = [HasCMov]
 } // SchedRW
 
 // Floating point loads & stores.
 let SchedRW = [WriteLoad] in {
 let canFoldAsLoad = 1 in {
 def LD_Fp32m   : FpIf32<(outs RFP32:$dst), (ins f32mem:$src), ZeroArgFP,
                   [(set RFP32:$dst, (loadf32 addr:$src))]>;

llvm/trunk/lib/Target/X86/X86InstrInfo.td

 def : InstAlias<"fucomi",       (UCOM_FIr    ST1), 0>;
 def : InstAlias<"fucompi",      (UCOM_FIPr   ST1), 0>;
 
 // Handle fmul/fadd/fsub/fdiv instructions with explicitly written st(0) op.
 // For example, "fadd %st(4), %st(0)" -> "fadd %st(4)".  We also disambiguate
 // instructions like "fadd %st(0), %st(0)" as "fadd %st(0)" for consistency with
 // gas.
 multiclass FpUnaryAlias<string Mnemonic, Instruction Inst, bit EmitAlias = 1> {
- def : InstAlias<!strconcat(Mnemonic, "\t{$op, %st(0)|st(0), $op}"),
+ def : InstAlias<!strconcat(Mnemonic, "\t{$op, %st|st, $op}"),
                  (Inst RST:$op), EmitAlias>;
- def : InstAlias<!strconcat(Mnemonic, "\t{%st(0), %st(0)|st(0), st(0)}"),
+ def : InstAlias<!strconcat(Mnemonic, "\t{%st, %st|st, st}"),
                  (Inst ST0), EmitAlias>;
 }
 
 defm : FpUnaryAlias<"fadd",   ADD_FST0r>;
 defm : FpUnaryAlias<"faddp",  ADD_FPrST0>;
 defm : FpUnaryAlias<"fsub",   SUB_FST0r>;
 defm : FpUnaryAlias<"fsub{|r}p",  SUBR_FPrST0>;
 defm : FpUnaryAlias<"fsubr",  SUBR_FST0r>;
 defm : FpUnaryAlias<"fsub{r|}p", SUB_FPrST0>;
 defm : FpUnaryAlias<"fmul",   MUL_FST0r>;
 defm : FpUnaryAlias<"fmulp",  MUL_FPrST0>;
 defm : FpUnaryAlias<"fdiv",   DIV_FST0r>;
 defm : FpUnaryAlias<"fdiv{|r}p",  DIVR_FPrST0>;
 defm : FpUnaryAlias<"fdivr",  DIVR_FST0r>;
 defm : FpUnaryAlias<"fdiv{r|}p", DIV_FPrST0>;
 defm : FpUnaryAlias<"fcomi",   COM_FIr>;
 defm : FpUnaryAlias<"fucomi",  UCOM_FIr>;
 defm : FpUnaryAlias<"fcompi",   COM_FIPr>;
 defm : FpUnaryAlias<"fucompi",  UCOM_FIPr>;
 
 
 // Handle "f{mulp,addp} st(0), $op" the same as "f{mulp,addp} $op", since they
 // commute.  We also allow fdiv[r]p/fsubrp even though they don't commute,
 // solely because gas supports it.
-def : InstAlias<"faddp\t{%st(0), $op|$op, st(0)}", (ADD_FPrST0 RST:$op)>;
-def : InstAlias<"fmulp\t{%st(0), $op|$op, st(0)}", (MUL_FPrST0 RST:$op)>;
-def : InstAlias<"fsub{|r}p\t{%st(0), $op|$op, st(0)}", (SUBR_FPrST0 RST:$op)>;
-def : InstAlias<"fsub{r|}p\t{%st(0), $op|$op, st(0)}", (SUB_FPrST0 RST:$op)>;
-def : InstAlias<"fdiv{|r}p\t{%st(0), $op|$op, st(0)}", (DIVR_FPrST0 RST:$op)>;
-def : InstAlias<"fdiv{r|}p\t{%st(0), $op|$op, st(0)}", (DIV_FPrST0 RST:$op)>;
+def : InstAlias<"faddp\t{%st, $op|$op, st}", (ADD_FPrST0 RST:$op)>;
+def : InstAlias<"fmulp\t{%st, $op|$op, st}", (MUL_FPrST0 RST:$op)>;
+def : InstAlias<"fsub{|r}p\t{%st, $op|$op, st}", (SUBR_FPrST0 RST:$op)>;
+def : InstAlias<"fsub{r|}p\t{%st, $op|$op, st}", (SUB_FPrST0 RST:$op)>;
+def : InstAlias<"fdiv{|r}p\t{%st, $op|$op, st}", (DIVR_FPrST0 RST:$op)>;
+def : InstAlias<"fdiv{r|}p\t{%st, $op|$op, st}", (DIV_FPrST0 RST:$op)>;
 
 def : InstAlias<"fnstsw"     , (FNSTSW16r), 0>;
 
 // lcall and ljmp aliases.  This seems to be an odd mapping in 64-bit mode, but
 // this is compatible with what GAS does.
 def : InstAlias<"lcall\t$seg, $off", (FARCALL32i i32imm:$off, i16imm:$seg), 0>, Requires<[In32BitMode]>;
 def : InstAlias<"ljmp\t$seg, $off",  (FARJMP32i  i32imm:$off, i16imm:$seg), 0>, Requires<[In32BitMode]>;
 def : InstAlias<"lcall\t{*}$dst",    (FARCALL32m opaquemem:$dst), 0>, Requires<[Not16BitMode]>;

llvm/trunk/lib/Target/X86/X86RegisterInfo.td

 def K5 : X86Reg<"k5", 5>, DwarfRegNum<[123,  98,  98]>;
 def K6 : X86Reg<"k6", 6>, DwarfRegNum<[124,  99,  99]>;
 def K7 : X86Reg<"k7", 7>, DwarfRegNum<[125, 100, 100]>;
 
 // Floating point stack registers. These don't map one-to-one to the FP
 // pseudo registers, but we still mark them as aliasing FP registers. That
 // way both kinds can be live without exceeding the stack depth. ST registers
 // are only live around inline assembly.
-def ST0 : X86Reg<"st(0)", 0>, DwarfRegNum<[33, 12, 11]>;
+def ST0 : X86Reg<"st", 0>, DwarfRegNum<[33, 12, 11]>;
 def ST1 : X86Reg<"st(1)", 1>, DwarfRegNum<[34, 13, 12]>;
 def ST2 : X86Reg<"st(2)", 2>, DwarfRegNum<[35, 14, 13]>;
 def ST3 : X86Reg<"st(3)", 3>, DwarfRegNum<[36, 15, 14]>;
 def ST4 : X86Reg<"st(4)", 4>, DwarfRegNum<[37, 16, 15]>;
 def ST5 : X86Reg<"st(5)", 5>, DwarfRegNum<[38, 17, 16]>;
 def ST6 : X86Reg<"st(6)", 6>, DwarfRegNum<[39, 18, 17]>;
 def ST7 : X86Reg<"st(7)", 7>, DwarfRegNum<[40, 19, 18]>;
 

llvm/trunk/test/CodeGen/X86/2007-09-27-LDIntrinsics.ll

 declare x86_fp80 @llvm.sqrt.f80(x86_fp80)
 
 define x86_fp80 @bar(x86_fp80 %x) nounwind {
 entry:
   %tmp2 = call x86_fp80 @llvm.powi.f80( x86_fp80 %x, i32 3 )
   ret x86_fp80 %tmp2
 ; CHECK-LABEL: bar:
 ; CHECK: fldt 4(%esp)
-; CHECK-NEXT: fld %st(0)
+; CHECK-NEXT: fld %st
 ; CHECK-NEXT: fmul  %st(1)
 ; CHECK-NEXT: fmulp
 ; CHECK-NEXT: ret
 }
 
 declare x86_fp80 @llvm.powi.f80(x86_fp80, i32)

llvm/trunk/test/CodeGen/X86/avx512-regcall-NoMask.ll

; LINUXOSX64-NEXT:    retq
   %d = fadd double 1.0, %c
   ret double %d
 }
 
 ; Test regcall when receiving/returning long double
 define x86_regcallcc x86_fp80 @test_argRetf80(x86_fp80 %a0) nounwind {
 ; X32-LABEL: test_argRetf80:
 ; X32:       # %bb.0:
-; X32-NEXT:    fadd %st(0), %st(0)
+; X32-NEXT:    fadd %st, %st
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_argRetf80:
 ; WIN64:       # %bb.0:
-; WIN64-NEXT:    fadd %st(0), %st(0)
+; WIN64-NEXT:    fadd %st, %st
 ; WIN64-NEXT:    retq
 ;
 ; LINUXOSX64-LABEL: test_argRetf80:
 ; LINUXOSX64:       # %bb.0:
-; LINUXOSX64-NEXT:    fadd %st(0), %st(0)
+; LINUXOSX64-NEXT:    fadd %st, %st
 ; LINUXOSX64-NEXT:    retq
   %r0 = fadd x86_fp80 %a0, %a0
   ret x86_fp80 %r0
 }
 
 ; Test regcall when passing/retrieving long double
 define x86_regcallcc x86_fp80 @test_CallargRetf80(x86_fp80 %a)  {
 ; X32-LABEL: test_CallargRetf80:
 ; X32:       # %bb.0:
 ; X32-NEXT:    pushl %esp
-; X32-NEXT:    fadd %st(0), %st(0)
+; X32-NEXT:    fadd %st, %st
 ; X32-NEXT:    calll _test_argRetf80
-; X32-NEXT:    fadd %st(0), %st(0)
+; X32-NEXT:    fadd %st, %st
 ; X32-NEXT:    popl %esp
 ; X32-NEXT:    retl
 ;
 ; WIN64-LABEL: test_CallargRetf80:
 ; WIN64:       # %bb.0:
 ; WIN64-NEXT:    pushq %rsp
 ; WIN64-NEXT:    .seh_pushreg 4
 ; WIN64-NEXT:    .seh_endprologue
-; WIN64-NEXT:    fadd %st(0), %st(0)
+; WIN64-NEXT:    fadd %st, %st
 ; WIN64-NEXT:    callq test_argRetf80
-; WIN64-NEXT:    fadd %st(0), %st(0)
+; WIN64-NEXT:    fadd %st, %st
 ; WIN64-NEXT:    popq %rsp
 ; WIN64-NEXT:    retq
 ; WIN64-NEXT:    .seh_handlerdata
 ; WIN64-NEXT:    .text
 ; WIN64-NEXT:    .seh_endproc
 ;
 ; LINUXOSX64-LABEL: test_CallargRetf80:
 ; LINUXOSX64:       # %bb.0:
 ; LINUXOSX64-NEXT:    pushq %rsp
 ; LINUXOSX64-NEXT:    .cfi_def_cfa_offset 16
 ; LINUXOSX64-NEXT:    .cfi_offset %rsp, -16
-; LINUXOSX64-NEXT:    fadd %st(0), %st(0)
+; LINUXOSX64-NEXT:    fadd %st, %st
 ; LINUXOSX64-NEXT:    callq test_argRetf80
-; LINUXOSX64-NEXT:    fadd %st(0), %st(0)
+; LINUXOSX64-NEXT:    fadd %st, %st
 ; LINUXOSX64-NEXT:    popq %rsp
 ; LINUXOSX64-NEXT:    .cfi_def_cfa_offset 8
 ; LINUXOSX64-NEXT:    retq
   %b = fadd x86_fp80 %a, %a
   %c = call x86_regcallcc x86_fp80 @test_argRetf80(x86_fp80 %b)
   %d = fadd x86_fp80 %c, %c
   ret x86_fp80 %d
 }

llvm/trunk/test/CodeGen/X86/fcmove.ll

 ; RUN: llc %s -o - -verify-machineinstrs | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-unknown"
 
 ; Test that we can generate an fcmove, and also that it passes verification.
 
 ; CHECK-LABEL: cmove_f
-; CHECK: fcmove %st({{[0-7]}}), %st(0)
+; CHECK: fcmove %st({{[0-7]}}), %st
 define x86_fp80 @cmove_f(x86_fp80 %a, x86_fp80 %b, i32 %c) {
   %test = icmp eq i32 %c, 0
   %add = fadd x86_fp80 %a, %b
   %ret = select i1 %test, x86_fp80 %add, x86_fp80 %b
   ret x86_fp80 %ret
 }

llvm/trunk/test/CodeGen/X86/finite-libcalls.ll

; MAC-NEXT:    jmp _pow ## TAILCALL
   ret double %r
 }
 
 define x86_fp80 @pow_f80(x86_fp80 %x) #0 {
 ; GNU-LABEL: pow_f80:
 ; GNU:       # %bb.0:
 ; GNU-NEXT:    subq $40, %rsp
 ; GNU-NEXT:    fldt {{[0-9]+}}(%rsp)
-; GNU-NEXT:    fld %st(0)
+; GNU-NEXT:    fld %st
 ; GNU-NEXT:    fstpt {{[0-9]+}}(%rsp)
 ; GNU-NEXT:    fstpt (%rsp)
 ; GNU-NEXT:    callq __powl_finite
 ; GNU-NEXT:    addq $40, %rsp
 ; GNU-NEXT:    retq
 ;
 ; WIN-LABEL: pow_f80:
 ; WIN:       # %bb.0:
 ; WIN-NEXT:    pushq %rsi
 ; WIN-NEXT:    subq $80, %rsp
 ; WIN-NEXT:    movq %rcx, %rsi
 ; WIN-NEXT:    fldt (%rdx)
-; WIN-NEXT:    fld %st(0)
+; WIN-NEXT:    fld %st
 ; WIN-NEXT:    fstpt {{[0-9]+}}(%rsp)
 ; WIN-NEXT:    fstpt {{[0-9]+}}(%rsp)
 ; WIN-NEXT:    leaq {{[0-9]+}}(%rsp), %rcx
 ; WIN-NEXT:    leaq {{[0-9]+}}(%rsp), %rdx
 ; WIN-NEXT:    leaq {{[0-9]+}}(%rsp), %r8
 ; WIN-NEXT:    callq powl
 ; WIN-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; WIN-NEXT:    fstpt (%rsi)
 ; WIN-NEXT:    movq %rsi, %rax
 ; WIN-NEXT:    addq $80, %rsp
 ; WIN-NEXT:    popq %rsi
 ; WIN-NEXT:    retq
 ;
 ; MAC-LABEL: pow_f80:
 ; MAC:       ## %bb.0:
 ; MAC-NEXT:    subq $40, %rsp
 ; MAC-NEXT:    fldt {{[0-9]+}}(%rsp)
-; MAC-NEXT:    fld %st(0)
+; MAC-NEXT:    fld %st
 ; MAC-NEXT:    fstpt {{[0-9]+}}(%rsp)
 ; MAC-NEXT:    fstpt (%rsp)
 ; MAC-NEXT:    callq _powl
 ; MAC-NEXT:    addq $40, %rsp
 ; MAC-NEXT:    retq
   %r = tail call nnan ninf x86_fp80 @llvm.pow.f80(x86_fp80 %x, x86_fp80 %x)
   ret x86_fp80 %r
 }

llvm/trunk/test/CodeGen/X86/fmf-flags.ll

 ; X64-NEXT:    mulsd %xmm0, %xmm1
 ; X64-NEXT:    mulsd {{.*}}(%rip), %xmm0
 ; X64-NEXT:    movsd %xmm1, {{.*}}(%rip)
 ; X64-NEXT:    retq
 ;
 ; X86-LABEL: not_so_fast_mul_add:
 ; X86:       # %bb.0:
 ; X86-NEXT:    fldl {{[0-9]+}}(%esp)
-; X86-NEXT:    fld %st(0)
+; X86-NEXT:    fld %st
 ; X86-NEXT:    fmull {{\.LCPI.*}}
 ; X86-NEXT:    fxch %st(1)
 ; X86-NEXT:    fmull {{\.LCPI.*}}
 ; X86-NEXT:    fxch %st(1)
 ; X86-NEXT:    fstpl mul1
 ; X86-NEXT:    retl
   %m = fmul double %x, 4.2
   %a = fadd fast double %m, %x

llvm/trunk/test/CodeGen/X86/fp-cvt.ll

 ; X86-NEXT:    fnstsw %ax
 ; X86-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X86-NEXT:    sahf
 ; X86-NEXT:    ja .LBB10_2
 ; X86-NEXT:  # %bb.1:
 ; X86-NEXT:    fstp %st(1)
 ; X86-NEXT:    fldz
 ; X86-NEXT:  .LBB10_2:
-; X86-NEXT:    fstp %st(0)
+; X86-NEXT:    fstp %st
 ; X86-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X86-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X86-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X86-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X86-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X86-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X86-NEXT:    setbe %al

 ; X64-X87:       # %bb.0:
 ; X64-X87-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    flds {{.*}}(%rip)
 ; X64-X87-NEXT:    fld %st(1)
 ; X64-X87-NEXT:    fsub %st(1)
 ; X64-X87-NEXT:    xorl %eax, %eax
 ; X64-X87-NEXT:    fxch %st(1)
 ; X64-X87-NEXT:    fucompi %st(2)
-; X64-X87-NEXT:    fcmovnbe %st(1), %st(0)
+; X64-X87-NEXT:    fcmovnbe %st(1), %st
 ; X64-X87-NEXT:    fstp %st(1)
 ; X64-X87-NEXT:    fnstcw -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    movzwl -{{[0-9]+}}(%rsp), %ecx
 ; X64-X87-NEXT:    movw $3199, -{{[0-9]+}}(%rsp) # imm = 0xC7F
 ; X64-X87-NEXT:    fldcw -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    movw %cx, -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    fistpll -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    fldcw -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    setbe %al
 ; X64-X87-NEXT:    shlq $63, %rax
 ; X64-X87-NEXT:    xorq -{{[0-9]+}}(%rsp), %rax
 ; X64-X87-NEXT:    retq
 ;
 ; X64-SSSE3-LABEL: fptoui_i64_fp80:
 ; X64-SSSE3:       # %bb.0:
 ; X64-SSSE3-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; X64-SSSE3-NEXT:    flds {{.*}}(%rip)
 ; X64-SSSE3-NEXT:    fld %st(1)
 ; X64-SSSE3-NEXT:    fsub %st(1)
 ; X64-SSSE3-NEXT:    xorl %eax, %eax
 ; X64-SSSE3-NEXT:    fxch %st(1)
 ; X64-SSSE3-NEXT:    fucompi %st(2)
-; X64-SSSE3-NEXT:    fcmovnbe %st(1), %st(0)
+; X64-SSSE3-NEXT:    fcmovnbe %st(1), %st
 ; X64-SSSE3-NEXT:    fstp %st(1)
 ; X64-SSSE3-NEXT:    fisttpll -{{[0-9]+}}(%rsp)
 ; X64-SSSE3-NEXT:    setbe %al
 ; X64-SSSE3-NEXT:    shlq $63, %rax
 ; X64-SSSE3-NEXT:    xorq -{{[0-9]+}}(%rsp), %rax
 ; X64-SSSE3-NEXT:    retq
   %1 = fptoui x86_fp80 %a0 to i64
   ret i64  %1

 ; X86-NEXT:    fnstsw %ax
 ; X86-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X86-NEXT:    sahf
 ; X86-NEXT:    ja .LBB11_2
 ; X86-NEXT:  # %bb.1:
 ; X86-NEXT:    fstp %st(1)
 ; X86-NEXT:    fldz
 ; X86-NEXT:  .LBB11_2:
-; X86-NEXT:    fstp %st(0)
+; X86-NEXT:    fstp %st
 ; X86-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X86-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X86-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X86-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X86-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X86-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X86-NEXT:    setbe %al

 ; X64-X87:       # %bb.0:
 ; X64-X87-NEXT:    fldt (%rdi)
 ; X64-X87-NEXT:    flds {{.*}}(%rip)
 ; X64-X87-NEXT:    fld %st(1)
 ; X64-X87-NEXT:    fsub %st(1)
 ; X64-X87-NEXT:    xorl %eax, %eax
 ; X64-X87-NEXT:    fxch %st(1)
 ; X64-X87-NEXT:    fucompi %st(2)
-; X64-X87-NEXT:    fcmovnbe %st(1), %st(0)
+; X64-X87-NEXT:    fcmovnbe %st(1), %st
 ; X64-X87-NEXT:    fstp %st(1)
 ; X64-X87-NEXT:    fnstcw -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    movzwl -{{[0-9]+}}(%rsp), %ecx
 ; X64-X87-NEXT:    movw $3199, -{{[0-9]+}}(%rsp) # imm = 0xC7F
 ; X64-X87-NEXT:    fldcw -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    movw %cx, -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    fistpll -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    fldcw -{{[0-9]+}}(%rsp)
 ; X64-X87-NEXT:    setbe %al
 ; X64-X87-NEXT:    shlq $63, %rax
 ; X64-X87-NEXT:    xorq -{{[0-9]+}}(%rsp), %rax
 ; X64-X87-NEXT:    retq
 ;
 ; X64-SSSE3-LABEL: fptoui_i64_fp80_ld:
 ; X64-SSSE3:       # %bb.0:
 ; X64-SSSE3-NEXT:    fldt (%rdi)
 ; X64-SSSE3-NEXT:    flds {{.*}}(%rip)
 ; X64-SSSE3-NEXT:    fld %st(1)
 ; X64-SSSE3-NEXT:    fsub %st(1)
 ; X64-SSSE3-NEXT:    xorl %eax, %eax
 ; X64-SSSE3-NEXT:    fxch %st(1)
 ; X64-SSSE3-NEXT:    fucompi %st(2)
-; X64-SSSE3-NEXT:    fcmovnbe %st(1), %st(0)
+; X64-SSSE3-NEXT:    fcmovnbe %st(1), %st
 ; X64-SSSE3-NEXT:    fstp %st(1)
 ; X64-SSSE3-NEXT:    fisttpll -{{[0-9]+}}(%rsp)
 ; X64-SSSE3-NEXT:    setbe %al
 ; X64-SSSE3-NEXT:    shlq $63, %rax
 ; X64-SSSE3-NEXT:    xorq -{{[0-9]+}}(%rsp), %rax
 ; X64-SSSE3-NEXT:    retq
   %1 = load x86_fp80, x86_fp80 *%a0
   %2 = fptoui x86_fp80 %1 to i64

llvm/trunk/test/CodeGen/X86/fp128-cast.ll

 ; X32-NEXT:    testb $-128, {{[0-9]+}}(%esp)
 ; X32-NEXT:    flds {{\.LCPI.*}}
 ; X32-NEXT:    flds {{\.LCPI.*}}
 ; X32-NEXT:    jne .LBB17_3
 ; X32-NEXT:  # %bb.2: # %if.then
 ; X32-NEXT:    fstp %st(1)
 ; X32-NEXT:    fldz
 ; X32-NEXT:  .LBB17_3: # %if.then
-; X32-NEXT:    fstp %st(0)
+; X32-NEXT:    fstp %st
 ; X32-NEXT:    subl $16, %esp
 ; X32-NEXT:    leal {{[0-9]+}}(%esp), %eax
 ; X32-NEXT:    movl %eax, (%esp)
 ; X32-NEXT:    fstpl {{[0-9]+}}(%esp)
 ; X32-NEXT:    calll __extenddftf2
 ; X32-NEXT:    addl $12, %esp
 ; X32-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X32-NEXT:    movl {{[0-9]+}}(%esp), %ecx

llvm/trunk/test/CodeGen/X86/inline-asm-fpstack.ll

 ; CHECK-LABEL: test6:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    fldl {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fldl {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fldl {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fldl {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fldl {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    foo %st(0) %st(0)
+; CHECK-NEXT:    foo %st %st
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    bar %st(1) %st(0)
+; CHECK-NEXT:    bar %st(1) %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fstp %st(1)
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    baz %st(1) %st(0)
+; CHECK-NEXT:    baz %st(1) %st
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    baz %st(0)
+; CHECK-NEXT:    baz %st
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
 ; Uses the same value twice, should have one fstp after the asm.
   tail call void asm sideeffect "foo $0 $1", "f,f,~{dirflag},~{fpsr},~{flags}"( double %A, double %A ) nounwind
 ; Uses two different values, should be in st(0)/st(1) and both be popped.
   tail call void asm sideeffect "bar $0 $1", "f,f,~{dirflag},~{fpsr},~{flags}"( double %B, double %C ) nounwind
 ; Uses two different values, one of which isn't killed in this asm, it should not be popped after the asm.
   tail call void asm sideeffect "baz $0 $1", "f,f,~{dirflag},~{fpsr},~{flags}"( double %D, double %E ) nounwind
 ; This is the last use of %D, so it should be popped after.
   tail call void asm sideeffect "baz $0", "f,~{dirflag},~{fpsr},~{flags}"( double %D ) nounwind
   ret void
 }
 
 ; PR4185
 ; Passing a non-killed value to asm in {st}.
 ; Make sure it is duped before.
 ; asm kills st(0), so we shouldn't pop anything
 ; A valid alternative would be to remat the constant pool load before each
 ; inline asm.
 define void @testPR4185() {
 ; CHECK-LABEL: testPR4185:
 ; CHECK:       ## %bb.0: ## %return
 ; CHECK-NEXT:    flds LCPI6_0
-; CHECK-NEXT:    fld %st(0)
+; CHECK-NEXT:    fld %st
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistpl %st(0)
+; CHECK-NEXT:    fistpl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistpl %st(0)
+; CHECK-NEXT:    fistpl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    retl
 return:
   call void asm sideeffect "fistpl $0", "{st},~{st}"(double 1.000000e+06)
   call void asm sideeffect "fistpl $0", "{st},~{st}"(double 1.000000e+06)
   ret void
 }
 
 ; Passing a non-killed value through asm in {st}.
 ; Make sure it is not duped before.
 ; Second asm kills st(0), so we shouldn't pop anything
 ; A valid alternative would be to remat the constant pool load before each inline asm.
 define void @testPR4185b() {
 ; CHECK-LABEL: testPR4185b:
 ; CHECK:       ## %bb.0: ## %return
 ; CHECK-NEXT:    flds LCPI7_0
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistl %st(0)
+; CHECK-NEXT:    fistl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistpl %st(0)
+; CHECK-NEXT:    fistpl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    retl
 return:
   call void asm sideeffect "fistl $0", "{st}"(double 1.000000e+06)
   call void asm sideeffect "fistpl $0", "{st},~{st}"(double 1.000000e+06)
   ret void
 }
 
 ; PR4459
 ; The return value from ceil must be duped before being consumed by asm.
 define void @testPR4459(x86_fp80 %a) {
 ; CHECK-LABEL: testPR4459:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    subl $28, %esp
 ; CHECK-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fstpt (%esp)
 ; CHECK-NEXT:    calll _ceil
-; CHECK-NEXT:    fld %st(0)
+; CHECK-NEXT:    fld %st
 ; CHECK-NEXT:    fxch %st(1)
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistpl %st(0)
+; CHECK-NEXT:    fistpl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fstpt (%esp)
 ; CHECK-NEXT:    calll _test3
 ; CHECK-NEXT:    addl $28, %esp
 ; CHECK-NEXT:    retl
 entry:
   %0 = call x86_fp80 @ceil(x86_fp80 %a)
   call void asm sideeffect "fistpl $0", "{st},~{st}"( x86_fp80 %0)
   call void @test3(x86_fp80 %0 )
   ret void
 }
 declare x86_fp80 @ceil(x86_fp80)
 
 ; PR4484
 ; test1 leaves a value on the stack that is needed after the asm.
 ; Load %a from stack after ceil
 ; Set up call to test.
 define void @testPR4484(x86_fp80 %a) {
 ; CHECK-LABEL: testPR4484:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    subl $28, %esp
 ; CHECK-NEXT:    .cfi_def_cfa_offset 32
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
-; CHECK-NEXT:    fstpt {{[0-9]+}}(%esp) ## 10-byte Folded Spill
+; CHECK-NEXT:    fstpt {{[-0-9]+}}(%e{{[sb]}}p) ## 10-byte Folded Spill
 ; CHECK-NEXT:    calll _test1
-; CHECK-NEXT:    fldt {{[0-9]+}}(%esp) ## 10-byte Folded Reload
+; CHECK-NEXT:    fldt {{[-0-9]+}}(%e{{[sb]}}p) ## 10-byte Folded Reload
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistpl %st(0)
+; CHECK-NEXT:    fistpl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fstpt (%esp)
 ; CHECK-NEXT:    calll _test3
 ; CHECK-NEXT:    addl $28, %esp
 ; CHECK-NEXT:    retl
 entry:
   %0 = call x86_fp80 @test1()
   call void asm sideeffect "fistpl $0", "{st},~{st}"(x86_fp80 %a)
   call void @test3(x86_fp80 %0)
   ret void
 }
 
 ; PR4485
 define void @testPR4485(x86_fp80* %a) {
 ; CHECK-LABEL: testPR4485:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-NEXT:    fldt (%eax)
 ; CHECK-NEXT:    flds LCPI10_0
-; CHECK-NEXT:    fmul %st(0), %st(1)
+; CHECK-NEXT:    fmul %st, %st(1)
 ; CHECK-NEXT:    flds LCPI10_1
-; CHECK-NEXT:    fmul %st(0), %st(2)
+; CHECK-NEXT:    fmul %st, %st(2)
 ; CHECK-NEXT:    fxch %st(2)
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistpl %st(0)
+; CHECK-NEXT:    fistpl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fldt (%eax)
 ; CHECK-NEXT:    fmulp %st(1)
 ; CHECK-NEXT:    fmulp %st(1)
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fistpl %st(0)
+; CHECK-NEXT:    fistpl %st
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    retl
 entry:
   %0 = load x86_fp80, x86_fp80* %a, align 16
   %1 = fmul x86_fp80 %0, 0xK4006B400000000000000
   %2 = fmul x86_fp80 %1, 0xK4012F424000000000000
   tail call void asm sideeffect "fistpl $0", "{st},~{st}"(x86_fp80 %2)
   %3 = load x86_fp80, x86_fp80* %a, align 16

 define void @fist1(x86_fp80 %x, i32* %p) nounwind ssp {
 ; CHECK-LABEL: fist1:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    fistl (%eax)
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   tail call void asm sideeffect "fistl $1", "{st},*m,~{memory},~{dirflag},~{fpsr},~{flags}"(x86_fp80 %x, i32* %p) nounwind
   ret void
 }
 
 ; Here, the input operand is tied to an output which means that is is
 ; implicitly popped (and then the output is implicitly pushed).
 ;
 ;   long double fist2(long double x, int *p) {
 ;     long double y;
 ;     asm ("fistl %1" : "=&t"(y) : "0"(x), "m"(*p) : "memory");
 ;     return y;
 ;   }
 define x86_fp80 @fist2(x86_fp80 %x, i32* %p) nounwind ssp {
 ; CHECK-LABEL: fist2:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    fistl (%eax)
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   %0 = tail call x86_fp80 asm "fistl $2", "=&{st},0,*m,~{memory},~{dirflag},~{fpsr},~{flags}"(x86_fp80 %x, i32* %p) nounwind
   ret x86_fp80 %0
 }
 
 ; An 'f' constraint is never implicitly popped:
 ;
 ;   void fucomp1(long double x, long double y) {
 ;     asm volatile ("fucomp %1" : : "t"(x), "f"(y) : "st");
 ;   }
 define void @fucomp1(x86_fp80 %x, x86_fp80 %y) nounwind ssp {
 ; CHECK-LABEL: fucomp1:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fxch %st(1)
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    fucomp %st(1)
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   tail call void asm sideeffect "fucomp $1", "{st},f,~{st},~{dirflag},~{fpsr},~{flags}"(x86_fp80 %x, x86_fp80 %y) nounwind
   ret void
 }
 
 ; The 'u' constraint is only popped implicitly when clobbered:
 ;
 ;   void fucomp2(long double x, long double y) {
 ;     asm volatile ("fucomp %1" : : "t"(x), "u"(y) : "st");
 ;   }
 ;
 ;   void fucomp3(long double x, long double y) {
 ;     asm volatile ("fucompp %1" : : "t"(x), "u"(y) : "st", "st(1)");
 ;   }
 ;
 define void @fucomp2(x86_fp80 %x, x86_fp80 %y) nounwind ssp {
 ; CHECK-LABEL: fucomp2:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fxch %st(1)
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    fucomp %st(1)
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   tail call void asm sideeffect "fucomp $1", "{st},{st(1)},~{st},~{dirflag},~{fpsr},~{flags}"(x86_fp80 %x, x86_fp80 %y) nounwind
   ret void
 }
 
 define void @fucomp3(x86_fp80 %x, x86_fp80 %y) nounwind ssp {
 ; CHECK-LABEL: fucomp3:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    fxch %st(1)
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    fucompp %st(1)
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   tail call void asm sideeffect "fucompp $1", "{st},{st(1)},~{st},~{st(1)},~{dirflag},~{fpsr},~{flags}"(x86_fp80 %x, x86_fp80 %y) nounwind
   ret void
 }
 
 ; One input, two outputs, one dead output.
 %complex = type { float, float }
 define float @sincos1(float %x) nounwind ssp {
 ; CHECK-LABEL: sincos1:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    flds {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    sincos
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fstp %st(1)
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   %0 = tail call %complex asm "sincos", "={st},={st(1)},0,~{dirflag},~{fpsr},~{flags}"(float %x) nounwind
   %asmresult = extractvalue %complex %0, 0
   ret float %asmresult
 }
 
 ; Same thing, swapped output operands.
 define float @sincos2(float %x) nounwind ssp {
 ; CHECK-LABEL: sincos2:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    flds {{[0-9]+}}(%esp)
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    sincos
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fstp %st(1)
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   %0 = tail call %complex asm "sincos", "={st(1)},={st},1,~{dirflag},~{fpsr},~{flags}"(float %x) nounwind
   %asmresult = extractvalue %complex %0, 1
   ret float %asmresult
 }
 
 ; Clobber st(0) after it was live-out/dead from the previous asm.
 ; Load x, make a copy for the second asm.
 ; Discard dead result in st(0), bring x to the top.
 ; x is now in st(0) for the second asm
 ; Discard both results.
 define float @sincos3(float %x) nounwind ssp {
 ; CHECK-LABEL: sincos3:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    flds {{[0-9]+}}(%esp)
-; CHECK-NEXT:    fld %st(0)
+; CHECK-NEXT:    fld %st
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    sincos
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    fxch %st(1)
 ; CHECK-NEXT:    ## InlineAsm Start
 ; CHECK-NEXT:    sincos
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fstp %st(1)
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   %0 = tail call %complex asm sideeffect "sincos", "={st(1)},={st},1,~{dirflag},~{fpsr},~{flags}"(float %x) nounwind
   %1 = tail call %complex asm sideeffect "sincos", "={st(1)},={st},1,~{dirflag},~{fpsr},~{flags}"(float %x) nounwind
   %asmresult = extractvalue %complex %0, 0
   ret float %asmresult
 }
 
 ; Pass the same value in two fixed stack slots.
 define i32 @PR10602() nounwind ssp {
 ; CHECK-LABEL: PR10602:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    flds LCPI19_0
-; CHECK-NEXT:    fld %st(0)
+; CHECK-NEXT:    fld %st
 ; CHECK-NEXT:    fxch %st(1)
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    fcomi %st(1), %st(0); pushf; pop %eax
+; CHECK-NEXT:    fcomi %st(1), %st; pushf; pop %eax
 ; CHECK-NEXT:    ## InlineAsm End
-; CHECK-NEXT:    fstp %st(0)
-; CHECK-NEXT:    fstp %st(0)
+; CHECK-NEXT:    fstp %st
+; CHECK-NEXT:    fstp %st
 ; CHECK-NEXT:    retl
-; CHECK-NEXT:    ## -- End function
 entry:
   %0 = tail call i32 asm "fcomi $2, $1; pushf; pop $0", "=r,{st},{st(1)},~{dirflag},~{fpsr},~{flags}"(double 2.000000e+00, double 2.000000e+00) nounwind
   ret i32 %0
 }
 
 ; <rdar://problem/16952634>
 ; X87 stackifier asserted when there was an ST register defined by an
 ; inline-asm instruction and the ST register was live across another
return:
   ret void
 }
 
 ; Check that x87 stackifier is correctly rewriting FP registers to ST registers.
 define double @test_operand_rewrite() {
 ; CHECK-LABEL: test_operand_rewrite:
 ; CHECK:       ## %bb.0: ## %entry
 ; CHECK-NEXT:    ## InlineAsm Start
-; CHECK-NEXT:    foo %st(0), %st(1)
+; CHECK-NEXT:    foo %st, %st(1)
 ; CHECK-NEXT:    ## InlineAsm End
 ; CHECK-NEXT:    fsubp %st(1)
 ; CHECK-NEXT:    retl
 entry:
   %0 = tail call { double, double } asm sideeffect "foo $0, $1", "={st},={st(1)},~{dirflag},~{fpsr},~{flags}"()
   %asmresult = extractvalue { double, double } %0, 0
   %asmresult1 = extractvalue { double, double } %0, 1
   %sub = fsub double %asmresult, %asmresult1
   ret double %sub
 }

llvm/trunk/test/CodeGen/X86/pr13577.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-darwin | FileCheck %s
 
 ; CHECK-LABEL: LCPI0_0:
 ; CHECK-NEXT: .long 4286578688
 ; CHECK-LABEL: LCPI0_1:
 ; CHECK-NEXT: .long 2139095040
 
 define x86_fp80 @foo(x86_fp80 %a) {
 ; CHECK-LABEL: foo:
 ; CHECK:       ## %bb.0:
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    fstpt -{{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    testb $-128, -{{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    flds {{.*}}(%rip)
 ; CHECK-NEXT:    flds {{.*}}(%rip)
-; CHECK-NEXT:    fcmovne %st(1), %st(0)
+; CHECK-NEXT:    fcmovne %st(1), %st
 ; CHECK-NEXT:    fstp %st(1)
 ; CHECK-NEXT:    retq
   %1 = tail call x86_fp80 @copysignl(x86_fp80 0xK7FFF8000000000000000, x86_fp80 %a) nounwind readnone
   ret x86_fp80 %1
 }
 
 declare x86_fp80 @copysignl(x86_fp80, x86_fp80) nounwind readnone
 

llvm/trunk/test/CodeGen/X86/pr33349.ll

 ; KNL-NEXT:    kshiftrw $1, %k0, %k1
 ; KNL-NEXT:    kmovw %k1, %eax
 ; KNL-NEXT:    kshiftrw $2, %k0, %k1
 ; KNL-NEXT:    kshiftrw $1, %k1, %k2
 ; KNL-NEXT:    kmovw %k1, %ecx
 ; KNL-NEXT:    testb $1, %al
 ; KNL-NEXT:    fld1
 ; KNL-NEXT:    fldz
-; KNL-NEXT:    fld %st(0)
-; KNL-NEXT:    fcmovne %st(2), %st(0)
+; KNL-NEXT:    fld %st
+; KNL-NEXT:    fcmovne %st(2), %st
 ; KNL-NEXT:    testb $1, %cl
 ; KNL-NEXT:    fld %st(1)
-; KNL-NEXT:    fcmovne %st(3), %st(0)
+; KNL-NEXT:    fcmovne %st(3), %st
 ; KNL-NEXT:    kmovw %k2, %eax
 ; KNL-NEXT:    testb $1, %al
 ; KNL-NEXT:    fld %st(2)
-; KNL-NEXT:    fcmovne %st(4), %st(0)
+; KNL-NEXT:    fcmovne %st(4), %st
 ; KNL-NEXT:    kmovw %k0, %eax
 ; KNL-NEXT:    testb $1, %al
 ; KNL-NEXT:    fxch %st(3)
-; KNL-NEXT:    fcmovne %st(4), %st(0)
+; KNL-NEXT:    fcmovne %st(4), %st
 ; KNL-NEXT:    fstp %st(4)
 ; KNL-NEXT:    fxch %st(3)
 ; KNL-NEXT:    fstpt (%rdi)
 ; KNL-NEXT:    fxch %st(1)
 ; KNL-NEXT:    fstpt 30(%rdi)
 ; KNL-NEXT:    fxch %st(1)
 ; KNL-NEXT:    fstpt 20(%rdi)
 ; KNL-NEXT:    fstpt 10(%rdi)
 ; KNL-NEXT:    vzeroupper
 ; KNL-NEXT:    retq
 ;
 ; SKX-LABEL: test:
 ; SKX:       # %bb.0: # %bb
 ; SKX-NEXT:    vpslld $31, %xmm0, %xmm0
 ; SKX-NEXT:    vpmovd2m %xmm0, %k0
 ; SKX-NEXT:    kshiftrb $1, %k0, %k1
 ; SKX-NEXT:    kmovd %k1, %eax
 ; SKX-NEXT:    kshiftrb $2, %k0, %k1
 ; SKX-NEXT:    kshiftrb $1, %k1, %k2
 ; SKX-NEXT:    kmovd %k1, %ecx
 ; SKX-NEXT:    testb $1, %al
 ; SKX-NEXT:    fld1
 ; SKX-NEXT:    fldz
-; SKX-NEXT:    fld %st(0)
-; SKX-NEXT:    fcmovne %st(2), %st(0)
+; SKX-NEXT:    fld %st
+; SKX-NEXT:    fcmovne %st(2), %st
 ; SKX-NEXT:    testb $1, %cl
 ; SKX-NEXT:    fld %st(1)
-; SKX-NEXT:    fcmovne %st(3), %st(0)
+; SKX-NEXT:    fcmovne %st(3), %st
 ; SKX-NEXT:    kmovd %k2, %eax
 ; SKX-NEXT:    testb $1, %al
 ; SKX-NEXT:    fld %st(2)
-; SKX-NEXT:    fcmovne %st(4), %st(0)
+; SKX-NEXT:    fcmovne %st(4), %st
 ; SKX-NEXT:    kmovd %k0, %eax
 ; SKX-NEXT:    testb $1, %al
 ; SKX-NEXT:    fxch %st(3)
-; SKX-NEXT:    fcmovne %st(4), %st(0)
+; SKX-NEXT:    fcmovne %st(4), %st
 ; SKX-NEXT:    fstp %st(4)
 ; SKX-NEXT:    fxch %st(3)
 ; SKX-NEXT:    fstpt (%rdi)
 ; SKX-NEXT:    fxch %st(1)
 ; SKX-NEXT:    fstpt 30(%rdi)
 ; SKX-NEXT:    fxch %st(1)
 ; SKX-NEXT:    fstpt 20(%rdi)
 ; SKX-NEXT:    fstpt 10(%rdi)
 ; SKX-NEXT:    retq
  bb:
    %tmp = select <4 x i1> %m, <4 x x86_fp80> <x86_fp80 0xK3FFF8000000000000000, x86_fp80 0xK3FFF8000000000000000, x86_fp80 0xK3FFF8000000000000000, x86_fp80             0xK3FFF8000000000000000>, <4 x x86_fp80> zeroinitializer
    store <4 x x86_fp80> %tmp, <4 x x86_fp80>* %p, align 16
    ret void
  }
 

llvm/trunk/test/CodeGen/X86/pr34080.ll

 ; SSE2-NEXT:    movw %ax, -4(%rbp)
 ; SSE2-NEXT:    fistl -8(%rbp)
 ; SSE2-NEXT:    fldcw -4(%rbp)
 ; SSE2-NEXT:    cvtsi2sdl -8(%rbp), %xmm0
 ; SSE2-NEXT:    movsd %xmm0, -64(%rbp)
 ; SSE2-NEXT:    movsd %xmm0, -32(%rbp)
 ; SSE2-NEXT:    fsubl -32(%rbp)
 ; SSE2-NEXT:    flds {{.*}}(%rip)
-; SSE2-NEXT:    fmul %st(0), %st(1)
+; SSE2-NEXT:    fmul %st, %st(1)
 ; SSE2-NEXT:    fnstcw -2(%rbp)
 ; SSE2-NEXT:    movzwl -2(%rbp), %eax
 ; SSE2-NEXT:    movw $3199, -2(%rbp) ## imm = 0xC7F
 ; SSE2-NEXT:    fldcw -2(%rbp)
 ; SSE2-NEXT:    movw %ax, -2(%rbp)
 ; SSE2-NEXT:    fxch %st(1)
 ; SSE2-NEXT:    fistl -12(%rbp)
 ; SSE2-NEXT:    fldcw -2(%rbp)

 ; SSE2-SCHEDULE-NEXT:    movsd %xmm0, -64(%rbp)
 ; SSE2-SCHEDULE-NEXT:    movsd %xmm0, -32(%rbp)
 ; SSE2-SCHEDULE-NEXT:    fsubl -32(%rbp)
 ; SSE2-SCHEDULE-NEXT:    fnstcw -2(%rbp)
 ; SSE2-SCHEDULE-NEXT:    flds {{.*}}(%rip)
 ; SSE2-SCHEDULE-NEXT:    movzwl -2(%rbp), %eax
 ; SSE2-SCHEDULE-NEXT:    movw $3199, -2(%rbp) ## imm = 0xC7F
 ; SSE2-SCHEDULE-NEXT:    fldcw -2(%rbp)
-; SSE2-SCHEDULE-NEXT:    fmul %st(0), %st(1)
+; SSE2-SCHEDULE-NEXT:    fmul %st, %st(1)
 ; SSE2-SCHEDULE-NEXT:    movw %ax, -2(%rbp)
 ; SSE2-SCHEDULE-NEXT:    fxch %st(1)
 ; SSE2-SCHEDULE-NEXT:    fistl -12(%rbp)
 ; SSE2-SCHEDULE-NEXT:    fldcw -2(%rbp)
 ; SSE2-SCHEDULE-NEXT:    xorps %xmm0, %xmm0
 ; SSE2-SCHEDULE-NEXT:    cvtsi2sdl -12(%rbp), %xmm0
 ; SSE2-SCHEDULE-NEXT:    movsd %xmm0, -56(%rbp)
 ; SSE2-SCHEDULE-NEXT:    movsd %xmm0, -24(%rbp)
 ; SSE2-SCHEDULE-NEXT:    fsubl -24(%rbp)
 ; SSE2-SCHEDULE-NEXT:    fmulp %st(1)
 ; SSE2-SCHEDULE-NEXT:    fstpl -48(%rbp)
 ; SSE2-SCHEDULE-NEXT:    popq %rbp
 ; SSE2-SCHEDULE-NEXT:    retq
 ;
 ; SSE3-LABEL: _Z1fe:
 ; SSE3:       ## %bb.0: ## %entry
 ; SSE3-NEXT:    pushq %rbp
 ; SSE3-NEXT:    .cfi_def_cfa_offset 16
 ; SSE3-NEXT:    .cfi_offset %rbp, -16
 ; SSE3-NEXT:    movq %rsp, %rbp
 ; SSE3-NEXT:    .cfi_def_cfa_register %rbp
 ; SSE3-NEXT:    fldt 16(%rbp)
-; SSE3-NEXT:    fld %st(0)
+; SSE3-NEXT:    fld %st
 ; SSE3-NEXT:    fisttpl -4(%rbp)
 ; SSE3-NEXT:    cvtsi2sdl -4(%rbp), %xmm0
 ; SSE3-NEXT:    movsd %xmm0, -48(%rbp)
 ; SSE3-NEXT:    movsd %xmm0, -24(%rbp)
 ; SSE3-NEXT:    fsubl -24(%rbp)
 ; SSE3-NEXT:    flds {{.*}}(%rip)
-; SSE3-NEXT:    fmul %st(0), %st(1)
+; SSE3-NEXT:    fmul %st, %st(1)
 ; SSE3-NEXT:    fld %st(1)
 ; SSE3-NEXT:    fisttpl -8(%rbp)
 ; SSE3-NEXT:    xorps %xmm0, %xmm0
 ; SSE3-NEXT:    cvtsi2sdl -8(%rbp), %xmm0
 ; SSE3-NEXT:    movsd %xmm0, -40(%rbp)
 ; SSE3-NEXT:    movsd %xmm0, -16(%rbp)
 ; SSE3-NEXT:    fxch %st(1)
 ; SSE3-NEXT:    fsubl -16(%rbp)
 ; SSE3-NEXT:    fmulp %st(1)
 ; SSE3-NEXT:    fstpl -32(%rbp)
 ; SSE3-NEXT:    popq %rbp
 ; SSE3-NEXT:    retq
 ;
 ; AVX-LABEL: _Z1fe:
 ; AVX:       ## %bb.0: ## %entry
 ; AVX-NEXT:    pushq %rbp
 ; AVX-NEXT:    .cfi_def_cfa_offset 16
 ; AVX-NEXT:    .cfi_offset %rbp, -16
 ; AVX-NEXT:    movq %rsp, %rbp
 ; AVX-NEXT:    .cfi_def_cfa_register %rbp
 ; AVX-NEXT:    fldt 16(%rbp)
-; AVX-NEXT:    fld %st(0)
+; AVX-NEXT:    fld %st
 ; AVX-NEXT:    fisttpl -4(%rbp)
 ; AVX-NEXT:    vcvtsi2sdl -4(%rbp), %xmm0, %xmm0
 ; AVX-NEXT:    vmovsd %xmm0, -48(%rbp)
 ; AVX-NEXT:    vmovsd %xmm0, -24(%rbp)
 ; AVX-NEXT:    fsubl -24(%rbp)
 ; AVX-NEXT:    flds {{.*}}(%rip)
-; AVX-NEXT:    fmul %st(0), %st(1)
+; AVX-NEXT:    fmul %st, %st(1)
 ; AVX-NEXT:    fld %st(1)
 ; AVX-NEXT:    fisttpl -8(%rbp)
 ; AVX-NEXT:    vcvtsi2sdl -8(%rbp), %xmm1, %xmm0
 ; AVX-NEXT:    vmovsd %xmm0, -40(%rbp)
 ; AVX-NEXT:    vmovsd %xmm0, -16(%rbp)
 ; AVX-NEXT:    fxch %st(1)
 ; AVX-NEXT:    fsubl -16(%rbp)
 ; AVX-NEXT:    fmulp %st(1)

llvm/trunk/test/CodeGen/X86/pr34177.ll

 ; CHECK-NEXT:    vextracti128 $1, %ymm0, %xmm2
 ; CHECK-NEXT:    vmovq %xmm2, %rdx
 ; CHECK-NEXT:    vpextrq $1, %xmm1, %rsi
 ; CHECK-NEXT:    vpextrq $1, %xmm2, %rax
 ; CHECK-NEXT:    vmovq %xmm0, %rcx
 ; CHECK-NEXT:    negq %rcx
 ; CHECK-NEXT:    fld1
 ; CHECK-NEXT:    fldz
-; CHECK-NEXT:    fld %st(0)
-; CHECK-NEXT:    fcmove %st(2), %st(0)
+; CHECK-NEXT:    fld %st
+; CHECK-NEXT:    fcmove %st(2), %st
 ; CHECK-NEXT:    cmpq %rax, %rsi
 ; CHECK-NEXT:    fld %st(1)
-; CHECK-NEXT:    fcmove %st(3), %st(0)
+; CHECK-NEXT:    fcmove %st(3), %st
 ; CHECK-NEXT:    cmpq %rdx, %r9
 ; CHECK-NEXT:    fld %st(2)
-; CHECK-NEXT:    fcmove %st(4), %st(0)
+; CHECK-NEXT:    fcmove %st(4), %st
 ; CHECK-NEXT:    movl $1, %eax
 ; CHECK-NEXT:    cmpq %r8, %rax
 ; CHECK-NEXT:    fxch %st(3)
-; CHECK-NEXT:    fcmove %st(4), %st(0)
+; CHECK-NEXT:    fcmove %st(4), %st
 ; CHECK-NEXT:    fstp %st(4)
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    fstpt 70(%rdi)
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    fstpt 50(%rdi)
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    fstpt 30(%rdi)
 ; CHECK-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    fstpt 10(%rdi)
-; CHECK-NEXT:    fadd %st(0), %st(0)
+; CHECK-NEXT:    fadd %st, %st
 ; CHECK-NEXT:    fstpt 60(%rdi)
 ; CHECK-NEXT:    fxch %st(1)
-; CHECK-NEXT:    fadd %st(0), %st(0)
+; CHECK-NEXT:    fadd %st, %st
 ; CHECK-NEXT:    fstpt 40(%rdi)
 ; CHECK-NEXT:    fxch %st(1)
-; CHECK-NEXT:    fadd %st(0), %st(0)
+; CHECK-NEXT:    fadd %st, %st
 ; CHECK-NEXT:    fstpt 20(%rdi)
-; CHECK-NEXT:    fadd %st(0), %st(0)
+; CHECK-NEXT:    fadd %st, %st
 ; CHECK-NEXT:    fstpt (%rdi)
   %1 = icmp eq <4 x i64> <i64 0, i64 1, i64 2, i64 3>, %a
   %2 = select <4 x i1> %1, <4 x x86_fp80> <x86_fp80 0xK3FFF8000000000000000, x86_fp80 0xK3FFF8000000000000000, x86_fp80 0xK3FFF8000000000000000, x86_fp80 0xK3FFF8000000000000000>, <4 x x86_fp80> zeroinitializer
   %3 = fadd <4 x x86_fp80> %2, %2
   %4 = shufflevector <4 x x86_fp80> %3, <4 x x86_fp80> %b, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
   store <8 x x86_fp80> %4, <8 x x86_fp80>* %c, align 16
   unreachable
 }

llvm/trunk/test/CodeGen/X86/scalar-fp-to-i64.ll

 ; X87_WIN-NEXT:    fnstsw %ax
 ; X87_WIN-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X87_WIN-NEXT:    sahf
 ; X87_WIN-NEXT:    ja LBB0_2
 ; X87_WIN-NEXT:  # %bb.1:
 ; X87_WIN-NEXT:    fstp %st(1)
 ; X87_WIN-NEXT:    fldz
 ; X87_WIN-NEXT:  LBB0_2:
-; X87_WIN-NEXT:    fstp %st(0)
+; X87_WIN-NEXT:    fstp %st
 ; X87_WIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X87_WIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X87_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    setbe %al

 ; X87_LIN-NEXT:    fnstsw %ax
 ; X87_LIN-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X87_LIN-NEXT:    sahf
 ; X87_LIN-NEXT:    ja .LBB0_2
 ; X87_LIN-NEXT:  # %bb.1:
 ; X87_LIN-NEXT:    fstp %st(1)
 ; X87_LIN-NEXT:    fldz
 ; X87_LIN-NEXT:  .LBB0_2:
-; X87_LIN-NEXT:    fstp %st(0)
+; X87_LIN-NEXT:    fstp %st
 ; X87_LIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X87_LIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X87_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    setbe %al

 ; X87_WIN-NEXT:    fnstsw %ax
 ; X87_WIN-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X87_WIN-NEXT:    sahf
 ; X87_WIN-NEXT:    ja LBB2_2
 ; X87_WIN-NEXT:  # %bb.1:
 ; X87_WIN-NEXT:    fstp %st(1)
 ; X87_WIN-NEXT:    fldz
 ; X87_WIN-NEXT:  LBB2_2:
-; X87_WIN-NEXT:    fstp %st(0)
+; X87_WIN-NEXT:    fstp %st
 ; X87_WIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X87_WIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X87_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    setbe %al

 ; X87_LIN-NEXT:    fnstsw %ax
 ; X87_LIN-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X87_LIN-NEXT:    sahf
 ; X87_LIN-NEXT:    ja .LBB2_2
 ; X87_LIN-NEXT:  # %bb.1:
 ; X87_LIN-NEXT:    fstp %st(1)
 ; X87_LIN-NEXT:    fldz
 ; X87_LIN-NEXT:  .LBB2_2:
-; X87_LIN-NEXT:    fstp %st(0)
+; X87_LIN-NEXT:    fstp %st
 ; X87_LIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X87_LIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X87_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    setbe %al

 ; AVX512_32_WIN-NEXT:    subl $8, %esp
 ; AVX512_32_WIN-NEXT:    fldt 8(%ebp)
 ; AVX512_32_WIN-NEXT:    flds __real@5f000000
 ; AVX512_32_WIN-NEXT:    fld %st(1)
 ; AVX512_32_WIN-NEXT:    fsub %st(1)
 ; AVX512_32_WIN-NEXT:    xorl %edx, %edx
 ; AVX512_32_WIN-NEXT:    fxch %st(1)
 ; AVX512_32_WIN-NEXT:    fucompi %st(2)
-; AVX512_32_WIN-NEXT:    fcmovnbe %st(1), %st(0)
+; AVX512_32_WIN-NEXT:    fcmovnbe %st(1), %st
 ; AVX512_32_WIN-NEXT:    fstp %st(1)
 ; AVX512_32_WIN-NEXT:    fisttpll (%esp)
 ; AVX512_32_WIN-NEXT:    setbe %dl
 ; AVX512_32_WIN-NEXT:    shll $31, %edx
 ; AVX512_32_WIN-NEXT:    xorl {{[0-9]+}}(%esp), %edx
 ; AVX512_32_WIN-NEXT:    movl (%esp), %eax
 ; AVX512_32_WIN-NEXT:    movl %ebp, %esp
 ; AVX512_32_WIN-NEXT:    popl %ebp
 ; AVX512_32_WIN-NEXT:    retl
 ;
 ; AVX512_32_LIN-LABEL: x_to_u64:
 ; AVX512_32_LIN:       # %bb.0:
 ; AVX512_32_LIN-NEXT:    subl $12, %esp
 ; AVX512_32_LIN-NEXT:    fldt {{[0-9]+}}(%esp)
 ; AVX512_32_LIN-NEXT:    flds {{\.LCPI.*}}
 ; AVX512_32_LIN-NEXT:    fld %st(1)
 ; AVX512_32_LIN-NEXT:    fsub %st(1)
 ; AVX512_32_LIN-NEXT:    xorl %edx, %edx
 ; AVX512_32_LIN-NEXT:    fxch %st(1)
 ; AVX512_32_LIN-NEXT:    fucompi %st(2)
-; AVX512_32_LIN-NEXT:    fcmovnbe %st(1), %st(0)
+; AVX512_32_LIN-NEXT:    fcmovnbe %st(1), %st
 ; AVX512_32_LIN-NEXT:    fstp %st(1)
 ; AVX512_32_LIN-NEXT:    fisttpll (%esp)
 ; AVX512_32_LIN-NEXT:    setbe %dl
 ; AVX512_32_LIN-NEXT:    shll $31, %edx
 ; AVX512_32_LIN-NEXT:    xorl {{[0-9]+}}(%esp), %edx
 ; AVX512_32_LIN-NEXT:    movl (%esp), %eax
 ; AVX512_32_LIN-NEXT:    addl $12, %esp
 ; AVX512_32_LIN-NEXT:    retl
 ;
 ; AVX512_64_WIN-LABEL: x_to_u64:
 ; AVX512_64_WIN:       # %bb.0:
 ; AVX512_64_WIN-NEXT:    pushq %rax
 ; AVX512_64_WIN-NEXT:    fldt (%rcx)
 ; AVX512_64_WIN-NEXT:    flds __real@{{.*}}(%rip)
 ; AVX512_64_WIN-NEXT:    fld %st(1)
 ; AVX512_64_WIN-NEXT:    fsub %st(1)
 ; AVX512_64_WIN-NEXT:    xorl %ecx, %ecx
 ; AVX512_64_WIN-NEXT:    fxch %st(1)
 ; AVX512_64_WIN-NEXT:    fucompi %st(2)
-; AVX512_64_WIN-NEXT:    fcmovnbe %st(1), %st(0)
+; AVX512_64_WIN-NEXT:    fcmovnbe %st(1), %st
 ; AVX512_64_WIN-NEXT:    fstp %st(1)
 ; AVX512_64_WIN-NEXT:    fisttpll (%rsp)
 ; AVX512_64_WIN-NEXT:    setbe %cl
 ; AVX512_64_WIN-NEXT:    shll $31, %ecx
 ; AVX512_64_WIN-NEXT:    xorl {{[0-9]+}}(%rsp), %ecx
 ; AVX512_64_WIN-NEXT:    shlq $32, %rcx
 ; AVX512_64_WIN-NEXT:    movl (%rsp), %eax
 ; AVX512_64_WIN-NEXT:    orq %rcx, %rax
 ; AVX512_64_WIN-NEXT:    popq %rcx
 ; AVX512_64_WIN-NEXT:    retq
 ;
 ; AVX512_64_LIN-LABEL: x_to_u64:
 ; AVX512_64_LIN:       # %bb.0:
 ; AVX512_64_LIN-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; AVX512_64_LIN-NEXT:    flds {{.*}}(%rip)
 ; AVX512_64_LIN-NEXT:    fld %st(1)
 ; AVX512_64_LIN-NEXT:    fsub %st(1)
 ; AVX512_64_LIN-NEXT:    xorl %ecx, %ecx
 ; AVX512_64_LIN-NEXT:    fxch %st(1)
 ; AVX512_64_LIN-NEXT:    fucompi %st(2)
-; AVX512_64_LIN-NEXT:    fcmovnbe %st(1), %st(0)
+; AVX512_64_LIN-NEXT:    fcmovnbe %st(1), %st
 ; AVX512_64_LIN-NEXT:    fstp %st(1)
 ; AVX512_64_LIN-NEXT:    fisttpll -{{[0-9]+}}(%rsp)
 ; AVX512_64_LIN-NEXT:    setbe %cl
 ; AVX512_64_LIN-NEXT:    shll $31, %ecx
 ; AVX512_64_LIN-NEXT:    xorl -{{[0-9]+}}(%rsp), %ecx
 ; AVX512_64_LIN-NEXT:    shlq $32, %rcx
 ; AVX512_64_LIN-NEXT:    movl -{{[0-9]+}}(%rsp), %eax
 ; AVX512_64_LIN-NEXT:    orq %rcx, %rax
 ; AVX512_64_LIN-NEXT:    retq
 ;
 ; SSE3_32_WIN-LABEL: x_to_u64:
 ; SSE3_32_WIN:       # %bb.0:
 ; SSE3_32_WIN-NEXT:    pushl %ebp
 ; SSE3_32_WIN-NEXT:    movl %esp, %ebp
 ; SSE3_32_WIN-NEXT:    andl $-8, %esp
 ; SSE3_32_WIN-NEXT:    subl $8, %esp
 ; SSE3_32_WIN-NEXT:    fldt 8(%ebp)
 ; SSE3_32_WIN-NEXT:    flds __real@5f000000
 ; SSE3_32_WIN-NEXT:    fld %st(1)
 ; SSE3_32_WIN-NEXT:    fsub %st(1)
 ; SSE3_32_WIN-NEXT:    xorl %edx, %edx
 ; SSE3_32_WIN-NEXT:    fxch %st(1)
 ; SSE3_32_WIN-NEXT:    fucompi %st(2)
-; SSE3_32_WIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE3_32_WIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE3_32_WIN-NEXT:    fstp %st(1)
 ; SSE3_32_WIN-NEXT:    fisttpll (%esp)
 ; SSE3_32_WIN-NEXT:    setbe %dl
 ; SSE3_32_WIN-NEXT:    shll $31, %edx
 ; SSE3_32_WIN-NEXT:    xorl {{[0-9]+}}(%esp), %edx
 ; SSE3_32_WIN-NEXT:    movl (%esp), %eax
 ; SSE3_32_WIN-NEXT:    movl %ebp, %esp
 ; SSE3_32_WIN-NEXT:    popl %ebp
 ; SSE3_32_WIN-NEXT:    retl
 ;
 ; SSE3_32_LIN-LABEL: x_to_u64:
 ; SSE3_32_LIN:       # %bb.0:
 ; SSE3_32_LIN-NEXT:    subl $12, %esp
 ; SSE3_32_LIN-NEXT:    fldt {{[0-9]+}}(%esp)
 ; SSE3_32_LIN-NEXT:    flds {{\.LCPI.*}}
 ; SSE3_32_LIN-NEXT:    fld %st(1)
 ; SSE3_32_LIN-NEXT:    fsub %st(1)
 ; SSE3_32_LIN-NEXT:    xorl %edx, %edx
 ; SSE3_32_LIN-NEXT:    fxch %st(1)
 ; SSE3_32_LIN-NEXT:    fucompi %st(2)
-; SSE3_32_LIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE3_32_LIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE3_32_LIN-NEXT:    fstp %st(1)
 ; SSE3_32_LIN-NEXT:    fisttpll (%esp)
 ; SSE3_32_LIN-NEXT:    setbe %dl
 ; SSE3_32_LIN-NEXT:    shll $31, %edx
 ; SSE3_32_LIN-NEXT:    xorl {{[0-9]+}}(%esp), %edx
 ; SSE3_32_LIN-NEXT:    movl (%esp), %eax
 ; SSE3_32_LIN-NEXT:    addl $12, %esp
 ; SSE3_32_LIN-NEXT:    retl
 ;
 ; SSE3_64_WIN-LABEL: x_to_u64:
 ; SSE3_64_WIN:       # %bb.0:
 ; SSE3_64_WIN-NEXT:    pushq %rax
 ; SSE3_64_WIN-NEXT:    fldt (%rcx)
 ; SSE3_64_WIN-NEXT:    flds __real@{{.*}}(%rip)
 ; SSE3_64_WIN-NEXT:    fld %st(1)
 ; SSE3_64_WIN-NEXT:    fsub %st(1)
 ; SSE3_64_WIN-NEXT:    xorl %eax, %eax
 ; SSE3_64_WIN-NEXT:    fxch %st(1)
 ; SSE3_64_WIN-NEXT:    fucompi %st(2)
-; SSE3_64_WIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE3_64_WIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE3_64_WIN-NEXT:    fstp %st(1)
 ; SSE3_64_WIN-NEXT:    fisttpll (%rsp)
 ; SSE3_64_WIN-NEXT:    setbe %al
 ; SSE3_64_WIN-NEXT:    shlq $63, %rax
 ; SSE3_64_WIN-NEXT:    xorq (%rsp), %rax
 ; SSE3_64_WIN-NEXT:    popq %rcx
 ; SSE3_64_WIN-NEXT:    retq
 ;
 ; SSE3_64_LIN-LABEL: x_to_u64:
 ; SSE3_64_LIN:       # %bb.0:
 ; SSE3_64_LIN-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; SSE3_64_LIN-NEXT:    flds {{.*}}(%rip)
 ; SSE3_64_LIN-NEXT:    fld %st(1)
 ; SSE3_64_LIN-NEXT:    fsub %st(1)
 ; SSE3_64_LIN-NEXT:    xorl %eax, %eax
 ; SSE3_64_LIN-NEXT:    fxch %st(1)
 ; SSE3_64_LIN-NEXT:    fucompi %st(2)
-; SSE3_64_LIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE3_64_LIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE3_64_LIN-NEXT:    fstp %st(1)
 ; SSE3_64_LIN-NEXT:    fisttpll -{{[0-9]+}}(%rsp)
 ; SSE3_64_LIN-NEXT:    setbe %al
 ; SSE3_64_LIN-NEXT:    shlq $63, %rax
 ; SSE3_64_LIN-NEXT:    xorq -{{[0-9]+}}(%rsp), %rax
 ; SSE3_64_LIN-NEXT:    retq
 ;
 ; SSE2_32_WIN-LABEL: x_to_u64:
 ; SSE2_32_WIN:       # %bb.0:
 ; SSE2_32_WIN-NEXT:    pushl %ebp
 ; SSE2_32_WIN-NEXT:    movl %esp, %ebp
 ; SSE2_32_WIN-NEXT:    andl $-8, %esp
 ; SSE2_32_WIN-NEXT:    subl $16, %esp
 ; SSE2_32_WIN-NEXT:    fldt 8(%ebp)
 ; SSE2_32_WIN-NEXT:    flds __real@5f000000
 ; SSE2_32_WIN-NEXT:    fld %st(1)
 ; SSE2_32_WIN-NEXT:    fsub %st(1)
 ; SSE2_32_WIN-NEXT:    xorl %edx, %edx
 ; SSE2_32_WIN-NEXT:    fxch %st(1)
 ; SSE2_32_WIN-NEXT:    fucompi %st(2)
-; SSE2_32_WIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE2_32_WIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE2_32_WIN-NEXT:    fstp %st(1)
 ; SSE2_32_WIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; SSE2_32_WIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; SSE2_32_WIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; SSE2_32_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; SSE2_32_WIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; SSE2_32_WIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; SSE2_32_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)

 ; SSE2_32_LIN-NEXT:    subl $20, %esp
 ; SSE2_32_LIN-NEXT:    fldt {{[0-9]+}}(%esp)
 ; SSE2_32_LIN-NEXT:    flds {{\.LCPI.*}}
 ; SSE2_32_LIN-NEXT:    fld %st(1)
 ; SSE2_32_LIN-NEXT:    fsub %st(1)
 ; SSE2_32_LIN-NEXT:    xorl %edx, %edx
 ; SSE2_32_LIN-NEXT:    fxch %st(1)
 ; SSE2_32_LIN-NEXT:    fucompi %st(2)
-; SSE2_32_LIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE2_32_LIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE2_32_LIN-NEXT:    fstp %st(1)
 ; SSE2_32_LIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; SSE2_32_LIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; SSE2_32_LIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; SSE2_32_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; SSE2_32_LIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; SSE2_32_LIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; SSE2_32_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)

 ; SSE2_64_WIN-NEXT:    subq $16, %rsp
 ; SSE2_64_WIN-NEXT:    fldt (%rcx)
 ; SSE2_64_WIN-NEXT:    flds __real@{{.*}}(%rip)
 ; SSE2_64_WIN-NEXT:    fld %st(1)
 ; SSE2_64_WIN-NEXT:    fsub %st(1)
 ; SSE2_64_WIN-NEXT:    xorl %eax, %eax
 ; SSE2_64_WIN-NEXT:    fxch %st(1)
 ; SSE2_64_WIN-NEXT:    fucompi %st(2)
-; SSE2_64_WIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE2_64_WIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE2_64_WIN-NEXT:    fstp %st(1)
 ; SSE2_64_WIN-NEXT:    fnstcw {{[0-9]+}}(%rsp)
 ; SSE2_64_WIN-NEXT:    movzwl {{[0-9]+}}(%rsp), %ecx
 ; SSE2_64_WIN-NEXT:    movw $3199, {{[0-9]+}}(%rsp) # imm = 0xC7F
 ; SSE2_64_WIN-NEXT:    fldcw {{[0-9]+}}(%rsp)
 ; SSE2_64_WIN-NEXT:    movw %cx, {{[0-9]+}}(%rsp)
 ; SSE2_64_WIN-NEXT:    fistpll {{[0-9]+}}(%rsp)
 ; SSE2_64_WIN-NEXT:    fldcw {{[0-9]+}}(%rsp)
 ; SSE2_64_WIN-NEXT:    setbe %al
 ; SSE2_64_WIN-NEXT:    shlq $63, %rax
 ; SSE2_64_WIN-NEXT:    xorq {{[0-9]+}}(%rsp), %rax
 ; SSE2_64_WIN-NEXT:    addq $16, %rsp
 ; SSE2_64_WIN-NEXT:    retq
 ;
 ; SSE2_64_LIN-LABEL: x_to_u64:
 ; SSE2_64_LIN:       # %bb.0:
 ; SSE2_64_LIN-NEXT:    fldt {{[0-9]+}}(%rsp)
 ; SSE2_64_LIN-NEXT:    flds {{.*}}(%rip)
 ; SSE2_64_LIN-NEXT:    fld %st(1)
 ; SSE2_64_LIN-NEXT:    fsub %st(1)
 ; SSE2_64_LIN-NEXT:    xorl %eax, %eax
 ; SSE2_64_LIN-NEXT:    fxch %st(1)
 ; SSE2_64_LIN-NEXT:    fucompi %st(2)
-; SSE2_64_LIN-NEXT:    fcmovnbe %st(1), %st(0)
+; SSE2_64_LIN-NEXT:    fcmovnbe %st(1), %st
 ; SSE2_64_LIN-NEXT:    fstp %st(1)
 ; SSE2_64_LIN-NEXT:    fnstcw -{{[0-9]+}}(%rsp)
 ; SSE2_64_LIN-NEXT:    movzwl -{{[0-9]+}}(%rsp), %ecx
 ; SSE2_64_LIN-NEXT:    movw $3199, -{{[0-9]+}}(%rsp) # imm = 0xC7F
 ; SSE2_64_LIN-NEXT:    fldcw -{{[0-9]+}}(%rsp)
 ; SSE2_64_LIN-NEXT:    movw %cx, -{{[0-9]+}}(%rsp)
 ; SSE2_64_LIN-NEXT:    fistpll -{{[0-9]+}}(%rsp)
 ; SSE2_64_LIN-NEXT:    fldcw -{{[0-9]+}}(%rsp)

 ; X87_WIN-NEXT:    fnstsw %ax
 ; X87_WIN-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X87_WIN-NEXT:    sahf
 ; X87_WIN-NEXT:    ja LBB4_2
 ; X87_WIN-NEXT:  # %bb.1:
 ; X87_WIN-NEXT:    fstp %st(1)
 ; X87_WIN-NEXT:    fldz
 ; X87_WIN-NEXT:  LBB4_2:
-; X87_WIN-NEXT:    fstp %st(0)
+; X87_WIN-NEXT:    fstp %st
 ; X87_WIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X87_WIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X87_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_WIN-NEXT:    setbe %al

 ; X87_LIN-NEXT:    fnstsw %ax
 ; X87_LIN-NEXT:    # kill: def $ah killed $ah killed $ax
 ; X87_LIN-NEXT:    sahf
 ; X87_LIN-NEXT:    ja .LBB4_2
 ; X87_LIN-NEXT:  # %bb.1:
 ; X87_LIN-NEXT:    fstp %st(1)
 ; X87_LIN-NEXT:    fldz
 ; X87_LIN-NEXT:  .LBB4_2:
-; X87_LIN-NEXT:    fstp %st(0)
+; X87_LIN-NEXT:    fstp %st
 ; X87_LIN-NEXT:    fnstcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    movzwl {{[0-9]+}}(%esp), %eax
 ; X87_LIN-NEXT:    movw $3199, {{[0-9]+}}(%esp) # imm = 0xC7F
 ; X87_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    movw %ax, {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    fistpll {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    fldcw {{[0-9]+}}(%esp)
 ; X87_LIN-NEXT:    setbe %al

llvm/trunk/test/CodeGen/X86/select.ll

 ;
 ; ATHLON-LABEL: test4:
 ; ATHLON:       ## %bb.0: ## %entry
 ; ATHLON-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; ATHLON-NEXT:    fldl {{[0-9]+}}(%esp)
 ; ATHLON-NEXT:    flds LCPI3_0
 ; ATHLON-NEXT:    xorl %ecx, %ecx
 ; ATHLON-NEXT:    fucompi %st(1)
-; ATHLON-NEXT:    fstp %st(0)
+; ATHLON-NEXT:    fstp %st
 ; ATHLON-NEXT:    seta %cl
 ; ATHLON-NEXT:    movsbl (%eax,%ecx,4), %eax
 ; ATHLON-NEXT:    retl
 ;
 ; MCU-LABEL: test4:
 ; MCU:       # %bb.0: # %entry
 ; MCU-NEXT:    movl %eax, %ecx
 ; MCU-NEXT:    fldl {{[0-9]+}}(%esp)

 ; ATHLON:       ## %bb.0:
 ; ATHLON-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; ATHLON-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; ATHLON-NEXT:    flds 12(%ecx)
 ; ATHLON-NEXT:    flds 8(%ecx)
 ; ATHLON-NEXT:    flds 4(%ecx)
 ; ATHLON-NEXT:    flds (%ecx)
 ; ATHLON-NEXT:    flds (%eax)
-; ATHLON-NEXT:    fmul %st(0), %st(0)
+; ATHLON-NEXT:    fmul %st, %st
 ; ATHLON-NEXT:    cmpl $0, {{[0-9]+}}(%esp)
 ; ATHLON-NEXT:    fxch %st(1)
-; ATHLON-NEXT:    fcmove %st(1), %st(0)
+; ATHLON-NEXT:    fcmove %st(1), %st
 ; ATHLON-NEXT:    fstp %st(1)
 ; ATHLON-NEXT:    flds 4(%eax)
-; ATHLON-NEXT:    fmul %st(0), %st(0)
+; ATHLON-NEXT:    fmul %st, %st
 ; ATHLON-NEXT:    fxch %st(2)
-; ATHLON-NEXT:    fcmove %st(2), %st(0)
+; ATHLON-NEXT:    fcmove %st(2), %st
 ; ATHLON-NEXT:    fstp %st(2)
 ; ATHLON-NEXT:    flds 8(%eax)
-; ATHLON-NEXT:    fmul %st(0), %st(0)
+; ATHLON-NEXT:    fmul %st, %st
 ; ATHLON-NEXT:    fxch %st(3)
-; ATHLON-NEXT:    fcmove %st(3), %st(0)
+; ATHLON-NEXT:    fcmove %st(3), %st
 ; ATHLON-NEXT:    fstp %st(3)
 ; ATHLON-NEXT:    flds 12(%eax)
-; ATHLON-NEXT:    fmul %st(0), %st(0)
+; ATHLON-NEXT:    fmul %st, %st
 ; ATHLON-NEXT:    fxch %st(4)
-; ATHLON-NEXT:    fcmove %st(4), %st(0)
+; ATHLON-NEXT:    fcmove %st(4), %st
 ; ATHLON-NEXT:    fstp %st(4)
 ; ATHLON-NEXT:    fxch %st(3)
 ; ATHLON-NEXT:    fstps 12(%ecx)
 ; ATHLON-NEXT:    fxch %st(1)
 ; ATHLON-NEXT:    fstps 8(%ecx)
 ; ATHLON-NEXT:    fstps 4(%ecx)
 ; ATHLON-NEXT:    fstps (%ecx)
 ; ATHLON-NEXT:    retl
 ;
 ; MCU-LABEL: test6:
 ; MCU:       # %bb.0:
 ; MCU-NEXT:    pushl %eax
 ; MCU-NEXT:    flds 12(%edx)
 ; MCU-NEXT:    fstps (%esp) # 4-byte Folded Spill
 ; MCU-NEXT:    flds 8(%edx)
 ; MCU-NEXT:    flds 4(%edx)
 ; MCU-NEXT:    flds (%ecx)
 ; MCU-NEXT:    flds 4(%ecx)
 ; MCU-NEXT:    flds 8(%ecx)
 ; MCU-NEXT:    flds 12(%ecx)
-; MCU-NEXT:    fmul %st(0), %st(0)
+; MCU-NEXT:    fmul %st, %st
 ; MCU-NEXT:    fxch %st(1)
-; MCU-NEXT:    fmul %st(0), %st(0)
+; MCU-NEXT:    fmul %st, %st
 ; MCU-NEXT:    fxch %st(2)
-; MCU-NEXT:    fmul %st(0), %st(0)
+; MCU-NEXT:    fmul %st, %st
 ; MCU-NEXT:    fxch %st(3)
-; MCU-NEXT:    fmul %st(0), %st(0)
+; MCU-NEXT:    fmul %st, %st
 ; MCU-NEXT:    testl %eax, %eax
 ; MCU-NEXT:    flds (%edx)
 ; MCU-NEXT:    je .LBB5_2
 ; MCU-NEXT:  # %bb.1:
 ; MCU-NEXT:    fstp %st(1)
 ; MCU-NEXT:    fstp %st(3)
 ; MCU-NEXT:    fstp %st(1)
-; MCU-NEXT:    fstp %st(0)
+; MCU-NEXT:    fstp %st
 ; MCU-NEXT:    flds (%esp) # 4-byte Folded Reload
 ; MCU-NEXT:    fldz
 ; MCU-NEXT:    fldz
 ; MCU-NEXT:    fldz
 ; MCU-NEXT:    fxch %st(1)
 ; MCU-NEXT:    fxch %st(6)
 ; MCU-NEXT:    fxch %st(1)
 ; MCU-NEXT:    fxch %st(5)
 ; MCU-NEXT:    fxch %st(4)
 ; MCU-NEXT:    fxch %st(1)
 ; MCU-NEXT:    fxch %st(3)
 ; MCU-NEXT:    fxch %st(2)
 ; MCU-NEXT:  .LBB5_2:
-; MCU-NEXT:    fstp %st(0)
+; MCU-NEXT:    fstp %st
 ; MCU-NEXT:    fstp %st(5)
 ; MCU-NEXT:    fstp %st(3)
 ; MCU-NEXT:    fxch %st(2)
 ; MCU-NEXT:    fstps 12(%edx)
 ; MCU-NEXT:    fxch %st(1)
 ; MCU-NEXT:    fstps 8(%edx)
 ; MCU-NEXT:    fstps 4(%edx)
 ; MCU-NEXT:    fstps (%edx)

 ; ATHLON-NEXT:  ## %bb.2: ## %CF250
 ; ATHLON-NEXT:    ## in Loop: Header=BB23_1 Depth=1
 ; ATHLON-NEXT:    jne LBB23_1
 ; ATHLON-NEXT:  ## %bb.3: ## %CF242.preheader
 ; ATHLON-NEXT:    fldz
 ; ATHLON-NEXT:    .p2align 4, 0x90
 ; ATHLON-NEXT:  LBB23_4: ## %CF242
 ; ATHLON-NEXT:    ## =>This Inner Loop Header: Depth=1
-; ATHLON-NEXT:    fucomi %st(0)
+; ATHLON-NEXT:    fucomi %st
 ; ATHLON-NEXT:    jp LBB23_4
 ; ATHLON-NEXT:  ## %bb.5: ## %CF244
-; ATHLON-NEXT:    fstp %st(0)
+; ATHLON-NEXT:    fstp %st
 ; ATHLON-NEXT:    retl
 ;
 ; MCU-LABEL: test19:
 ; MCU:       # %bb.0: # %BB
 ; MCU-NEXT:    movl $-1, %ecx
 ; MCU-NEXT:    movb $1, %al
 ; MCU-NEXT:    .p2align 4, 0x90
 ; MCU-NEXT:  .LBB23_1: # %CF
 ; MCU-NEXT:    # =>This Inner Loop Header: Depth=1
 ; MCU-NEXT:    testb %al, %al
 ; MCU-NEXT:    jne .LBB23_1
 ; MCU-NEXT:  # %bb.2: # %CF250
 ; MCU-NEXT:    # in Loop: Header=BB23_1 Depth=1
 ; MCU-NEXT:    jne .LBB23_1
 ; MCU-NEXT:  # %bb.3: # %CF242.preheader
 ; MCU-NEXT:    fldz
 ; MCU-NEXT:    .p2align 4, 0x90
 ; MCU-NEXT:  .LBB23_4: # %CF242
 ; MCU-NEXT:    # =>This Inner Loop Header: Depth=1
 ; MCU-NEXT:    cmpl %eax, %ecx
-; MCU-NEXT:    fucom %st(0)
+; MCU-NEXT:    fucom %st
 ; MCU-NEXT:    fnstsw %ax
 ; MCU-NEXT:    # kill: def $ah killed $ah killed $ax
 ; MCU-NEXT:    sahf
 ; MCU-NEXT:    jp .LBB23_4
 ; MCU-NEXT:  # %bb.5: # %CF244
-; MCU-NEXT:    fstp %st(0)
+; MCU-NEXT:    fstp %st
 ; MCU-NEXT:    retl
 BB:
   br label %CF
 
 CF:
   %Cmp10 = icmp ule i8 undef, undef
   br i1 %Cmp10, label %CF, label %CF250
 

llvm/trunk/test/CodeGen/X86/sibcall.ll

 
 declare void @f(%struct.foo* noalias sret) nounwind
 
 define void @t16() nounwind ssp {
 ; X86-LABEL: t16:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    calll bar4
-; X86-NEXT:    fstp %st(0)
+; X86-NEXT:    fstp %st
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t16:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    jmp bar4 # TAILCALL
 ;
 ; X32-LABEL: t16:

 declare void @bar5(...)
 
 ; rdar://7774847
 define void @t18() nounwind ssp {
 ; X86-LABEL: t18:
 ; X86:       # %bb.0: # %entry
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    calll bar6
-; X86-NEXT:    fstp %st(0)
+; X86-NEXT:    fstp %st
 ; X86-NEXT:    addl $12, %esp
 ; X86-NEXT:    retl
 ;
 ; X64-LABEL: t18:
 ; X64:       # %bb.0: # %entry
 ; X64-NEXT:    xorl %eax, %eax
 ; X64-NEXT:    jmp bar6 # TAILCALL
 ;

llvm/trunk/test/CodeGen/X86/x87-schedule.ll

 }
 
 define void @test_fadd(float *%a0, double *%a1) optsize {
 ; GENERIC-LABEL: test_fadd:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fadd %st(0), %st(1)
+; GENERIC-NEXT:    fadd %st, %st(1)
 ; GENERIC-NEXT:    fadd %st(2)
 ; GENERIC-NEXT:    fadds (%ecx)
 ; GENERIC-NEXT:    faddl (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fadd:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fadd %st(0), %st(1) # sched: [5:5.00]
+; ATOM-NEXT:    fadd %st, %st(1) # sched: [5:5.00]
 ; ATOM-NEXT:    fadd %st(2) # sched: [5:5.00]
 ; ATOM-NEXT:    fadds (%ecx) # sched: [5:5.00]
 ; ATOM-NEXT:    faddl (%eax) # sched: [5:5.00]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fadd:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; SLM-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; SLM-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; SLM-NEXT:    fadds (%ecx) # sched: [6:1.00]
 ; SLM-NEXT:    faddl (%eax) # sched: [6:1.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fadd:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; SANDY-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; SANDY-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; SANDY-NEXT:    fadds (%ecx) # sched: [10:1.00]
 ; SANDY-NEXT:    faddl (%eax) # sched: [10:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fadd:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; HASWELL-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; HASWELL-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; HASWELL-NEXT:    fadds (%ecx) # sched: [10:1.00]
 ; HASWELL-NEXT:    faddl (%eax) # sched: [10:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fadd:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; BROADWELL-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; BROADWELL-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; BROADWELL-NEXT:    fadds (%ecx) # sched: [9:1.00]
 ; BROADWELL-NEXT:    faddl (%eax) # sched: [9:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fadd:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; SKYLAKE-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; SKYLAKE-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; SKYLAKE-NEXT:    fadds (%ecx) # sched: [10:1.00]
 ; SKYLAKE-NEXT:    faddl (%eax) # sched: [10:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fadd:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; SKX-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; SKX-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; SKX-NEXT:    fadds (%ecx) # sched: [10:1.00]
 ; SKX-NEXT:    faddl (%eax) # sched: [10:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fadd:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fadd %st(0), %st(1) # sched: [5:1.00]
+; BDVER2-NEXT:    fadd %st, %st(1) # sched: [5:1.00]
 ; BDVER2-NEXT:    fadd %st(2) # sched: [5:1.00]
 ; BDVER2-NEXT:    fadds (%ecx) # sched: [10:1.00]
 ; BDVER2-NEXT:    faddl (%eax) # sched: [10:1.00]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fadd:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; BTVER2-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; BTVER2-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; BTVER2-NEXT:    fadds (%ecx) # sched: [8:1.00]
 ; BTVER2-NEXT:    faddl (%eax) # sched: [8:1.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fadd:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fadd %st(0), %st(1) # sched: [3:1.00]
+; ZNVER1-NEXT:    fadd %st, %st(1) # sched: [3:1.00]
 ; ZNVER1-NEXT:    fadd %st(2) # sched: [3:1.00]
 ; ZNVER1-NEXT:    fadds (%ecx) # sched: [10:1.00]
 ; ZNVER1-NEXT:    faddl (%eax) # sched: [10:1.00]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fadd %st(0), %st(1) \0A\09 fadd %st(2), %st(0) \0A\09 fadds $0 \0A\09 faddl $1", "*m,*m"(float *%a0, double *%a1) nounwind
   ret void
 }
; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fnclex", ""() nounwind
   ret void
 }
 
 define void @test_fcmov() optsize {
 ; GENERIC-LABEL: test_fcmov:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fcmovb %st(1), %st(0)
-; GENERIC-NEXT:    fcmovbe %st(1), %st(0)
-; GENERIC-NEXT:    fcmove %st(1), %st(0)
-; GENERIC-NEXT:    fcmovnb %st(1), %st(0)
-; GENERIC-NEXT:    fcmovnbe %st(1), %st(0)
-; GENERIC-NEXT:    fcmovne %st(1), %st(0)
-; GENERIC-NEXT:    fcmovnu %st(1), %st(0)
-; GENERIC-NEXT:    fcmovu %st(1), %st(0)
+; GENERIC-NEXT:    fcmovb %st(1), %st
+; GENERIC-NEXT:    fcmovbe %st(1), %st
+; GENERIC-NEXT:    fcmove %st(1), %st
+; GENERIC-NEXT:    fcmovnb %st(1), %st
+; GENERIC-NEXT:    fcmovnbe %st(1), %st
+; GENERIC-NEXT:    fcmovne %st(1), %st
+; GENERIC-NEXT:    fcmovnu %st(1), %st
+; GENERIC-NEXT:    fcmovu %st(1), %st
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fcmov:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fcmovb %st(1), %st(0) # sched: [9:4.50]
-; ATOM-NEXT:    fcmovbe %st(1), %st(0) # sched: [9:4.50]
-; ATOM-NEXT:    fcmove %st(1), %st(0) # sched: [9:4.50]
-; ATOM-NEXT:    fcmovnb %st(1), %st(0) # sched: [9:4.50]
-; ATOM-NEXT:    fcmovnbe %st(1), %st(0) # sched: [9:4.50]
-; ATOM-NEXT:    fcmovne %st(1), %st(0) # sched: [9:4.50]
-; ATOM-NEXT:    fcmovnu %st(1), %st(0) # sched: [9:4.50]
-; ATOM-NEXT:    fcmovu %st(1), %st(0) # sched: [9:4.50]
+; ATOM-NEXT:    fcmovb %st(1), %st # sched: [9:4.50]
+; ATOM-NEXT:    fcmovbe %st(1), %st # sched: [9:4.50]
+; ATOM-NEXT:    fcmove %st(1), %st # sched: [9:4.50]
+; ATOM-NEXT:    fcmovnb %st(1), %st # sched: [9:4.50]
+; ATOM-NEXT:    fcmovnbe %st(1), %st # sched: [9:4.50]
+; ATOM-NEXT:    fcmovne %st(1), %st # sched: [9:4.50]
+; ATOM-NEXT:    fcmovnu %st(1), %st # sched: [9:4.50]
+; ATOM-NEXT:    fcmovu %st(1), %st # sched: [9:4.50]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fcmov:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fcmovb %st(1), %st(0) # sched: [3:1.00]
-; SLM-NEXT:    fcmovbe %st(1), %st(0) # sched: [3:1.00]
-; SLM-NEXT:    fcmove %st(1), %st(0) # sched: [3:1.00]
-; SLM-NEXT:    fcmovnb %st(1), %st(0) # sched: [3:1.00]
-; SLM-NEXT:    fcmovnbe %st(1), %st(0) # sched: [3:1.00]
-; SLM-NEXT:    fcmovne %st(1), %st(0) # sched: [3:1.00]
-; SLM-NEXT:    fcmovnu %st(1), %st(0) # sched: [3:1.00]
-; SLM-NEXT:    fcmovu %st(1), %st(0) # sched: [3:1.00]
+; SLM-NEXT:    fcmovb %st(1), %st # sched: [3:1.00]
+; SLM-NEXT:    fcmovbe %st(1), %st # sched: [3:1.00]
+; SLM-NEXT:    fcmove %st(1), %st # sched: [3:1.00]
+; SLM-NEXT:    fcmovnb %st(1), %st # sched: [3:1.00]
+; SLM-NEXT:    fcmovnbe %st(1), %st # sched: [3:1.00]
+; SLM-NEXT:    fcmovne %st(1), %st # sched: [3:1.00]
+; SLM-NEXT:    fcmovnu %st(1), %st # sched: [3:1.00]
+; SLM-NEXT:    fcmovu %st(1), %st # sched: [3:1.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fcmov:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fcmovb %st(1), %st(0) # sched: [3:2.00]
-; SANDY-NEXT:    fcmovbe %st(1), %st(0) # sched: [3:2.00]
-; SANDY-NEXT:    fcmove %st(1), %st(0) # sched: [3:2.00]
-; SANDY-NEXT:    fcmovnb %st(1), %st(0) # sched: [3:2.00]
-; SANDY-NEXT:    fcmovnbe %st(1), %st(0) # sched: [3:2.00]
-; SANDY-NEXT:    fcmovne %st(1), %st(0) # sched: [3:2.00]
-; SANDY-NEXT:    fcmovnu %st(1), %st(0) # sched: [3:2.00]
-; SANDY-NEXT:    fcmovu %st(1), %st(0) # sched: [3:2.00]
+; SANDY-NEXT:    fcmovb %st(1), %st # sched: [3:2.00]
+; SANDY-NEXT:    fcmovbe %st(1), %st # sched: [3:2.00]
+; SANDY-NEXT:    fcmove %st(1), %st # sched: [3:2.00]
+; SANDY-NEXT:    fcmovnb %st(1), %st # sched: [3:2.00]
+; SANDY-NEXT:    fcmovnbe %st(1), %st # sched: [3:2.00]
+; SANDY-NEXT:    fcmovne %st(1), %st # sched: [3:2.00]
+; SANDY-NEXT:    fcmovnu %st(1), %st # sched: [3:2.00]
+; SANDY-NEXT:    fcmovu %st(1), %st # sched: [3:2.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fcmov:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fcmovb %st(1), %st(0) # sched: [3:1.00]
-; HASWELL-NEXT:    fcmovbe %st(1), %st(0) # sched: [3:1.00]
-; HASWELL-NEXT:    fcmove %st(1), %st(0) # sched: [3:1.00]
-; HASWELL-NEXT:    fcmovnb %st(1), %st(0) # sched: [3:1.00]
-; HASWELL-NEXT:    fcmovnbe %st(1), %st(0) # sched: [3:1.00]
-; HASWELL-NEXT:    fcmovne %st(1), %st(0) # sched: [3:1.00]
-; HASWELL-NEXT:    fcmovnu %st(1), %st(0) # sched: [3:1.00]
-; HASWELL-NEXT:    fcmovu %st(1), %st(0) # sched: [3:1.00]
+; HASWELL-NEXT:    fcmovb %st(1), %st # sched: [3:1.00]
+; HASWELL-NEXT:    fcmovbe %st(1), %st # sched: [3:1.00]
+; HASWELL-NEXT:    fcmove %st(1), %st # sched: [3:1.00]
+; HASWELL-NEXT:    fcmovnb %st(1), %st # sched: [3:1.00]
+; HASWELL-NEXT:    fcmovnbe %st(1), %st # sched: [3:1.00]
+; HASWELL-NEXT:    fcmovne %st(1), %st # sched: [3:1.00]
+; HASWELL-NEXT:    fcmovnu %st(1), %st # sched: [3:1.00]
+; HASWELL-NEXT:    fcmovu %st(1), %st # sched: [3:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fcmov:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fcmovb %st(1), %st(0) # sched: [3:1.00]
-; BROADWELL-NEXT:    fcmovbe %st(1), %st(0) # sched: [3:1.00]
-; BROADWELL-NEXT:    fcmove %st(1), %st(0) # sched: [3:1.00]
-; BROADWELL-NEXT:    fcmovnb %st(1), %st(0) # sched: [3:1.00]
-; BROADWELL-NEXT:    fcmovnbe %st(1), %st(0) # sched: [3:1.00]
-; BROADWELL-NEXT:    fcmovne %st(1), %st(0) # sched: [3:1.00]
-; BROADWELL-NEXT:    fcmovnu %st(1), %st(0) # sched: [3:1.00]
-; BROADWELL-NEXT:    fcmovu %st(1), %st(0) # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmovb %st(1), %st # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmovbe %st(1), %st # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmove %st(1), %st # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmovnb %st(1), %st # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmovnbe %st(1), %st # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmovne %st(1), %st # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmovnu %st(1), %st # sched: [3:1.00]
+; BROADWELL-NEXT:    fcmovu %st(1), %st # sched: [3:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fcmov:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fcmovb %st(1), %st(0) # sched: [3:1.00]
-; SKYLAKE-NEXT:    fcmovbe %st(1), %st(0) # sched: [3:1.00]
-; SKYLAKE-NEXT:    fcmove %st(1), %st(0) # sched: [3:1.00]
-; SKYLAKE-NEXT:    fcmovnb %st(1), %st(0) # sched: [3:1.00]
-; SKYLAKE-NEXT:    fcmovnbe %st(1), %st(0) # sched: [3:1.00]
-; SKYLAKE-NEXT:    fcmovne %st(1), %st(0) # sched: [3:1.00]
-; SKYLAKE-NEXT:    fcmovnu %st(1), %st(0) # sched: [3:1.00]
-; SKYLAKE-NEXT:    fcmovu %st(1), %st(0) # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmovb %st(1), %st # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmovbe %st(1), %st # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmove %st(1), %st # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmovnb %st(1), %st # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmovnbe %st(1), %st # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmovne %st(1), %st # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmovnu %st(1), %st # sched: [3:1.00]
+; SKYLAKE-NEXT:    fcmovu %st(1), %st # sched: [3:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fcmov:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fcmovb %st(1), %st(0) # sched: [3:1.00]
-; SKX-NEXT:    fcmovbe %st(1), %st(0) # sched: [3:1.00]
-; SKX-NEXT:    fcmove %st(1), %st(0) # sched: [3:1.00]
-; SKX-NEXT:    fcmovnb %st(1), %st(0) # sched: [3:1.00]
-; SKX-NEXT:    fcmovnbe %st(1), %st(0) # sched: [3:1.00]
-; SKX-NEXT:    fcmovne %st(1), %st(0) # sched: [3:1.00]
-; SKX-NEXT:    fcmovnu %st(1), %st(0) # sched: [3:1.00]
-; SKX-NEXT:    fcmovu %st(1), %st(0) # sched: [3:1.00]
+; SKX-NEXT:    fcmovb %st(1), %st # sched: [3:1.00]
+; SKX-NEXT:    fcmovbe %st(1), %st # sched: [3:1.00]
+; SKX-NEXT:    fcmove %st(1), %st # sched: [3:1.00]
+; SKX-NEXT:    fcmovnb %st(1), %st # sched: [3:1.00]
+; SKX-NEXT:    fcmovnbe %st(1), %st # sched: [3:1.00]
+; SKX-NEXT:    fcmovne %st(1), %st # sched: [3:1.00]
+; SKX-NEXT:    fcmovnu %st(1), %st # sched: [3:1.00]
+; SKX-NEXT:    fcmovu %st(1), %st # sched: [3:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fcmov:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fcmovb %st(1), %st(0) # sched: [1:1.00]
-; BDVER2-NEXT:    fcmovbe %st(1), %st(0) # sched: [1:1.00]
-; BDVER2-NEXT:    fcmove %st(1), %st(0) # sched: [1:1.00]
-; BDVER2-NEXT:    fcmovnb %st(1), %st(0) # sched: [1:1.00]
-; BDVER2-NEXT:    fcmovnbe %st(1), %st(0) # sched: [1:1.00]
-; BDVER2-NEXT:    fcmovne %st(1), %st(0) # sched: [1:1.00]
-; BDVER2-NEXT:    fcmovnu %st(1), %st(0) # sched: [1:1.00]
-; BDVER2-NEXT:    fcmovu %st(1), %st(0) # sched: [1:1.00]
+; BDVER2-NEXT:    fcmovb %st(1), %st # sched: [1:1.00]
+; BDVER2-NEXT:    fcmovbe %st(1), %st # sched: [1:1.00]
+; BDVER2-NEXT:    fcmove %st(1), %st # sched: [1:1.00]
+; BDVER2-NEXT:    fcmovnb %st(1), %st # sched: [1:1.00]
+; BDVER2-NEXT:    fcmovnbe %st(1), %st # sched: [1:1.00]
+; BDVER2-NEXT:    fcmovne %st(1), %st # sched: [1:1.00]
+; BDVER2-NEXT:    fcmovnu %st(1), %st # sched: [1:1.00]
+; BDVER2-NEXT:    fcmovu %st(1), %st # sched: [1:1.00]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fcmov:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fcmovb %st(1), %st(0) # sched: [3:1.00]
-; BTVER2-NEXT:    fcmovbe %st(1), %st(0) # sched: [3:1.00]
-; BTVER2-NEXT:    fcmove %st(1), %st(0) # sched: [3:1.00]
-; BTVER2-NEXT:    fcmovnb %st(1), %st(0) # sched: [3:1.00]
-; BTVER2-NEXT:    fcmovnbe %st(1), %st(0) # sched: [3:1.00]
-; BTVER2-NEXT:    fcmovne %st(1), %st(0) # sched: [3:1.00]
-; BTVER2-NEXT:    fcmovnu %st(1), %st(0) # sched: [3:1.00]
-; BTVER2-NEXT:    fcmovu %st(1), %st(0) # sched: [3:1.00]
+; BTVER2-NEXT:    fcmovb %st(1), %st # sched: [3:1.00]
+; BTVER2-NEXT:    fcmovbe %st(1), %st # sched: [3:1.00]
+; BTVER2-NEXT:    fcmove %st(1), %st # sched: [3:1.00]
+; BTVER2-NEXT:    fcmovnb %st(1), %st # sched: [3:1.00]
+; BTVER2-NEXT:    fcmovnbe %st(1), %st # sched: [3:1.00]
+; BTVER2-NEXT:    fcmovne %st(1), %st # sched: [3:1.00]
+; BTVER2-NEXT:    fcmovnu %st(1), %st # sched: [3:1.00]
+; BTVER2-NEXT:    fcmovu %st(1), %st # sched: [3:1.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fcmov:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fcmovb %st(1), %st(0) # sched: [100:0.25]
-; ZNVER1-NEXT:    fcmovbe %st(1), %st(0) # sched: [100:0.25]
-; ZNVER1-NEXT:    fcmove %st(1), %st(0) # sched: [100:0.25]
-; ZNVER1-NEXT:    fcmovnb %st(1), %st(0) # sched: [100:0.25]
-; ZNVER1-NEXT:    fcmovnbe %st(1), %st(0) # sched: [100:0.25]
-; ZNVER1-NEXT:    fcmovne %st(1), %st(0) # sched: [100:0.25]
-; ZNVER1-NEXT:    fcmovnu %st(1), %st(0) # sched: [100:0.25]
-; ZNVER1-NEXT:    fcmovu %st(1), %st(0) # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmovb %st(1), %st # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmovbe %st(1), %st # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmove %st(1), %st # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmovnb %st(1), %st # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmovnbe %st(1), %st # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmovne %st(1), %st # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmovnu %st(1), %st # sched: [100:0.25]
+; ZNVER1-NEXT:    fcmovu %st(1), %st # sched: [100:0.25]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fcmovb %st(1), %st(0) \0A\09 fcmovbe %st(1), %st(0) \0A\09 fcmove %st(1), %st(0) \0A\09 fcmovnb %st(1), %st(0) \0A\09 fcmovnbe %st(1), %st(0) \0A\09 fcmovne %st(1), %st(0) \0A\09 fcmovnu %st(1), %st(0) \0A\09 fcmovu %st(1), %st(0)", ""() nounwind
   ret void
 }
 
 define void @test_fcom(float *%a0, double *%a1) optsize {
 ; GENERIC-LABEL: test_fcom:

 }
 
 define void @test_fdiv(float *%a0, double *%a1) optsize {
 ; GENERIC-LABEL: test_fdiv:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fdiv %st(0), %st(1)
+; GENERIC-NEXT:    fdiv %st, %st(1)
 ; GENERIC-NEXT:    fdiv %st(2)
 ; GENERIC-NEXT:    fdivs (%ecx)
 ; GENERIC-NEXT:    fdivl (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fdiv:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fdiv %st(0), %st(1) # sched: [34:17.00]
+; ATOM-NEXT:    fdiv %st, %st(1) # sched: [34:17.00]
 ; ATOM-NEXT:    fdiv %st(2) # sched: [34:17.00]
 ; ATOM-NEXT:    fdivs (%ecx) # sched: [34:17.00]
 ; ATOM-NEXT:    fdivl (%eax) # sched: [34:17.00]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fdiv:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fdiv %st(0), %st(1) # sched: [19:17.00]
+; SLM-NEXT:    fdiv %st, %st(1) # sched: [19:17.00]
 ; SLM-NEXT:    fdiv %st(2) # sched: [19:17.00]
 ; SLM-NEXT:    fdivs (%ecx) # sched: [22:17.00]
 ; SLM-NEXT:    fdivl (%eax) # sched: [22:17.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fdiv:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fdiv %st(0), %st(1) # sched: [14:14.00]
+; SANDY-NEXT:    fdiv %st, %st(1) # sched: [14:14.00]
 ; SANDY-NEXT:    fdiv %st(2) # sched: [14:14.00]
 ; SANDY-NEXT:    fdivs (%ecx) # sched: [31:1.00]
 ; SANDY-NEXT:    fdivl (%eax) # sched: [31:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fdiv:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fdiv %st(0), %st(1) # sched: [24:1.00]
+; HASWELL-NEXT:    fdiv %st, %st(1) # sched: [24:1.00]
 ; HASWELL-NEXT:    fdiv %st(2) # sched: [20:1.00]
 ; HASWELL-NEXT:    fdivs (%ecx) # sched: [31:1.00]
 ; HASWELL-NEXT:    fdivl (%eax) # sched: [31:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fdiv:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fdiv %st(0), %st(1) # sched: [15:1.00]
+; BROADWELL-NEXT:    fdiv %st, %st(1) # sched: [15:1.00]
 ; BROADWELL-NEXT:    fdiv %st(2) # sched: [20:1.00]
 ; BROADWELL-NEXT:    fdivs (%ecx) # sched: [21:1.00]
 ; BROADWELL-NEXT:    fdivl (%eax) # sched: [21:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fdiv:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fdiv %st(0), %st(1) # sched: [15:1.00]
+; SKYLAKE-NEXT:    fdiv %st, %st(1) # sched: [15:1.00]
 ; SKYLAKE-NEXT:    fdiv %st(2) # sched: [20:1.00]
 ; SKYLAKE-NEXT:    fdivs (%ecx) # sched: [22:1.00]
 ; SKYLAKE-NEXT:    fdivl (%eax) # sched: [22:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fdiv:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fdiv %st(0), %st(1) # sched: [15:1.00]
+; SKX-NEXT:    fdiv %st, %st(1) # sched: [15:1.00]
 ; SKX-NEXT:    fdiv %st(2) # sched: [20:1.00]
 ; SKX-NEXT:    fdivs (%ecx) # sched: [22:1.00]
 ; SKX-NEXT:    fdivl (%eax) # sched: [22:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fdiv:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fdiv %st(0), %st(1) # sched: [9:9.50]
+; BDVER2-NEXT:    fdiv %st, %st(1) # sched: [9:9.50]
 ; BDVER2-NEXT:    fdiv %st(2) # sched: [9:9.50]
 ; BDVER2-NEXT:    fdivs (%ecx) # sched: [14:9.50]
 ; BDVER2-NEXT:    fdivl (%eax) # sched: [14:9.50]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fdiv:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fdiv %st(0), %st(1) # sched: [19:19.00]
+; BTVER2-NEXT:    fdiv %st, %st(1) # sched: [19:19.00]
 ; BTVER2-NEXT:    fdiv %st(2) # sched: [19:19.00]
 ; BTVER2-NEXT:    fdivs (%ecx) # sched: [24:19.00]
 ; BTVER2-NEXT:    fdivl (%eax) # sched: [24:19.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fdiv:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fdiv %st(0), %st(1) # sched: [15:1.00]
+; ZNVER1-NEXT:    fdiv %st, %st(1) # sched: [15:1.00]
 ; ZNVER1-NEXT:    fdiv %st(2) # sched: [15:1.00]
 ; ZNVER1-NEXT:    fdivs (%ecx) # sched: [22:1.00]
 ; ZNVER1-NEXT:    fdivl (%eax) # sched: [22:1.00]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fdiv %st(0), %st(1) \0A\09 fdiv %st(2), %st(0) \0A\09 fdivs $0 \0A\09 fdivl $1", "*m,*m"(float *%a0, double *%a1) nounwind
   ret void
 }

 }
 
 define void @test_fdivr(float *%a0, double *%a1) optsize {
 ; GENERIC-LABEL: test_fdivr:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fdivr %st(0), %st(1)
+; GENERIC-NEXT:    fdivr %st, %st(1)
 ; GENERIC-NEXT:    fdivr %st(2)
 ; GENERIC-NEXT:    fdivrs (%ecx)
 ; GENERIC-NEXT:    fdivrl (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fdivr:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fdivr %st(0), %st(1) # sched: [34:17.00]
+; ATOM-NEXT:    fdivr %st, %st(1) # sched: [34:17.00]
 ; ATOM-NEXT:    fdivr %st(2) # sched: [34:17.00]
 ; ATOM-NEXT:    fdivrs (%ecx) # sched: [34:17.00]
 ; ATOM-NEXT:    fdivrl (%eax) # sched: [34:17.00]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fdivr:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fdivr %st(0), %st(1) # sched: [19:17.00]
+; SLM-NEXT:    fdivr %st, %st(1) # sched: [19:17.00]
 ; SLM-NEXT:    fdivr %st(2) # sched: [19:17.00]
 ; SLM-NEXT:    fdivrs (%ecx) # sched: [22:17.00]
 ; SLM-NEXT:    fdivrl (%eax) # sched: [22:17.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fdivr:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fdivr %st(0), %st(1) # sched: [14:14.00]
+; SANDY-NEXT:    fdivr %st, %st(1) # sched: [14:14.00]
 ; SANDY-NEXT:    fdivr %st(2) # sched: [14:14.00]
 ; SANDY-NEXT:    fdivrs (%ecx) # sched: [31:1.00]
 ; SANDY-NEXT:    fdivrl (%eax) # sched: [31:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fdivr:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fdivr %st(0), %st(1) # sched: [20:1.00]
+; HASWELL-NEXT:    fdivr %st, %st(1) # sched: [20:1.00]
 ; HASWELL-NEXT:    fdivr %st(2) # sched: [24:1.00]
 ; HASWELL-NEXT:    fdivrs (%ecx) # sched: [27:1.00]
 ; HASWELL-NEXT:    fdivrl (%eax) # sched: [27:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fdivr:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fdivr %st(0), %st(1) # sched: [20:1.00]
+; BROADWELL-NEXT:    fdivr %st, %st(1) # sched: [20:1.00]
 ; BROADWELL-NEXT:    fdivr %st(2) # sched: [15:1.00]
 ; BROADWELL-NEXT:    fdivrs (%ecx) # sched: [26:1.00]
 ; BROADWELL-NEXT:    fdivrl (%eax) # sched: [26:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fdivr:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fdivr %st(0), %st(1) # sched: [20:1.00]
+; SKYLAKE-NEXT:    fdivr %st, %st(1) # sched: [20:1.00]
 ; SKYLAKE-NEXT:    fdivr %st(2) # sched: [15:1.00]
 ; SKYLAKE-NEXT:    fdivrs (%ecx) # sched: [27:1.00]
 ; SKYLAKE-NEXT:    fdivrl (%eax) # sched: [27:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fdivr:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fdivr %st(0), %st(1) # sched: [20:1.00]
+; SKX-NEXT:    fdivr %st, %st(1) # sched: [20:1.00]
 ; SKX-NEXT:    fdivr %st(2) # sched: [15:1.00]
 ; SKX-NEXT:    fdivrs (%ecx) # sched: [27:1.00]
 ; SKX-NEXT:    fdivrl (%eax) # sched: [27:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fdivr:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fdivr %st(0), %st(1) # sched: [9:9.50]
+; BDVER2-NEXT:    fdivr %st, %st(1) # sched: [9:9.50]
 ; BDVER2-NEXT:    fdivr %st(2) # sched: [9:9.50]
 ; BDVER2-NEXT:    fdivrs (%ecx) # sched: [14:9.50]
 ; BDVER2-NEXT:    fdivrl (%eax) # sched: [14:9.50]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fdivr:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fdivr %st(0), %st(1) # sched: [19:19.00]
+; BTVER2-NEXT:    fdivr %st, %st(1) # sched: [19:19.00]
 ; BTVER2-NEXT:    fdivr %st(2) # sched: [19:19.00]
 ; BTVER2-NEXT:    fdivrs (%ecx) # sched: [24:19.00]
 ; BTVER2-NEXT:    fdivrl (%eax) # sched: [24:19.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fdivr:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fdivr %st(0), %st(1) # sched: [15:1.00]
+; ZNVER1-NEXT:    fdivr %st, %st(1) # sched: [15:1.00]
 ; ZNVER1-NEXT:    fdivr %st(2) # sched: [15:1.00]
 ; ZNVER1-NEXT:    fdivrs (%ecx) # sched: [22:1.00]
 ; ZNVER1-NEXT:    fdivrl (%eax) # sched: [22:1.00]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fdivr %st(0), %st(1) \0A\09 fdivr %st(2), %st(0) \0A\09 fdivrs $0 \0A\09 fdivrl $1", "*m,*m"(float *%a0, double *%a1) nounwind
   ret void
 }
; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fdivrp \0A\09 fdivrp %st(2), %st(0) \0A\09 fidivrs $0 \0A\09 fidivrl $1", "*m,*m"(i16 *%a0, i32 *%a1) nounwind
   ret void
 }
 
 define void @test_ffree() optsize {
 ; GENERIC-LABEL: test_ffree:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    ffree %st(0)
+; GENERIC-NEXT:    ffree %st
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_ffree:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    ffree %st(0) # sched: [1:0.50]
+; ATOM-NEXT:    ffree %st # sched: [1:0.50]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_ffree:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    ffree %st(0) # sched: [100:1.00]
+; SLM-NEXT:    ffree %st # sched: [100:1.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_ffree:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    ffree %st(0) # sched: [1:1.00]
+; SANDY-NEXT:    ffree %st # sched: [1:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_ffree:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    ffree %st(0) # sched: [1:0.50]
+; HASWELL-NEXT:    ffree %st # sched: [1:0.50]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_ffree:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    ffree %st(0) # sched: [100:0.25]
+; BROADWELL-NEXT:    ffree %st # sched: [100:0.25]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_ffree:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    ffree %st(0) # sched: [100:0.25]
+; SKYLAKE-NEXT:    ffree %st # sched: [100:0.25]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_ffree:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    ffree %st(0) # sched: [100:0.25]
+; SKX-NEXT:    ffree %st # sched: [100:0.25]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_ffree:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    ffree %st(0) # sched: [100:0.50]
+; BDVER2-NEXT:    ffree %st # sched: [100:0.50]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_ffree:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    ffree %st(0) # sched: [100:0.50]
+; BTVER2-NEXT:    ffree %st # sched: [100:0.50]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_ffree:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    ffree %st(0) # sched: [11:1.00]
+; ZNVER1-NEXT:    ffree %st # sched: [11:1.00]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "ffree %st(0)", ""() nounwind
   ret void
 }
 
 define void @test_ficom(i16 *%a0, i32 *%a1) optsize {
 ; GENERIC-LABEL: test_ficom:

 
 define void @test_fld(i16* %a0, i32* %a1, i64 *%a2) optsize {
 ; GENERIC-LABEL: test_fld:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fld %st(0)
+; GENERIC-NEXT:    fld %st
 ; GENERIC-NEXT:    flds (%edx)
 ; GENERIC-NEXT:    fldl (%ecx)
 ; GENERIC-NEXT:    fldt (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fld:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fld %st(0) # sched: [1:1.00]
+; ATOM-NEXT:    fld %st # sched: [1:1.00]
 ; ATOM-NEXT:    flds (%edx) # sched: [1:1.00]
 ; ATOM-NEXT:    fldl (%ecx) # sched: [1:1.00]
 ; ATOM-NEXT:    fldt (%eax) # sched: [4:2.00]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fld:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fld %st(0) # sched: [1:0.50]
+; SLM-NEXT:    fld %st # sched: [1:0.50]
 ; SLM-NEXT:    flds (%edx) # sched: [3:1.00]
 ; SLM-NEXT:    fldl (%ecx) # sched: [3:1.00]
 ; SLM-NEXT:    fldt (%eax) # sched: [3:1.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fld:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fld %st(0) # sched: [1:1.00]
+; SANDY-NEXT:    fld %st # sched: [1:1.00]
 ; SANDY-NEXT:    flds (%edx) # sched: [9:1.00]
 ; SANDY-NEXT:    fldl (%ecx) # sched: [9:1.00]
 ; SANDY-NEXT:    fldt (%eax) # sched: [9:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fld:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fld %st(0) # sched: [1:0.50]
+; HASWELL-NEXT:    fld %st # sched: [1:0.50]
 ; HASWELL-NEXT:    flds (%edx) # sched: [7:0.50]
 ; HASWELL-NEXT:    fldl (%ecx) # sched: [7:0.50]
 ; HASWELL-NEXT:    fldt (%eax) # sched: [7:0.50]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fld:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fld %st(0) # sched: [1:0.25]
+; BROADWELL-NEXT:    fld %st # sched: [1:0.25]
 ; BROADWELL-NEXT:    flds (%edx) # sched: [6:0.50]
 ; BROADWELL-NEXT:    fldl (%ecx) # sched: [6:0.50]
 ; BROADWELL-NEXT:    fldt (%eax) # sched: [6:0.50]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fld:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fld %st(0) # sched: [1:0.25]
+; SKYLAKE-NEXT:    fld %st # sched: [1:0.25]
 ; SKYLAKE-NEXT:    flds (%edx) # sched: [7:0.50]
 ; SKYLAKE-NEXT:    fldl (%ecx) # sched: [7:0.50]
 ; SKYLAKE-NEXT:    fldt (%eax) # sched: [7:0.50]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fld:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fld %st(0) # sched: [1:0.25]
+; SKX-NEXT:    fld %st # sched: [1:0.25]
 ; SKX-NEXT:    flds (%edx) # sched: [7:0.50]
 ; SKX-NEXT:    fldl (%ecx) # sched: [7:0.50]
 ; SKX-NEXT:    fldt (%eax) # sched: [7:0.50]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fld:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fld %st(0) # sched: [1:0.50]
+; BDVER2-NEXT:    fld %st # sched: [1:0.50]
 ; BDVER2-NEXT:    flds (%edx) # sched: [5:0.50]
 ; BDVER2-NEXT:    fldl (%ecx) # sched: [5:0.50]
 ; BDVER2-NEXT:    fldt (%eax) # sched: [5:0.50]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fld:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fld %st(0) # sched: [1:0.50]
+; BTVER2-NEXT:    fld %st # sched: [1:0.50]
 ; BTVER2-NEXT:    flds (%edx) # sched: [3:1.00]
 ; BTVER2-NEXT:    fldl (%ecx) # sched: [3:1.00]
 ; BTVER2-NEXT:    fldt (%eax) # sched: [3:1.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fld:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fld %st(0) # sched: [1:0.50]
+; ZNVER1-NEXT:    fld %st # sched: [1:0.50]
 ; ZNVER1-NEXT:    flds (%edx) # sched: [8:0.50]
 ; ZNVER1-NEXT:    fldl (%ecx) # sched: [8:0.50]
 ; ZNVER1-NEXT:    fldt (%eax) # sched: [1:0.50]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fld %st(0) \0A\09 flds $0 \0A\09 fldl $1 \0A\09 fldt $2", "*m,*m,*m"(i16* %a0, i32* %a1, i64 *%a2) nounwind
   ret void
 }

 }
 
 define void @test_fmul(float *%a0, double *%a1) optsize {
 ; GENERIC-LABEL: test_fmul:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fmul %st(0), %st(1)
+; GENERIC-NEXT:    fmul %st, %st(1)
 ; GENERIC-NEXT:    fmul %st(2)
 ; GENERIC-NEXT:    fmuls (%ecx)
 ; GENERIC-NEXT:    fmull (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fmul:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fmul %st(0), %st(1) # sched: [4:4.00]
+; ATOM-NEXT:    fmul %st, %st(1) # sched: [4:4.00]
 ; ATOM-NEXT:    fmul %st(2) # sched: [4:4.00]
 ; ATOM-NEXT:    fmuls (%ecx) # sched: [4:4.00]
 ; ATOM-NEXT:    fmull (%eax) # sched: [4:4.00]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fmul:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fmul %st(0), %st(1) # sched: [5:2.00]
+; SLM-NEXT:    fmul %st, %st(1) # sched: [5:2.00]
 ; SLM-NEXT:    fmul %st(2) # sched: [5:2.00]
 ; SLM-NEXT:    fmuls (%ecx) # sched: [8:2.00]
 ; SLM-NEXT:    fmull (%eax) # sched: [8:2.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fmul:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fmul %st(0), %st(1) # sched: [5:1.00]
+; SANDY-NEXT:    fmul %st, %st(1) # sched: [5:1.00]
 ; SANDY-NEXT:    fmul %st(2) # sched: [5:1.00]
 ; SANDY-NEXT:    fmuls (%ecx) # sched: [12:1.00]
 ; SANDY-NEXT:    fmull (%eax) # sched: [12:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fmul:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fmul %st(0), %st(1) # sched: [5:1.00]
+; HASWELL-NEXT:    fmul %st, %st(1) # sched: [5:1.00]
 ; HASWELL-NEXT:    fmul %st(2) # sched: [5:1.00]
 ; HASWELL-NEXT:    fmuls (%ecx) # sched: [12:1.00]
 ; HASWELL-NEXT:    fmull (%eax) # sched: [12:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fmul:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fmul %st(0), %st(1) # sched: [5:1.00]
+; BROADWELL-NEXT:    fmul %st, %st(1) # sched: [5:1.00]
 ; BROADWELL-NEXT:    fmul %st(2) # sched: [5:1.00]
 ; BROADWELL-NEXT:    fmuls (%ecx) # sched: [11:1.00]
 ; BROADWELL-NEXT:    fmull (%eax) # sched: [11:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fmul:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fmul %st(0), %st(1) # sched: [4:1.00]
+; SKYLAKE-NEXT:    fmul %st, %st(1) # sched: [4:1.00]
 ; SKYLAKE-NEXT:    fmul %st(2) # sched: [4:1.00]
 ; SKYLAKE-NEXT:    fmuls (%ecx) # sched: [11:1.00]
 ; SKYLAKE-NEXT:    fmull (%eax) # sched: [11:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fmul:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fmul %st(0), %st(1) # sched: [4:1.00]
+; SKX-NEXT:    fmul %st, %st(1) # sched: [4:1.00]
 ; SKX-NEXT:    fmul %st(2) # sched: [4:1.00]
 ; SKX-NEXT:    fmuls (%ecx) # sched: [11:1.00]
 ; SKX-NEXT:    fmull (%eax) # sched: [11:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fmul:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fmul %st(0), %st(1) # sched: [5:1.00]
+; BDVER2-NEXT:    fmul %st, %st(1) # sched: [5:1.00]
 ; BDVER2-NEXT:    fmul %st(2) # sched: [5:1.00]
 ; BDVER2-NEXT:    fmuls (%ecx) # sched: [10:1.00]
 ; BDVER2-NEXT:    fmull (%eax) # sched: [10:1.00]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fmul:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fmul %st(0), %st(1) # sched: [2:1.00]
+; BTVER2-NEXT:    fmul %st, %st(1) # sched: [2:1.00]
 ; BTVER2-NEXT:    fmul %st(2) # sched: [2:1.00]
 ; BTVER2-NEXT:    fmuls (%ecx) # sched: [7:1.00]
 ; BTVER2-NEXT:    fmull (%eax) # sched: [7:1.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fmul:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fmul %st(0), %st(1) # sched: [3:0.50]
+; ZNVER1-NEXT:    fmul %st, %st(1) # sched: [3:0.50]
 ; ZNVER1-NEXT:    fmul %st(2) # sched: [3:0.50]
 ; ZNVER1-NEXT:    fmuls (%ecx) # sched: [10:0.50]
 ; ZNVER1-NEXT:    fmull (%eax) # sched: [10:0.50]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fmul %st(0), %st(1) \0A\09 fmul %st(2), %st(0) \0A\09 fmuls $0 \0A\09 fmull $1", "*m,*m"(float *%a0, double *%a1) nounwind
   ret void
 }

 
 define void @test_fst_fstp(i16* %a0, i32* %a1, i64 *%a2) optsize {
 ; GENERIC-LABEL: test_fst_fstp:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fst %st(0)
+; GENERIC-NEXT:    fst %st
 ; GENERIC-NEXT:    fsts (%edx)
 ; GENERIC-NEXT:    fstl (%ecx)
-; GENERIC-NEXT:    fstp %st(0)
+; GENERIC-NEXT:    fstp %st
 ; GENERIC-NEXT:    fstpl (%edx)
 ; GENERIC-NEXT:    fstpl (%ecx)
 ; GENERIC-NEXT:    fstpt (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fst_fstp:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fst %st(0) # sched: [2:1.00]
+; ATOM-NEXT:    fst %st # sched: [2:1.00]
 ; ATOM-NEXT:    fsts (%edx) # sched: [2:1.00]
 ; ATOM-NEXT:    fstl (%ecx) # sched: [2:1.00]
-; ATOM-NEXT:    fstp %st(0) # sched: [2:1.00]
+; ATOM-NEXT:    fstp %st # sched: [2:1.00]
 ; ATOM-NEXT:    fstpl (%edx) # sched: [2:1.00]
 ; ATOM-NEXT:    fstpl (%ecx) # sched: [2:1.00]
 ; ATOM-NEXT:    fstpt (%eax) # sched: [5:2.50]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fst_fstp:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fst %st(0) # sched: [1:0.50]
+; SLM-NEXT:    fst %st # sched: [1:0.50]
 ; SLM-NEXT:    fsts (%edx) # sched: [1:1.00]
 ; SLM-NEXT:    fstl (%ecx) # sched: [1:1.00]
-; SLM-NEXT:    fstp %st(0) # sched: [1:0.50]
+; SLM-NEXT:    fstp %st # sched: [1:0.50]
 ; SLM-NEXT:    fstpl (%edx) # sched: [1:1.00]
 ; SLM-NEXT:    fstpl (%ecx) # sched: [1:1.00]
 ; SLM-NEXT:    fstpt (%eax) # sched: [1:1.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fst_fstp:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fst %st(0) # sched: [1:1.00]
+; SANDY-NEXT:    fst %st # sched: [1:1.00]
 ; SANDY-NEXT:    fsts (%edx) # sched: [6:1.00]
 ; SANDY-NEXT:    fstl (%ecx) # sched: [6:1.00]
-; SANDY-NEXT:    fstp %st(0) # sched: [1:1.00]
+; SANDY-NEXT:    fstp %st # sched: [1:1.00]
 ; SANDY-NEXT:    fstpl (%edx) # sched: [6:1.00]
 ; SANDY-NEXT:    fstpl (%ecx) # sched: [6:1.00]
 ; SANDY-NEXT:    fstpt (%eax) # sched: [6:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fst_fstp:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fst %st(0) # sched: [1:0.50]
+; HASWELL-NEXT:    fst %st # sched: [1:0.50]
 ; HASWELL-NEXT:    fsts (%edx) # sched: [1:1.00]
 ; HASWELL-NEXT:    fstl (%ecx) # sched: [1:1.00]
-; HASWELL-NEXT:    fstp %st(0) # sched: [1:0.50]
+; HASWELL-NEXT:    fstp %st # sched: [1:0.50]
 ; HASWELL-NEXT:    fstpl (%edx) # sched: [1:1.00]
 ; HASWELL-NEXT:    fstpl (%ecx) # sched: [1:1.00]
 ; HASWELL-NEXT:    fstpt (%eax) # sched: [1:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fst_fstp:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fst %st(0) # sched: [1:0.25]
+; BROADWELL-NEXT:    fst %st # sched: [1:0.25]
 ; BROADWELL-NEXT:    fsts (%edx) # sched: [1:1.00]
 ; BROADWELL-NEXT:    fstl (%ecx) # sched: [1:1.00]
-; BROADWELL-NEXT:    fstp %st(0) # sched: [1:0.25]
+; BROADWELL-NEXT:    fstp %st # sched: [1:0.25]
 ; BROADWELL-NEXT:    fstpl (%edx) # sched: [1:1.00]
 ; BROADWELL-NEXT:    fstpl (%ecx) # sched: [1:1.00]
 ; BROADWELL-NEXT:    fstpt (%eax) # sched: [1:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fst_fstp:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fst %st(0) # sched: [1:0.25]
+; SKYLAKE-NEXT:    fst %st # sched: [1:0.25]
 ; SKYLAKE-NEXT:    fsts (%edx) # sched: [1:1.00]
 ; SKYLAKE-NEXT:    fstl (%ecx) # sched: [1:1.00]
-; SKYLAKE-NEXT:    fstp %st(0) # sched: [1:0.25]
+; SKYLAKE-NEXT:    fstp %st # sched: [1:0.25]
 ; SKYLAKE-NEXT:    fstpl (%edx) # sched: [1:1.00]
 ; SKYLAKE-NEXT:    fstpl (%ecx) # sched: [1:1.00]
 ; SKYLAKE-NEXT:    fstpt (%eax) # sched: [1:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fst_fstp:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fst %st(0) # sched: [1:0.25]
+; SKX-NEXT:    fst %st # sched: [1:0.25]
 ; SKX-NEXT:    fsts (%edx) # sched: [1:1.00]
 ; SKX-NEXT:    fstl (%ecx) # sched: [1:1.00]
-; SKX-NEXT:    fstp %st(0) # sched: [1:0.25]
+; SKX-NEXT:    fstp %st # sched: [1:0.25]
 ; SKX-NEXT:    fstpl (%edx) # sched: [1:1.00]
 ; SKX-NEXT:    fstpl (%ecx) # sched: [1:1.00]
 ; SKX-NEXT:    fstpt (%eax) # sched: [1:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fst_fstp:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fst %st(0) # sched: [1:0.50]
+; BDVER2-NEXT:    fst %st # sched: [1:0.50]
 ; BDVER2-NEXT:    fsts (%edx) # sched: [1:1.00]
 ; BDVER2-NEXT:    fstl (%ecx) # sched: [1:1.00]
-; BDVER2-NEXT:    fstp %st(0) # sched: [1:0.50]
+; BDVER2-NEXT:    fstp %st # sched: [1:0.50]
 ; BDVER2-NEXT:    fstpl (%edx) # sched: [1:1.00]
 ; BDVER2-NEXT:    fstpl (%ecx) # sched: [1:1.00]
 ; BDVER2-NEXT:    fstpt (%eax) # sched: [1:1.00]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fst_fstp:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fst %st(0) # sched: [1:0.50]
+; BTVER2-NEXT:    fst %st # sched: [1:0.50]
 ; BTVER2-NEXT:    fsts (%edx) # sched: [1:1.00]
 ; BTVER2-NEXT:    fstl (%ecx) # sched: [1:1.00]
-; BTVER2-NEXT:    fstp %st(0) # sched: [1:0.50]
+; BTVER2-NEXT:    fstp %st # sched: [1:0.50]
 ; BTVER2-NEXT:    fstpl (%edx) # sched: [1:1.00]
 ; BTVER2-NEXT:    fstpl (%ecx) # sched: [1:1.00]
 ; BTVER2-NEXT:    fstpt (%eax) # sched: [1:1.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fst_fstp:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %edx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fst %st(0) # sched: [5:0.50]
+; ZNVER1-NEXT:    fst %st # sched: [5:0.50]
 ; ZNVER1-NEXT:    fsts (%edx) # sched: [1:0.50]
 ; ZNVER1-NEXT:    fstl (%ecx) # sched: [1:0.50]
-; ZNVER1-NEXT:    fstp %st(0) # sched: [5:0.50]
+; ZNVER1-NEXT:    fstp %st # sched: [5:0.50]
 ; ZNVER1-NEXT:    fstpl (%edx) # sched: [1:0.50]
 ; ZNVER1-NEXT:    fstpl (%ecx) # sched: [1:0.50]
 ; ZNVER1-NEXT:    fstpt (%eax) # sched: [5:0.50]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fst %st(0) \0A\09 fsts $0 \0A\09 fstl $1 \0A\09 fstp %st(0) \0A\09 fstpl $0 \0A\09 fstpl $1 \0A\09 fstpt $2", "*m,*m,*m"(i16* %a0, i32* %a1, i64 *%a2) nounwind
   ret void
 }

 }
 
 define void @test_fsub(float *%a0, double *%a1) optsize {
 ; GENERIC-LABEL: test_fsub:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fsub %st(0), %st(1)
+; GENERIC-NEXT:    fsub %st, %st(1)
 ; GENERIC-NEXT:    fsub %st(2)
 ; GENERIC-NEXT:    fsubs (%ecx)
 ; GENERIC-NEXT:    fsubl (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fsub:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fsub %st(0), %st(1) # sched: [5:5.00]
+; ATOM-NEXT:    fsub %st, %st(1) # sched: [5:5.00]
 ; ATOM-NEXT:    fsub %st(2) # sched: [5:5.00]
 ; ATOM-NEXT:    fsubs (%ecx) # sched: [5:5.00]
 ; ATOM-NEXT:    fsubl (%eax) # sched: [5:5.00]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fsub:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; SLM-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; SLM-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; SLM-NEXT:    fsubs (%ecx) # sched: [6:1.00]
 ; SLM-NEXT:    fsubl (%eax) # sched: [6:1.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fsub:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; SANDY-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; SANDY-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; SANDY-NEXT:    fsubs (%ecx) # sched: [10:1.00]
 ; SANDY-NEXT:    fsubl (%eax) # sched: [10:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fsub:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; HASWELL-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; HASWELL-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; HASWELL-NEXT:    fsubs (%ecx) # sched: [10:1.00]
 ; HASWELL-NEXT:    fsubl (%eax) # sched: [10:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fsub:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; BROADWELL-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; BROADWELL-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; BROADWELL-NEXT:    fsubs (%ecx) # sched: [9:1.00]
 ; BROADWELL-NEXT:    fsubl (%eax) # sched: [9:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fsub:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; SKYLAKE-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; SKYLAKE-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; SKYLAKE-NEXT:    fsubs (%ecx) # sched: [10:1.00]
 ; SKYLAKE-NEXT:    fsubl (%eax) # sched: [10:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fsub:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; SKX-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; SKX-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; SKX-NEXT:    fsubs (%ecx) # sched: [10:1.00]
 ; SKX-NEXT:    fsubl (%eax) # sched: [10:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fsub:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fsub %st(0), %st(1) # sched: [5:1.00]
+; BDVER2-NEXT:    fsub %st, %st(1) # sched: [5:1.00]
 ; BDVER2-NEXT:    fsub %st(2) # sched: [5:1.00]
 ; BDVER2-NEXT:    fsubs (%ecx) # sched: [10:1.00]
 ; BDVER2-NEXT:    fsubl (%eax) # sched: [10:1.00]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fsub:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; BTVER2-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; BTVER2-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; BTVER2-NEXT:    fsubs (%ecx) # sched: [8:1.00]
 ; BTVER2-NEXT:    fsubl (%eax) # sched: [8:1.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fsub:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fsub %st(0), %st(1) # sched: [3:1.00]
+; ZNVER1-NEXT:    fsub %st, %st(1) # sched: [3:1.00]
 ; ZNVER1-NEXT:    fsub %st(2) # sched: [3:1.00]
 ; ZNVER1-NEXT:    fsubs (%ecx) # sched: [10:1.00]
 ; ZNVER1-NEXT:    fsubl (%eax) # sched: [10:1.00]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fsub %st(0), %st(1) \0A\09 fsub %st(2), %st(0) \0A\09 fsubs $0 \0A\09 fsubl $1", "*m,*m"(float *%a0, double *%a1) nounwind
   ret void
 }

 }
 
 define void @test_fsubr(float *%a0, double *%a1) optsize {
 ; GENERIC-LABEL: test_fsubr:
 ; GENERIC:       # %bb.0:
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; GENERIC-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    fsubr %st(0), %st(1)
+; GENERIC-NEXT:    fsubr %st, %st(1)
 ; GENERIC-NEXT:    fsubr %st(2)
 ; GENERIC-NEXT:    fsubrs (%ecx)
 ; GENERIC-NEXT:    fsubrl (%eax)
 ; GENERIC-NEXT:    #NO_APP
 ; GENERIC-NEXT:    retl
 ;
 ; ATOM-LABEL: test_fsubr:
 ; ATOM:       # %bb.0:
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [1:1.00]
 ; ATOM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [1:1.00]
 ; ATOM-NEXT:    #APP
-; ATOM-NEXT:    fsubr %st(0), %st(1) # sched: [5:5.00]
+; ATOM-NEXT:    fsubr %st, %st(1) # sched: [5:5.00]
 ; ATOM-NEXT:    fsubr %st(2) # sched: [5:5.00]
 ; ATOM-NEXT:    fsubrs (%ecx) # sched: [5:5.00]
 ; ATOM-NEXT:    fsubrl (%eax) # sched: [5:5.00]
 ; ATOM-NEXT:    #NO_APP
 ; ATOM-NEXT:    retl # sched: [79:39.50]
 ;
 ; SLM-LABEL: test_fsubr:
 ; SLM:       # %bb.0:
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; SLM-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; SLM-NEXT:    #APP
-; SLM-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; SLM-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; SLM-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; SLM-NEXT:    fsubrs (%ecx) # sched: [6:1.00]
 ; SLM-NEXT:    fsubrl (%eax) # sched: [6:1.00]
 ; SLM-NEXT:    #NO_APP
 ; SLM-NEXT:    retl # sched: [4:1.00]
 ;
 ; SANDY-LABEL: test_fsubr:
 ; SANDY:       # %bb.0:
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SANDY-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SANDY-NEXT:    #APP
-; SANDY-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; SANDY-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; SANDY-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; SANDY-NEXT:    fsubrs (%ecx) # sched: [10:1.00]
 ; SANDY-NEXT:    fsubrl (%eax) # sched: [10:1.00]
 ; SANDY-NEXT:    #NO_APP
 ; SANDY-NEXT:    retl # sched: [6:1.00]
 ;
 ; HASWELL-LABEL: test_fsubr:
 ; HASWELL:       # %bb.0:
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; HASWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; HASWELL-NEXT:    #APP
-; HASWELL-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; HASWELL-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; HASWELL-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; HASWELL-NEXT:    fsubrs (%ecx) # sched: [10:1.00]
 ; HASWELL-NEXT:    fsubrl (%eax) # sched: [10:1.00]
 ; HASWELL-NEXT:    #NO_APP
 ; HASWELL-NEXT:    retl # sched: [7:1.00]
 ;
 ; BROADWELL-LABEL: test_fsubr:
 ; BROADWELL:       # %bb.0:
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BROADWELL-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BROADWELL-NEXT:    #APP
-; BROADWELL-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; BROADWELL-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; BROADWELL-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; BROADWELL-NEXT:    fsubrs (%ecx) # sched: [9:1.00]
 ; BROADWELL-NEXT:    fsubrl (%eax) # sched: [9:1.00]
 ; BROADWELL-NEXT:    #NO_APP
 ; BROADWELL-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKYLAKE-LABEL: test_fsubr:
 ; SKYLAKE:       # %bb.0:
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKYLAKE-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKYLAKE-NEXT:    #APP
-; SKYLAKE-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; SKYLAKE-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; SKYLAKE-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; SKYLAKE-NEXT:    fsubrs (%ecx) # sched: [10:1.00]
 ; SKYLAKE-NEXT:    fsubrl (%eax) # sched: [10:1.00]
 ; SKYLAKE-NEXT:    #NO_APP
 ; SKYLAKE-NEXT:    retl # sched: [6:0.50]
 ;
 ; SKX-LABEL: test_fsubr:
 ; SKX:       # %bb.0:
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; SKX-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; SKX-NEXT:    #APP
-; SKX-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; SKX-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; SKX-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; SKX-NEXT:    fsubrs (%ecx) # sched: [10:1.00]
 ; SKX-NEXT:    fsubrl (%eax) # sched: [10:1.00]
 ; SKX-NEXT:    #NO_APP
 ; SKX-NEXT:    retl # sched: [6:0.50]
 ;
 ; BDVER2-LABEL: test_fsubr:
 ; BDVER2:       # %bb.0:
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [5:0.50]
 ; BDVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [5:0.50]
 ; BDVER2-NEXT:    #APP
-; BDVER2-NEXT:    fsubr %st(0), %st(1) # sched: [5:1.00]
+; BDVER2-NEXT:    fsubr %st, %st(1) # sched: [5:1.00]
 ; BDVER2-NEXT:    fsubr %st(2) # sched: [5:1.00]
 ; BDVER2-NEXT:    fsubrs (%ecx) # sched: [10:1.00]
 ; BDVER2-NEXT:    fsubrl (%eax) # sched: [10:1.00]
 ; BDVER2-NEXT:    #NO_APP
 ; BDVER2-NEXT:    retl # sched: [5:1.00]
 ;
 ; BTVER2-LABEL: test_fsubr:
 ; BTVER2:       # %bb.0:
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [3:1.00]
 ; BTVER2-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [3:1.00]
 ; BTVER2-NEXT:    #APP
-; BTVER2-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; BTVER2-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; BTVER2-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; BTVER2-NEXT:    fsubrs (%ecx) # sched: [8:1.00]
 ; BTVER2-NEXT:    fsubrl (%eax) # sched: [8:1.00]
 ; BTVER2-NEXT:    #NO_APP
 ; BTVER2-NEXT:    retl # sched: [4:1.00]
 ;
 ; ZNVER1-LABEL: test_fsubr:
 ; ZNVER1:       # %bb.0:
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %eax # sched: [8:0.50]
 ; ZNVER1-NEXT:    movl {{[0-9]+}}(%esp), %ecx # sched: [8:0.50]
 ; ZNVER1-NEXT:    #APP
-; ZNVER1-NEXT:    fsubr %st(0), %st(1) # sched: [3:1.00]
+; ZNVER1-NEXT:    fsubr %st, %st(1) # sched: [3:1.00]
 ; ZNVER1-NEXT:    fsubr %st(2) # sched: [3:1.00]
 ; ZNVER1-NEXT:    fsubrs (%ecx) # sched: [10:1.00]
 ; ZNVER1-NEXT:    fsubrl (%eax) # sched: [10:1.00]
 ; ZNVER1-NEXT:    #NO_APP
 ; ZNVER1-NEXT:    retl # sched: [1:0.50]
   tail call void asm sideeffect "fsubr %st(0), %st(1) \0A\09 fsubr %st(2), %st(0) \0A\09 fsubrs $0 \0A\09 fsubrl $1", "*m,*m"(float *%a0, double *%a1) nounwind
   ret void
 }

llvm/trunk/test/MC/Disassembler/X86/fp-stack.txt

 # RUN: llvm-mc --disassemble %s -triple=x86_64 | FileCheck %s
 # RUN: llvm-mc --disassemble %s -triple=i686-apple-darwin9 | FileCheck %s
 
-# CHECK: fadd %st(0)
+# CHECK: fadd %st
 0xd8,0xc0
 
 # CHECK: fadd %st(1)
 0xd8,0xc1
 
 # CHECK: fadd %st(2)
 0xd8,0xc2
 
 # CHECK: fadd %st(3)
 0xd8,0xc3
 
 # CHECK: fadd %st(4)
 0xd8,0xc4
 
 # CHECK: fadd %st(5)
 0xd8,0xc5
 
 # CHECK: fadd %st(6)
 0xd8,0xc6
 
 # CHECK: fadd %st(7)
 0xd8,0xc7
 
-# CHECK: fmul %st(0)
+# CHECK: fmul %st
 0xd8,0xc8
 
 # CHECK: fmul %st(1)
 0xd8,0xc9
 
 # CHECK: fmul %st(2)
 0xd8,0xca
 
 # CHECK: fmul %st(3)
 0xd8,0xcb
 
 # CHECK: fmul %st(4)
 0xd8,0xcc
 
 # CHECK: fmul %st(5)
 0xd8,0xcd
 
 # CHECK: fmul %st(6)
 0xd8,0xce
 
 # CHECK: fmul %st(7)
 0xd8,0xcf
 
-# CHECK: fcom %st(0)
+# CHECK: fcom %st
 0xd8,0xd0
 
 # CHECK: fcom %st(1)
 0xd8,0xd1
 
 # CHECK: fcom %st(2)
 0xd8,0xd2
 
 # CHECK: fcom %st(3)
 0xd8,0xd3
 
 # CHECK: fcom %st(4)
 0xd8,0xd4
 
 # CHECK: fcom %st(5)
 0xd8,0xd5
 
 # CHECK: fcom %st(6)
 0xd8,0xd6
 
 # CHECK: fcom %st(7)
 0xd8,0xd7
 
-# CHECK: fcomp %st(0)
+# CHECK: fcomp %st
 0xd8,0xd8
 
 # CHECK: fcomp %st(1)
 0xd8,0xd9
 
 # CHECK: fcomp %st(2)
 0xd8,0xda
 
 # CHECK: fcomp %st(3)
 0xd8,0xdb
 
 # CHECK: fcomp %st(4)
 0xd8,0xdc
 
 # CHECK: fcomp %st(5)
 0xd8,0xdd
 
 # CHECK: fcomp %st(6)
 0xd8,0xde
 
 # CHECK: fcomp %st(7)
 0xd8,0xdf
 
-# CHECK: fsub %st(0)
+# CHECK: fsub %st
 0xd8,0xe0
 
 # CHECK: fsub %st(1)
 0xd8,0xe1
 
 # CHECK: fsub %st(2)
 0xd8,0xe2
 
 # CHECK: fsub %st(3)
 0xd8,0xe3
 
 # CHECK: fsub %st(4)
 0xd8,0xe4
 
 # CHECK: fsub %st(5)
 0xd8,0xe5
 
 # CHECK: fsub %st(6)
 0xd8,0xe6
 
 # CHECK: fsub %st(7)
 0xd8,0xe7
 
-# CHECK: fsubr %st(0)
+# CHECK: fsubr %st
 0xd8,0xe8
 
 # CHECK: fsubr %st(1)
 0xd8,0xe9
 
 # CHECK: fsubr %st(2)
 0xd8,0xea
 
 # CHECK: fsubr %st(3)
 0xd8,0xeb
 
 # CHECK: fsubr %st(4)
 0xd8,0xec
 
 # CHECK: fsubr %st(5)
 0xd8,0xed
 
 # CHECK: fsubr %st(6)
 0xd8,0xee
 
 # CHECK: fsubr %st(7)
 0xd8,0xef
 
-# CHECK: fdiv %st(0)
+# CHECK: fdiv %st
 0xd8,0xf0
 
 # CHECK: fdiv %st(1)
 0xd8,0xf1
 
 # CHECK: fdiv %st(2)
 0xd8,0xf2
 
 # CHECK: fdiv %st(3)
 0xd8,0xf3
 
 # CHECK: fdiv %st(4)
 0xd8,0xf4
 
 # CHECK: fdiv %st(5)
 0xd8,0xf5
 
 # CHECK: fdiv %st(6)
 0xd8,0xf6
 
 # CHECK: fdiv %st(7)
 0xd8,0xf7
 
-# CHECK: fdivr %st(0)
+# CHECK: fdivr %st
 0xd8,0xf8
 
 # CHECK: fdivr %st(1)
 0xd8,0xf9
 
 # CHECK: fdivr %st(2)
 0xd8,0xfa
 
 # CHECK: fdivr %st(3)
 0xd8,0xfb
 
 # CHECK: fdivr %st(4)
 0xd8,0xfc
 
 # CHECK: fdivr %st(5)
 0xd8,0xfd
 
 # CHECK: fdivr %st(6)
 0xd8,0xfe
 
 # CHECK: fdivr %st(7)
 0xd8,0xff
 
-# CHECK: fld %st(0)
+# CHECK: fld %st
 0xd9,0xc0
 
 # CHECK: fld %st(1)
 0xd9,0xc1
 
 # CHECK: fld %st(2)
 0xd9,0xc2
 
 # CHECK: fld %st(3)
 0xd9,0xc3
 
 # CHECK: fld %st(4)
 0xd9,0xc4
 
 # CHECK: fld %st(5)
 0xd9,0xc5
 
 # CHECK: fld %st(6)
 0xd9,0xc6
 
 # CHECK: fld %st(7)
 0xd9,0xc7
 
-# CHECK: fxch %st(0)
+# CHECK: fxch %st
 0xd9,0xc8
 
 # CHECK: fxch %st(1)
 0xd9,0xc9
 
 # CHECK: fxch %st(2)
 0xd9,0xca
 

 0xd9,0xfd
 
 # CHECK: fsin
 0xd9,0xfe
 
 # CHECK: fcos
 0xd9,0xff
 
-# CHECK: fcmovb %st(0), %st(0)
+# CHECK: fcmovb %st, %st
 0xda,0xc0
 
-# CHECK: fcmovb %st(1), %st(0)
+# CHECK: fcmovb %st(1), %st
 0xda,0xc1
 
-# CHECK: fcmovb %st(2), %st(0)
+# CHECK: fcmovb %st(2), %st
 0xda,0xc2
 
-# CHECK: fcmovb %st(3), %st(0)
+# CHECK: fcmovb %st(3), %st
 0xda,0xc3
 
-# CHECK: fcmovb %st(4), %st(0)
+# CHECK: fcmovb %st(4), %st
 0xda,0xc4
 
-# CHECK: fcmovb %st(5), %st(0)
+# CHECK: fcmovb %st(5), %st
 0xda,0xc5
 
-# CHECK: fcmovb %st(6), %st(0)
+# CHECK: fcmovb %st(6), %st
 0xda,0xc6
 
-# CHECK: fcmovb %st(7), %st(0)
+# CHECK: fcmovb %st(7), %st
 0xda,0xc7
 
-# CHECK: fcmove %st(0), %st(0)
+# CHECK: fcmove %st, %st
 0xda,0xc8
 
-# CHECK: fcmove %st(1), %st(0)
+# CHECK: fcmove %st(1), %st
 0xda,0xc9
 
-# CHECK: fcmove %st(2), %st(0)
+# CHECK: fcmove %st(2), %st
 0xda,0xca
 
-# CHECK: fcmove %st(3), %st(0)
+# CHECK: fcmove %st(3), %st
 0xda,0xcb
 
-# CHECK: fcmove %st(4), %st(0)
+# CHECK: fcmove %st(4), %st
 0xda,0xcc
 
-# CHECK: fcmove %st(5), %st(0)
+# CHECK: fcmove %st(5), %st
 0xda,0xcd
 
-# CHECK: fcmove %st(6), %st(0)
+# CHECK: fcmove %st(6), %st
 0xda,0xce
 
-# CHECK: fcmove %st(7), %st(0)
+# CHECK: fcmove %st(7), %st
 0xda,0xcf
 
-# CHECK: fcmovbe %st(0), %st(0)
+# CHECK: fcmovbe %st, %st
 0xda,0xd0
 
-# CHECK: fcmovbe %st(1), %st(0)
+# CHECK: fcmovbe %st(1), %st
 0xda,0xd1
 
-# CHECK: fcmovbe %st(2), %st(0)
+# CHECK: fcmovbe %st(2), %st
 0xda,0xd2
 
-# CHECK: fcmovbe %st(3), %st(0)
+# CHECK: fcmovbe %st(3), %st
 0xda,0xd3
 
-# CHECK: fcmovbe %st(4), %st(0)
+# CHECK: fcmovbe %st(4), %st
 0xda,0xd4
 
-# CHECK: fcmovbe %st(5), %st(0)
+# CHECK: fcmovbe %st(5), %st
 0xda,0xd5
 
-# CHECK: fcmovbe %st(6), %st(0)
+# CHECK: fcmovbe %st(6), %st
 0xda,0xd6
 
-# CHECK: fcmovbe %st(7), %st(0)
+# CHECK: fcmovbe %st(7), %st
 0xda,0xd7
 
-# CHECK: fcmovu %st(0), %st(0)
+# CHECK: fcmovu %st, %st
 0xda,0xd8
 
-# CHECK: fcmovu %st(1), %st(0)
+# CHECK: fcmovu %st(1), %st
 0xda,0xd9
 
-# CHECK: fcmovu %st(2), %st(0)
+# CHECK: fcmovu %st(2), %st
 0xda,0xda
 
-# CHECK: fcmovu %st(3), %st(0)
+# CHECK: fcmovu %st(3), %st
 0xda,0xdb
 
-# CHECK: fcmovu %st(4), %st(0)
+# CHECK: fcmovu %st(4), %st
 0xda,0xdc
 
-# CHECK: fcmovu %st(5), %st(0)
+# CHECK: fcmovu %st(5), %st
 0xda,0xdd
 
-# CHECK: fcmovu %st(6), %st(0)
+# CHECK: fcmovu %st(6), %st
 0xda,0xde
 
-# CHECK: fcmovu %st(7), %st(0)
+# CHECK: fcmovu %st(7), %st
 0xda,0xdf
 
 # CHECK: fucompp
 0xda,0xe9
 
-# CHECK: fcmovnb %st(0), %st(0)
+# CHECK: fcmovnb %st, %st
 0xdb,0xc0
 
-# CHECK: fcmovnb %st(1), %st(0)
+# CHECK: fcmovnb %st(1), %st
 0xdb,0xc1
 
-# CHECK: fcmovnb %st(2), %st(0)
+# CHECK: fcmovnb %st(2), %st
 0xdb,0xc2
 
-# CHECK: fcmovnb %st(3), %st(0)
+# CHECK: fcmovnb %st(3), %st
 0xdb,0xc3
 
-# CHECK: fcmovnb %st(4), %st(0)
+# CHECK: fcmovnb %st(4), %st
 0xdb,0xc4
 
-# CHECK: fcmovnb %st(5), %st(0)
+# CHECK: fcmovnb %st(5), %st
 0xdb,0xc5
 
-# CHECK: fcmovnb %st(6), %st(0)
+# CHECK: fcmovnb %st(6), %st
 0xdb,0xc6
 
-# CHECK: fcmovnb %st(7), %st(0)
+# CHECK: fcmovnb %st(7), %st
 0xdb,0xc7
 
-# CHECK: fcmovne %st(0), %st(0)
+# CHECK: fcmovne %st, %st
 0xdb,0xc8
 
-# CHECK: fcmovne %st(1), %st(0)
+# CHECK: fcmovne %st(1), %st
 0xdb,0xc9
 
-# CHECK: fcmovne %st(2), %st(0)
+# CHECK: fcmovne %st(2), %st
 0xdb,0xca
 
-# CHECK: fcmovne %st(3), %st(0)
+# CHECK: fcmovne %st(3), %st
 0xdb,0xcb
 
-# CHECK: fcmovne %st(4), %st(0)
+# CHECK: fcmovne %st(4), %st
 0xdb,0xcc
 
-# CHECK: fcmovne %st(5), %st(0)
+# CHECK: fcmovne %st(5), %st
 0xdb,0xcd
 
-# CHECK: fcmovne %st(6), %st(0)
+# CHECK: fcmovne %st(6), %st
 0xdb,0xce
 
-# CHECK: fcmovne %st(7), %st(0)
+# CHECK: fcmovne %st(7), %st
 0xdb,0xcf
 
-# CHECK: fcmovnbe %st(0), %st(0)
+# CHECK: fcmovnbe %st, %st
 0xdb,0xd0
 
-# CHECK: fcmovnbe %st(1), %st(0)
+# CHECK: fcmovnbe %st(1), %st
 0xdb,0xd1
 
-# CHECK: fcmovnbe %st(2), %st(0)
+# CHECK: fcmovnbe %st(2), %st
 0xdb,0xd2
 
-# CHECK: fcmovnbe %st(3), %st(0)
+# CHECK: fcmovnbe %st(3), %st
 0xdb,0xd3
 
-# CHECK: fcmovnbe %st(4), %st(0)
+# CHECK: fcmovnbe %st(4), %st
 0xdb,0xd4
 
-# CHECK: fcmovnbe %st(5), %st(0)
+# CHECK: fcmovnbe %st(5), %st
 0xdb,0xd5
 
-# CHECK: fcmovnbe %st(6), %st(0)
+# CHECK: fcmovnbe %st(6), %st
 0xdb,0xd6
 
-# CHECK: fcmovnbe %st(7), %st(0)
+# CHECK: fcmovnbe %st(7), %st
 0xdb,0xd7
 
-# CHECK: fcmovnu %st(0), %st(0)
+# CHECK: fcmovnu %st, %st
 0xdb,0xd8
 
-# CHECK: fcmovnu %st(1), %st(0)
+# CHECK: fcmovnu %st(1), %st
 0xdb,0xd9
 
-# CHECK: fcmovnu %st(2), %st(0)
+# CHECK: fcmovnu %st(2), %st
 0xdb,0xda
 
-# CHECK: fcmovnu %st(3), %st(0)
+# CHECK: fcmovnu %st(3), %st
 0xdb,0xdb
 
-# CHECK: fcmovnu %st(4), %st(0)
+# CHECK: fcmovnu %st(4), %st
 0xdb,0xdc
 
-# CHECK: fcmovnu %st(5), %st(0)
+# CHECK: fcmovnu %st(5), %st
 0xdb,0xdd
 
-# CHECK: fcmovnu %st(6), %st(0)
+# CHECK: fcmovnu %st(6), %st
 0xdb,0xde
 
-# CHECK: fcmovnu %st(7), %st(0)
+# CHECK: fcmovnu %st(7), %st
 0xdb,0xdf
 
 # CHECK: fnclex
 0xdb,0xe2
 
 # CHECK: fninit
 0xdb,0xe3
 
-# CHECK: fucomi %st(0)
+# CHECK: fucomi %st
 0xdb,0xe8
 
 # CHECK: fucomi %st(1)
 0xdb,0xe9
 
 # CHECK: fucomi %st(2)
 0xdb,0xea
 
 # CHECK: fucomi %st(3)
 0xdb,0xeb
 
 # CHECK: fucomi %st(4)
 0xdb,0xec
 
 # CHECK: fucomi %st(5)
 0xdb,0xed
 
 # CHECK: fucomi %st(6)
 0xdb,0xee
 
 # CHECK: fucomi %st(7)
 0xdb,0xef
 
-# CHECK: fcomi %st(0)
+# CHECK: fcomi %st
 0xdb,0xf0
 
 # CHECK: fcomi %st(1)
 0xdb,0xf1
 
 # CHECK: fcomi %st(2)
 0xdb,0xf2
 
 # CHECK: fcomi %st(3)
 0xdb,0xf3
 
 # CHECK: fcomi %st(4)
 0xdb,0xf4
 
 # CHECK: fcomi %st(5)
 0xdb,0xf5
 
 # CHECK: fcomi %st(6)
 0xdb,0xf6
 
 # CHECK: fcomi %st(7)
 0xdb,0xf7
 
-# CHECK: fadd %st(0), %st(0)
+# CHECK: fadd %st, %st
 0xdc,0xc0
 
-# CHECK: fadd %st(0), %st(1)
+# CHECK: fadd %st, %st(1)
 0xdc,0xc1
 
-# CHECK: fadd %st(0), %st(2)
+# CHECK: fadd %st, %st(2)
 0xdc,0xc2
 
-# CHECK: fadd %st(0), %st(3)
+# CHECK: fadd %st, %st(3)
 0xdc,0xc3
 
-# CHECK: fadd %st(0), %st(4)
+# CHECK: fadd %st, %st(4)
 0xdc,0xc4
 
-# CHECK: fadd %st(0), %st(5)
+# CHECK: fadd %st, %st(5)
 0xdc,0xc5
 
-# CHECK: fadd %st(0), %st(6)
+# CHECK: fadd %st, %st(6)
 0xdc,0xc6
 
-# CHECK: fadd %st(0), %st(7)
+# CHECK: fadd %st, %st(7)
 0xdc,0xc7
 
-# CHECK: fmul %st(0), %st(0)
+# CHECK: fmul %st, %st
 0xdc,0xc8
 
-# CHECK: fmul %st(0), %st(1)
+# CHECK: fmul %st, %st(1)
 0xdc,0xc9
 
-# CHECK: fmul %st(0), %st(2)
+# CHECK: fmul %st, %st(2)
 0xdc,0xca
 
-# CHECK: fmul %st(0), %st(3)
+# CHECK: fmul %st, %st(3)
 0xdc,0xcb
 
-# CHECK: fmul %st(0), %st(4)
+# CHECK: fmul %st, %st(4)
 0xdc,0xcc
 
-# CHECK: fmul %st(0), %st(5)
+# CHECK: fmul %st, %st(5)
 0xdc,0xcd
 
-# CHECK: fmul %st(0), %st(6)
+# CHECK: fmul %st, %st(6)
 0xdc,0xce
 
-# CHECK: fmul %st(0), %st(7)
+# CHECK: fmul %st, %st(7)
 0xdc,0xcf
 
-# CHECK: fsub %st(0), %st(0)
+# CHECK: fsub %st, %st
 0xdc,0xe0
 
-# CHECK: fsub %st(0), %st(1)
+# CHECK: fsub %st, %st(1)
 0xdc,0xe1
 
-# CHECK: fsub %st(0), %st(2)
+# CHECK: fsub %st, %st(2)
 0xdc,0xe2
 
-# CHECK: fsub %st(0), %st(3)
+# CHECK: fsub %st, %st(3)
 0xdc,0xe3
 
-# CHECK: fsub %st(0), %st(4)
+# CHECK: fsub %st, %st(4)
 0xdc,0xe4
 
-# CHECK: fsub %st(0), %st(5)
+# CHECK: fsub %st, %st(5)
 0xdc,0xe5
 
-# CHECK: fsub %st(0), %st(6)
+# CHECK: fsub %st, %st(6)
 0xdc,0xe6
 
-# CHECK: fsub %st(0), %st(7)
+# CHECK: fsub %st, %st(7)
 0xdc,0xe7
 
-# CHECK: fsubr %st(0), %st(0)
+# CHECK: fsubr %st, %st
 0xdc,0xe8
 
-# CHECK: fsubr %st(0), %st(1)
+# CHECK: fsubr %st, %st(1)
 0xdc,0xe9
 
-# CHECK: fsubr %st(0), %st(2)
+# CHECK: fsubr %st, %st(2)
 0xdc,0xea
 
-# CHECK: fsubr %st(0), %st(3)
+# CHECK: fsubr %st, %st(3)
 0xdc,0xeb
 
-# CHECK: fsubr %st(0), %st(4)
+# CHECK: fsubr %st, %st(4)
 0xdc,0xec
 
-# CHECK: fsubr %st(0), %st(5)
+# CHECK: fsubr %st, %st(5)
 0xdc,0xed
 
-# CHECK: fsubr %st(0), %st(6)
+# CHECK: fsubr %st, %st(6)
 0xdc,0xee
 
-# CHECK: fsubr %st(0), %st(7)
+# CHECK: fsubr %st, %st(7)
 0xdc,0xef
 
-# CHECK: fdiv %st(0), %st(0)
+# CHECK: fdiv %st, %st
 0xdc,0xf0
 
-# CHECK: fdiv %st(0), %st(1)
+# CHECK: fdiv %st, %st(1)
 0xdc,0xf1
 
-# CHECK: fdiv %st(0), %st(2)
+# CHECK: fdiv %st, %st(2)
 0xdc,0xf2
 
-# CHECK: fdiv %st(0), %st(3)
+# CHECK: fdiv %st, %st(3)
 0xdc,0xf3
 
-# CHECK: fdiv %st(0), %st(4)
+# CHECK: fdiv %st, %st(4)
 0xdc,0xf4
 
-# CHECK: fdiv %st(0), %st(5)
+# CHECK: fdiv %st, %st(5)
 0xdc,0xf5
 
-# CHECK: fdiv %st(0), %st(6)
+# CHECK: fdiv %st, %st(6)
 0xdc,0xf6
 
-# CHECK: fdiv %st(0), %st(7)
+# CHECK: fdiv %st, %st(7)
 0xdc,0xf7
 
-# CHECK: fdivr %st(0), %st(0)
+# CHECK: fdivr %st, %st
 0xdc,0xf8
 
-# CHECK: fdivr %st(0), %st(1)
+# CHECK: fdivr %st, %st(1)
 0xdc,0xf9
 
-# CHECK: fdivr %st(0), %st(2)
+# CHECK: fdivr %st, %st(2)
 0xdc,0xfa
 
-# CHECK: fdivr %st(0), %st(3)
+# CHECK: fdivr %st, %st(3)
 0xdc,0xfb
 
-# CHECK: fdivr %st(0), %st(4)
+# CHECK: fdivr %st, %st(4)
 0xdc,0xfc
 
-# CHECK: fdivr %st(0), %st(5)
+# CHECK: fdivr %st, %st(5)
 0xdc,0xfd
 
-# CHECK: fdivr %st(0), %st(6)
+# CHECK: fdivr %st, %st(6)
 0xdc,0xfe
 
-# CHECK: fdivr %st(0), %st(7)
+# CHECK: fdivr %st, %st(7)
 0xdc,0xff
 
-# CHECK: ffree %st(0)
+# CHECK: ffree %st
 0xdd,0xc0
 
 # CHECK: ffree %st(1)
 0xdd,0xc1
 
 # CHECK: ffree %st(2)
 0xdd,0xc2
 
 # CHECK: ffree %st(3)
 0xdd,0xc3
 
 # CHECK: ffree %st(4)
 0xdd,0xc4
 
 # CHECK: ffree %st(5)
 0xdd,0xc5
 
 # CHECK: ffree %st(6)
 0xdd,0xc6
 
 # CHECK: ffree %st(7)
 0xdd,0xc7
 
-# CHECK: fst %st(0)
+# CHECK: fst %st
 0xdd,0xd0
 
 # CHECK: fst %st(1)
 0xdd,0xd1
 
 # CHECK: fst %st(2)
 0xdd,0xd2
 
 # CHECK: fst %st(3)
 0xdd,0xd3
 
 # CHECK: fst %st(4)
 0xdd,0xd4
 
 # CHECK: fst %st(5)
 0xdd,0xd5
 
 # CHECK: fst %st(6)
 0xdd,0xd6
 
 # CHECK: fst %st(7)
 0xdd,0xd7
 
-# CHECK: fstp %st(0)
+# CHECK: fstp %st
 0xdd,0xd8
 
 # CHECK: fstp %st(1)
 0xdd,0xd9
 
 # CHECK: fstp %st(2)
 0xdd,0xda
 
 # CHECK: fstp %st(3)
 0xdd,0xdb
 
 # CHECK: fstp %st(4)
 0xdd,0xdc
 
 # CHECK: fstp %st(5)
 0xdd,0xdd
 
 # CHECK: fstp %st(6)
 0xdd,0xde
 
 # CHECK: fstp %st(7)
 0xdd,0xdf
 
-# CHECK: fucom %st(0)
+# CHECK: fucom %st
 0xdd,0xe0
 
 # CHECK: fucom %st(1)
 0xdd,0xe1
 
 # CHECK: fucom %st(2)
 0xdd,0xe2
 
 # CHECK: fucom %st(3)
 0xdd,0xe3
 
 # CHECK: fucom %st(4)
 0xdd,0xe4
 
 # CHECK: fucom %st(5)
 0xdd,0xe5
 
 # CHECK: fucom %st(6)
 0xdd,0xe6
 
 # CHECK: fucom %st(7)
 0xdd,0xe7
 
-# CHECK: fucomp %st(0)
+# CHECK: fucomp %st
 0xdd,0xe8
 
 # CHECK: fucomp %st(1)
 0xdd,0xe9
 
 # CHECK: fucomp %st(2)
 0xdd,0xea
 
 # CHECK: fucomp %st(3)
 0xdd,0xeb
 
 # CHECK: fucomp %st(4)
 0xdd,0xec
 
 # CHECK: fucomp %st(5)
 0xdd,0xed
 
 # CHECK: fucomp %st(6)
 0xdd,0xee
 
 # CHECK: fucomp %st(7)
 0xdd,0xef
 
-# CHECK: faddp %st(0)
+# CHECK: faddp %st
 0xde,0xc0
 
 # CHECK: faddp %st(1)
 0xde,0xc1
 
 # CHECK: faddp %st(2)
 0xde,0xc2
 
 # CHECK: faddp %st(3)
 0xde,0xc3
 
 # CHECK: faddp %st(4)
 0xde,0xc4
 
 # CHECK: faddp %st(5)
 0xde,0xc5
 
 # CHECK: faddp %st(6)
 0xde,0xc6
 
 # CHECK: faddp %st(7)
 0xde,0xc7
 
-# CHECK: fmulp %st(0)
+# CHECK: fmulp %st
 0xde,0xc8
 
 # CHECK: fmulp %st(1)
 0xde,0xc9
 
 # CHECK: fmulp %st(2)
 0xde,0xca
 

 0xde,0xce
 
 # CHECK: fmulp %st(7)
 0xde,0xcf
 
 # CHECK: fcompp
 0xde,0xd9
 
-# CHECK: fsubp %st(0)
+# CHECK: fsubp %st
 0xde,0xe0
 
 # CHECK: fsubp %st(1)
 0xde,0xe1
 
 # CHECK: fsubp %st(2)
 0xde,0xe2
 
 # CHECK: fsubp %st(3)
 0xde,0xe3
 
 # CHECK: fsubp %st(4)
 0xde,0xe4
 
 # CHECK: fsubp %st(5)
 0xde,0xe5
 
 # CHECK: fsubp %st(6)
 0xde,0xe6
 
 # CHECK: fsubp %st(7)
 0xde,0xe7
 
-# CHECK: fsubrp %st(0)
+# CHECK: fsubrp %st
 0xde,0xe8
 
 # CHECK: fsubrp %st(1)
 0xde,0xe9
 
 # CHECK: fsubrp %st(2)
 0xde,0xea
 
 # CHECK: fsubrp %st(3)
 0xde,0xeb
 
 # CHECK: fsubrp %st(4)
 0xde,0xec
 
 # CHECK: fsubrp %st(5)
 0xde,0xed
 
 # CHECK: fsubrp %st(6)
 0xde,0xee
 
 # CHECK: fsubrp %st(7)
 0xde,0xef
 
-# CHECK: fdivp %st(0)
+# CHECK: fdivp %st
 0xde,0xf0
 
 # CHECK: fdivp %st(1)
 0xde,0xf1
 
 # CHECK: fdivp %st(2)
 0xde,0xf2
 
 # CHECK: fdivp %st(3)
 0xde,0xf3
 
 # CHECK: fdivp %st(4)
 0xde,0xf4
 
 # CHECK: fdivp %st(5)
 0xde,0xf5
 
 # CHECK: fdivp %st(6)
 0xde,0xf6
 
 # CHECK: fdivp %st(7)
 0xde,0xf7
 
-# CHECK: fdivrp %st(0)
+# CHECK: fdivrp %st
 0xde,0xf8
 
 # CHECK: fdivrp %st(1)
 0xde,0xf9
 
 # CHECK: fdivrp %st(2)
 0xde,0xfa
 
 # CHECK: fdivrp %st(3)
 0xde,0xfb
 
 # CHECK: fdivrp %st(4)
 0xde,0xfc
 
 # CHECK: fdivrp %st(5)
 0xde,0xfd
 
 # CHECK: fdivrp %st(6)
 0xde,0xfe
 
 # CHECK: fdivrp %st(7)
 0xde,0xff
 
-# CHECK: ffreep %st(0)
+# CHECK: ffreep %st
 0xdf,0xc0
 
 # CHECK: ffreep %st(1)
 0xdf,0xc1
 
 # CHECK: ffreep %st(2)
 0xdf,0xc2
 

 0xdf,0xc6
 
 # CHECK: ffreep %st(7)
 0xdf,0xc7
 
 # CHECK: fnstsw %ax
 0xdf,0xe0
 
-# CHECK: fucompi %st(0)
+# CHECK: fucompi %st
 0xdf,0xe8
 
 # CHECK: fucompi %st(1)
 0xdf,0xe9
 
 # CHECK: fucompi %st(2)
 0xdf,0xea
 
 # CHECK: fucompi %st(3)
 0xdf,0xeb
 
 # CHECK: fucompi %st(4)
 0xdf,0xec
 
 # CHECK: fucompi %st(5)
 0xdf,0xed
 
 # CHECK: fucompi %st(6)
 0xdf,0xee
 
 # CHECK: fucompi %st(7)
 0xdf,0xef
 
-# CHECK: fcompi %st(0)
+# CHECK: fcompi %st
 0xdf,0xf0
 
 # CHECK: fcompi %st(1)
 0xdf,0xf1
 
 # CHECK: fcompi %st(2)
 0xdf,0xf2
 

llvm/trunk/test/MC/Disassembler/X86/x86-16.txt

 0x66 0x0f 0x4a 0xd0
 
 # CHECK: cmovsl %eax, %edx
 0x66 0x0f 0x48 0xd0
 
 # CHECK: cmovel %eax, %edx
 0x66 0x0f 0x44 0xd0
 
-# CHECK: fmul %st(0)
+# CHECK: fmul %st
 0xd8 0xc8
 
-# CHECK: fadd %st(0)
+# CHECK: fadd %st
 0xd8 0xc0
 
-# CHECK: fsub %st(0)
+# CHECK: fsub %st
 0xd8 0xe0
 
-# CHECK: fsubr %st(0)
+# CHECK: fsubr %st
 0xd8 0xe8
 
-# CHECK: fdivr %st(0)
+# CHECK: fdivr %st
 0xd8 0xf8
 
-# CHECK: fdiv %st(0)
+# CHECK: fdiv %st
 0xd8 0xf0
 
 # CHECK: movl %cs, %eax
 0x66 0x8c 0xc8
 
 # CHECK: movw %cs, %ax
 0x8c 0xc8
 

llvm/trunk/test/MC/X86/PPRO-32.s

 // CHECK: cmovpl %eax, %eax 
 // CHECK: encoding: [0x0f,0x4a,0xc0]        
 cmovpl %eax, %eax 
 
 // CHECK: cmovsl %eax, %eax 
 // CHECK: encoding: [0x0f,0x48,0xc0]        
 cmovsl %eax, %eax 
 
-// CHECK: fcmovbe %st(4), %st(0) 
+// CHECK: fcmovbe %st(4), %st 
 // CHECK: encoding: [0xda,0xd4]        
-fcmovbe %st(4), %st(0) 
+fcmovbe %st(4), %st 
 
-// CHECK: fcmovb %st(4), %st(0) 
+// CHECK: fcmovb %st(4), %st 
 // CHECK: encoding: [0xda,0xc4]        
-fcmovb %st(4), %st(0) 
+fcmovb %st(4), %st 
 
-// CHECK: fcmove %st(4), %st(0) 
+// CHECK: fcmove %st(4), %st 
 // CHECK: encoding: [0xda,0xcc]        
-fcmove %st(4), %st(0) 
+fcmove %st(4), %st 
 
-// CHECK: fcmovnbe %st(4), %st(0) 
+// CHECK: fcmovnbe %st(4), %st 
 // CHECK: encoding: [0xdb,0xd4]        
-fcmovnbe %st(4), %st(0) 
+fcmovnbe %st(4), %st 
 
-// CHECK: fcmovnb %st(4), %st(0) 
+// CHECK: fcmovnb %st(4), %st 
 // CHECK: encoding: [0xdb,0xc4]        
-fcmovnb %st(4), %st(0) 
+fcmovnb %st(4), %st 
 
-// CHECK: fcmovne %st(4), %st(0) 
+// CHECK: fcmovne %st(4), %st 
 // CHECK: encoding: [0xdb,0xcc]        
-fcmovne %st(4), %st(0) 
+fcmovne %st(4), %st 
 
-// CHECK: fcmovnu %st(4), %st(0) 
+// CHECK: fcmovnu %st(4), %st 
 // CHECK: encoding: [0xdb,0xdc]        
-fcmovnu %st(4), %st(0) 
+fcmovnu %st(4), %st 
 
-// CHECK: fcmovu %st(4), %st(0) 
+// CHECK: fcmovu %st(4), %st 
 // CHECK: encoding: [0xda,0xdc]        
-fcmovu %st(4), %st(0) 
+fcmovu %st(4), %st 
 
 // CHECK: fcomi %st(4) 
 // CHECK: encoding: [0xdb,0xf4]         
 fcomi %st(4) 
 
 // CHECK: fcompi %st(4) 
 // CHECK: encoding: [0xdf,0xf4]         
 fcompi %st(4) 

llvm/trunk/test/MC/X86/PPRO-64.s

 // CHECK: cmovpl %r13d, %r13d 
 // CHECK: encoding: [0x45,0x0f,0x4a,0xed]        
 cmovpl %r13d, %r13d 
 
 // CHECK: cmovsl %r13d, %r13d 
 // CHECK: encoding: [0x45,0x0f,0x48,0xed]        
 cmovsl %r13d, %r13d 
 
-// CHECK: fcmovbe %st(4), %st(0) 
+// CHECK: fcmovbe %st(4), %st 
 // CHECK: encoding: [0xda,0xd4]        
-fcmovbe %st(4), %st(0) 
+fcmovbe %st(4), %st 
 
-// CHECK: fcmovb %st(4), %st(0) 
+// CHECK: fcmovb %st(4), %st 
 // CHECK: encoding: [0xda,0xc4]        
-fcmovb %st(4), %st(0) 
+fcmovb %st(4), %st 
 
-// CHECK: fcmove %st(4), %st(0) 
+// CHECK: fcmove %st(4), %st 
 // CHECK: encoding: [0xda,0xcc]        
-fcmove %st(4), %st(0) 
+fcmove %st(4), %st 
 
-// CHECK: fcmovnbe %st(4), %st(0) 
+// CHECK: fcmovnbe %st(4), %st 
 // CHECK: encoding: [0xdb,0xd4]        
-fcmovnbe %st(4), %st(0) 
+fcmovnbe %st(4), %st 
 
-// CHECK: fcmovnb %st(4), %st(0) 
+// CHECK: fcmovnb %st(4), %st 
 // CHECK: encoding: [0xdb,0xc4]        
-fcmovnb %st(4), %st(0) 
+fcmovnb %st(4), %st 
 
-// CHECK: fcmovne %st(4), %st(0) 
+// CHECK: fcmovne %st(4), %st 
 // CHECK: encoding: [0xdb,0xcc]        
-fcmovne %st(4), %st(0) 
+fcmovne %st(4), %st 
 
-// CHECK: fcmovnu %st(4), %st(0) 
+// CHECK: fcmovnu %st(4), %st 
 // CHECK: encoding: [0xdb,0xdc]        
-fcmovnu %st(4), %st(0) 
+fcmovnu %st(4), %st 
 
-// CHECK: fcmovu %st(4), %st(0) 
+// CHECK: fcmovu %st(4), %st 
 // CHECK: encoding: [0xda,0xdc]        
-fcmovu %st(4), %st(0) 
+fcmovu %st(4), %st 
 
 // CHECK: fcomi %st(4) 
 // CHECK: encoding: [0xdb,0xf4]         
 fcomi %st(4) 
 
 // CHECK: fcompi %st(4) 
 // CHECK: encoding: [0xdf,0xf4]         
 fcompi %st(4) 

llvm/trunk/test/MC/X86/X87-32.s

 // CHECK: fadds 64(%edx,%eax) 
 // CHECK: encoding: [0xd8,0x44,0x02,0x40]        
 fadds 64(%edx,%eax) 
 
 // CHECK: fadds (%edx) 
 // CHECK: encoding: [0xd8,0x02]        
 fadds (%edx) 
 
-// CHECK: fadd %st(0), %st(4) 
+// CHECK: fadd %st, %st(4) 
 // CHECK: encoding: [0xdc,0xc4]       
-fadd %st(0), %st(4) 
+fadd %st, %st(4) 
 
 // CHECK: fadd %st(4) 
 // CHECK: encoding: [0xd8,0xc4]        
 fadd %st(4) 
 
 // CHECK: fbld -485498096(%edx,%eax,4) 
 // CHECK: encoding: [0xdf,0xa4,0x82,0x10,0xe3,0x0f,0xe3]        
 fbld -485498096(%edx,%eax,4) 

 // CHECK: fdivrs 64(%edx,%eax) 
 // CHECK: encoding: [0xd8,0x7c,0x02,0x40]        
 fdivrs 64(%edx,%eax) 
 
 // CHECK: fdivrs (%edx) 
 // CHECK: encoding: [0xd8,0x3a]        
 fdivrs (%edx) 
 
-// CHECK: fdivr %st(0), %st(4) 
+// CHECK: fdivr %st, %st(4) 
 // CHECK: encoding: [0xdc,0xfc]       
-fdivr %st(0), %st(4) 
+fdivr %st, %st(4) 
 
 // CHECK: fdivr %st(4) 
 // CHECK: encoding: [0xd8,0xfc]        
 fdivr %st(4) 
 
 // CHECK: fdivs -485498096(%edx,%eax,4) 
 // CHECK: encoding: [0xd8,0xb4,0x82,0x10,0xe3,0x0f,0xe3]        
 fdivs -485498096(%edx,%eax,4) 

 // CHECK: fdivs 64(%edx,%eax) 
 // CHECK: encoding: [0xd8,0x74,0x02,0x40]        
 fdivs 64(%edx,%eax) 
 
 // CHECK: fdivs (%edx) 
 // CHECK: encoding: [0xd8,0x32]        
 fdivs (%edx) 
 
-// CHECK: fdiv %st(0), %st(4) 
+// CHECK: fdiv %st, %st(4) 
 // CHECK: encoding: [0xdc,0xf4]       
-fdiv %st(0), %st(4) 
+fdiv %st, %st(4) 
 
 // CHECK: fdiv %st(4) 
 // CHECK: encoding: [0xd8,0xf4]        
 fdiv %st(4) 
 
 // CHECK: ffreep %st(4) 
 // CHECK: encoding: [0xdf,0xc4]        
 ffreep %st(4) 

 // CHECK: fmuls 64(%edx,%eax) 
 // CHECK: encoding: [0xd8,0x4c,0x02,0x40]        
 fmuls 64(%edx,%eax) 
 
 // CHECK: fmuls (%edx) 
 // CHECK: encoding: [0xd8,0x0a]        
 fmuls (%edx) 
 
-// CHECK: fmul %st(0), %st(4) 
+// CHECK: fmul %st, %st(4) 
 // CHECK: encoding: [0xdc,0xcc]       
-fmul %st(0), %st(4) 
+fmul %st, %st(4) 
 
 // CHECK: fmul %st(4) 
 // CHECK: encoding: [0xd8,0xcc]        
 fmul %st(4) 
 
 // CHECK: fnclex 
 // CHECK: encoding: [0xdb,0xe2]         
 fnclex 

 // CHECK: fsubrs 64(%edx,%eax) 
 // CHECK: encoding: [0xd8,0x6c,0x02,0x40]        
 fsubrs 64(%edx,%eax) 
 
 // CHECK: fsubrs (%edx) 
 // CHECK: encoding: [0xd8,0x2a]        
 fsubrs (%edx) 
 
-// CHECK: fsubr %st(0), %st(4) 
+// CHECK: fsubr %st, %st(4) 
 // CHECK: encoding: [0xdc,0xec]       
-fsubr %st(0), %st(4) 
+fsubr %st, %st(4) 
 
 // CHECK: fsubr %st(4) 
 // CHECK: encoding: [0xd8,0xec]        
 fsubr %st(4) 
 
 // CHECK: fsubs -485498096(%edx,%eax,4) 
 // CHECK: encoding: [0xd8,0xa4,0x82,0x10,0xe3,0x0f,0xe3]        
 fsubs -485498096(%edx,%eax,4) 

 // CHECK: fsubs 64(%edx,%eax) 
 // CHECK: encoding: [0xd8,0x64,0x02,0x40]        
 fsubs 64(%edx,%eax) 
 
 // CHECK: fsubs (%edx) 
 // CHECK: encoding: [0xd8,0x22]        
 fsubs (%edx) 
 
-// CHECK: fsub %st(0), %st(4) 
+// CHECK: fsub %st, %st(4) 
 // CHECK: encoding: [0xdc,0xe4]       
-fsub %st(0), %st(4) 
+fsub %st, %st(4) 
 
 // CHECK: fsub %st(4) 
 // CHECK: encoding: [0xd8,0xe4]        
 fsub %st(4) 
 
 // CHECK: ftst 
 // CHECK: encoding: [0xd9,0xe4]         
 ftst 

llvm/trunk/test/MC/X86/X87-64.s

 // CHECK: fadds 64(%rdx,%rax) 
 // CHECK: encoding: [0xd8,0x44,0x02,0x40]        
 fadds 64(%rdx,%rax) 
 
 // CHECK: fadds (%rdx) 
 // CHECK: encoding: [0xd8,0x02]        
 fadds (%rdx) 
 
-// CHECK: fadd %st(0), %st(4) 
+// CHECK: fadd %st, %st(4) 
 // CHECK: encoding: [0xdc,0xc4]       
-fadd %st(0), %st(4) 
+fadd %st, %st(4) 
 
 // CHECK: fadd %st(4) 
 // CHECK: encoding: [0xd8,0xc4]        
 fadd %st(4) 
 
 // CHECK: fbld 485498096 
 // CHECK: encoding: [0xdf,0x24,0x25,0xf0,0x1c,0xf0,0x1c]        
 fbld 485498096 

 // CHECK: fdivrs 64(%rdx,%rax) 
 // CHECK: encoding: [0xd8,0x7c,0x02,0x40]        
 fdivrs 64(%rdx,%rax) 
 
 // CHECK: fdivrs (%rdx) 
 // CHECK: encoding: [0xd8,0x3a]        
 fdivrs (%rdx) 
 
-// CHECK: fdivr %st(0), %st(4) 
+// CHECK: fdivr %st, %st(4) 
 // CHECK: encoding: [0xdc,0xfc]       
-fdivr %st(0), %st(4) 
+fdivr %st, %st(4) 
 
 // CHECK: fdivr %st(4) 
 // CHECK: encoding: [0xd8,0xfc]        
 fdivr %st(4) 
 
 // CHECK: fdivs 485498096 
 // CHECK: encoding: [0xd8,0x34,0x25,0xf0,0x1c,0xf0,0x1c]        
 fdivs 485498096 

 // CHECK: fdivs 64(%rdx,%rax) 
 // CHECK: encoding: [0xd8,0x74,0x02,0x40]        
 fdivs 64(%rdx,%rax) 
 
 // CHECK: fdivs (%rdx) 
 // CHECK: encoding: [0xd8,0x32]        
 fdivs (%rdx) 
 
-// CHECK: fdiv %st(0), %st(4) 
+// CHECK: fdiv %st, %st(4) 
 // CHECK: encoding: [0xdc,0xf4]       
-fdiv %st(0), %st(4) 
+fdiv %st, %st(4) 
 
 // CHECK: fdiv %st(4) 
 // CHECK: encoding: [0xd8,0xf4]        
 fdiv %st(4) 
 
 // CHECK: ffreep %st(4) 
 // CHECK: encoding: [0xdf,0xc4]        
 ffreep %st(4) 

 // CHECK: fmuls 64(%rdx,%rax) 
 // CHECK: encoding: [0xd8,0x4c,0x02,0x40]        
 fmuls 64(%rdx,%rax) 
 
 // CHECK: fmuls (%rdx) 
 // CHECK: encoding: [0xd8,0x0a]        
 fmuls (%rdx) 
 
-// CHECK: fmul %st(0), %st(4) 
+// CHECK: fmul %st, %st(4) 
 // CHECK: encoding: [0xdc,0xcc]       
-fmul %st(0), %st(4) 
+fmul %st, %st(4) 
 
 // CHECK: fmul %st(4) 
 // CHECK: encoding: [0xd8,0xcc]        
 fmul %st(4) 
 
 // CHECK: fnclex 
 // CHECK: encoding: [0xdb,0xe2]         
 fnclex 

 // CHECK: fsubrs 64(%rdx,%rax) 
 // CHECK: encoding: [0xd8,0x6c,0x02,0x40]        
 fsubrs 64(%rdx,%rax) 
 
 // CHECK: fsubrs (%rdx) 
 // CHECK: encoding: [0xd8,0x2a]        
 fsubrs (%rdx) 
 
-// CHECK: fsubr %st(0), %st(4) 
+// CHECK: fsubr %st, %st(4) 
 // CHECK: encoding: [0xdc,0xec]       
-fsubr %st(0), %st(4) 
+fsubr %st, %st(4) 
 
 // CHECK: fsubr %st(4) 
 // CHECK: encoding: [0xd8,0xec]        
 fsubr %st(4) 
 
 // CHECK: fsubs 485498096 
 // CHECK: encoding: [0xd8,0x24,0x25,0xf0,0x1c,0xf0,0x1c]        
 fsubs 485498096 

 // CHECK: fsubs 64(%rdx,%rax) 
 // CHECK: encoding: [0xd8,0x64,0x02,0x40]        
 fsubs 64(%rdx,%rax) 
 
 // CHECK: fsubs (%rdx) 
 // CHECK: encoding: [0xd8,0x22]        
 fsubs (%rdx) 
 
-// CHECK: fsub %st(0), %st(4) 
+// CHECK: fsub %st, %st(4) 
 // CHECK: encoding: [0xdc,0xe4]       
-fsub %st(0), %st(4) 
+fsub %st, %st(4) 
 
 // CHECK: fsub %st(4) 
 // CHECK: encoding: [0xd8,0xe4]        
 fsub %st(4) 
 
 // CHECK: ftst 
 // CHECK: encoding: [0xd9,0xe4]         
 ftst 

llvm/trunk/test/MC/X86/intel-syntax.s

 // CHECK: andq  $12,  %rax
   and rax, 12
 // CHECK: andq  $-12, %rax
   and rax, -12
 // CHECK: andq  $257, %rax
   and rax, 257
 // CHECK: andq  $-257,  %rax
   and rax, -257
-// CHECK: fld %st(0)
-  fld  ST(0)
+// CHECK: fld %st
+  fld st
 // CHECK: movl  %fs:(%rdi), %eax
     mov EAX, DWORD PTR FS:[RDI]
 // CHECK: leal (,%rdi,4), %r8d
     lea R8D, DWORD PTR [4*RDI]
 // CHECK: movl _fnan(,%ecx,4), %ecx
     mov ECX, DWORD PTR [4*ECX + _fnan]
 // CHECK: movq %fs:320, %rax
     mov RAX, QWORD PTR FS:[320]

 fnstsw WORD PTR [EAX]
 
 // CHECK: faddp %st(1)
 // CHECK: fmulp %st(1)
 // CHECK: fsubrp %st(1)
 // CHECK: fsubp %st(1)
 // CHECK: fdivrp %st(1)
 // CHECK: fdivp %st(1)
-faddp ST(1), ST(0)
-fmulp ST(1), ST(0)
-fsubp ST(1), ST(0)
-fsubrp ST(1), ST(0)
-fdivp ST(1), ST(0)
-fdivrp ST(1), ST(0)
+faddp ST(1), st
+fmulp ST(1), st
+fsubp ST(1), st
+fsubrp ST(1), st
+fdivp ST(1), st
+fdivrp ST(1), st
 
 // CHECK: faddp %st(1)
 // CHECK: fmulp %st(1)
 // CHECK: fsubrp %st(1)
 // CHECK: fsubp %st(1)
 // CHECK: fdivrp %st(1)
 // CHECK: fdivp %st(1)
-faddp ST(0), ST(1)
-fmulp ST(0), ST(1)
-fsubp ST(0), ST(1)
-fsubrp ST(0), ST(1)
-fdivp ST(0), ST(1)
-fdivrp ST(0), ST(1)
+faddp st, ST(1)
+fmulp st, ST(1)
+fsubp st, ST(1)
+fsubrp st, ST(1)
+fdivp st, ST(1)
+fdivrp st, ST(1)
 
 // CHECK: faddp %st(1)
 // CHECK: fmulp %st(1)
 // CHECK: fsubrp %st(1)
 // CHECK: fsubp %st(1)
 // CHECK: fdivrp %st(1)
 // CHECK: fdivp %st(1)
 faddp ST(1)

 fdivrp
 
 // CHECK: fadd %st(1)
 // CHECK: fmul %st(1)
 // CHECK: fsub %st(1)
 // CHECK: fsubr %st(1)
 // CHECK: fdiv %st(1)
 // CHECK: fdivr %st(1)
-fadd ST(0), ST(1)
-fmul ST(0), ST(1)
-fsub ST(0), ST(1)
-fsubr ST(0), ST(1)
-fdiv ST(0), ST(1)
-fdivr ST(0), ST(1)
-
-// CHECK: fadd %st(0), %st(1)
-// CHECK: fmul %st(0), %st(1)
-// CHECK: fsubr %st(0), %st(1)
-// CHECK: fsub %st(0), %st(1)
-// CHECK: fdivr %st(0), %st(1)
-// CHECK: fdiv %st(0), %st(1)
-fadd ST(1), ST(0)
-fmul ST(1), ST(0)
-fsub ST(1), ST(0)
-fsubr ST(1), ST(0)
-fdiv ST(1), ST(0)
-fdivr ST(1), ST(0)
+fadd st, ST(1)
+fmul st, ST(1)
+fsub st, ST(1)
+fsubr st, ST(1)
+fdiv st, ST(1)
+fdivr st, ST(1)
+
+// CHECK: fadd %st, %st(1)
+// CHECK: fmul %st, %st(1)
+// CHECK: fsubr %st, %st(1)
+// CHECK: fsub %st, %st(1)
+// CHECK: fdivr %st, %st(1)
+// CHECK: fdiv %st, %st(1)
+fadd ST(1), st
+fmul ST(1), st
+fsub ST(1), st
+fsubr ST(1), st
+fdiv ST(1), st
+fdivr ST(1), st
 
 // CHECK: fadd %st(1)
 // CHECK: fmul %st(1)
 // CHECK: fsub %st(1)
 // CHECK: fsubr %st(1)
 // CHECK: fdiv %st(1)
 // CHECK: fdivr %st(1)
 fadd ST(1)

llvm/trunk/test/MC/X86/x86-16.s

 // CHECK: cmovsl  %eax, %edx
 // CHECK:  encoding: [0x66,0x0f,0x48,0xd0]
           cmovsl  %eax,%edx
 
 // CHECK: cmovel  %eax, %edx
 // CHECK:  encoding: [0x66,0x0f,0x44,0xd0]
           cmovzl  %eax,%edx
 
-// CHECK: fmul  %st(0)
+// CHECK: fmul  %st
 // CHECK:  encoding: [0xd8,0xc8]
-        fmul %st(0), %st
+        fmul %st, %st
 
-// CHECK: fadd  %st(0)
+// CHECK: fadd  %st
 // CHECK:  encoding: [0xd8,0xc0]
-        fadd %st(0), %st
+        fadd %st, %st
 
-// CHECK: fsub  %st(0)
+// CHECK: fsub  %st
 // CHECK:  encoding: [0xd8,0xe0]
-        fsub %st(0), %st
+        fsub %st, %st
 
-// CHECK: fsubr %st(0)
+// CHECK: fsubr %st
 // CHECK:  encoding: [0xd8,0xe8]
-        fsubr %st(0), %st
+        fsubr %st, %st
 
-// CHECK: fdivr %st(0)
+// CHECK: fdivr %st
 // CHECK:  encoding: [0xd8,0xf8]
-        fdivr %st(0), %st
+        fdivr %st, %st
 
-// CHECK: fdiv  %st(0)
+// CHECK: fdiv  %st
 // CHECK:  encoding: [0xd8,0xf0]
-        fdiv %st(0), %st
+        fdiv %st, %st
 
 // CHECK: movl  %cs, %eax
 // CHECK:  encoding: [0x66,0x8c,0xc8]
         movl %cs, %eax
 
 // CHECK: movw  %cs, %ax
 // CHECK:  encoding: [0x8c,0xc8]
         movw %cs, %ax

llvm/trunk/test/MC/X86/x86-32-coverage.s

 // CHECK: rdpmc
 // CHECK:  encoding: [0x0f,0x33]
           rdpmc
 
 // CHECK: ud2
 // CHECK:  encoding: [0x0f,0x0b]
           ud2
 
-// CHECK: fcmovb  %st(2), %st(0)
+// CHECK: fcmovb  %st(2), %st
 // CHECK:  encoding: [0xda,0xc2]
           fcmovb  %st(2),%st
 
-// CHECK: fcmove  %st(2), %st(0)
+// CHECK: fcmove  %st(2), %st
 // CHECK:  encoding: [0xda,0xca]
           fcmove  %st(2),%st
 
-// CHECK: fcmovbe %st(2), %st(0)
+// CHECK: fcmovbe %st(2), %st
 // CHECK:  encoding: [0xda,0xd2]
           fcmovbe %st(2),%st
 
-// CHECK: fcmovu   %st(2), %st(0)
+// CHECK: fcmovu   %st(2), %st
 // CHECK:  encoding: [0xda,0xda]
           fcmovu  %st(2),%st
 
-// CHECK: fcmovnb %st(2), %st(0)
+// CHECK: fcmovnb %st(2), %st
 // CHECK:  encoding: [0xdb,0xc2]
           fcmovnb %st(2),%st
 
-// CHECK: fcmovne %st(2), %st(0)
+// CHECK: fcmovne %st(2), %st
 // CHECK:  encoding: [0xdb,0xca]
           fcmovne %st(2),%st
 
-// CHECK: fcmovnbe  %st(2), %st(0)
+// CHECK: fcmovnbe  %st(2), %st
 // CHECK:  encoding: [0xdb,0xd2]
           fcmovnbe  %st(2),%st
 
-// CHECK: fcmovnu %st(2), %st(0)
+// CHECK: fcmovnu %st(2), %st
 // CHECK:  encoding: [0xdb,0xda]
           fcmovnu %st(2),%st
 
 // CHECK: fcomi %st(2)
 // CHECK:  encoding: [0xdb,0xf2]
           fcomi %st(2),%st
 
 // CHECK: fucomi  %st(2)

llvm/trunk/test/MC/X86/x86-32.s

 // CHECK: encoding: [0xf3,0x0f,0xc2,0xc8,0x06]
         cmpnless %xmm0, %xmm1
 
 // CHECK: cmpordsd %xmm0, %xmm1
 // CHECK: encoding: [0xf2,0x0f,0xc2,0xc8,0x07]
         cmpordsd %xmm0, %xmm1
 
 // rdar://7995856
-// CHECK: fmul  %st(0)
+// CHECK: fmul  %st
 // CHECK:  encoding: [0xd8,0xc8]
-        fmul %st(0), %st
+        fmul %st, %st
 
-// CHECK: fadd  %st(0)
+// CHECK: fadd  %st
 // CHECK:  encoding: [0xd8,0xc0]
-        fadd %st(0), %st
+        fadd %st, %st
 
-// CHECK: fsub  %st(0)
+// CHECK: fsub  %st
 // CHECK:  encoding: [0xd8,0xe0]
-        fsub %st(0), %st
+        fsub %st, %st
 
-// CHECK: fsubr %st(0)
+// CHECK: fsubr %st
 // CHECK:  encoding: [0xd8,0xe8]
-        fsubr %st(0), %st
+        fsubr %st, %st
 
-// CHECK: fdivr %st(0)
+// CHECK: fdivr %st
 // CHECK:  encoding: [0xd8,0xf8]
-        fdivr %st(0), %st
+        fdivr %st, %st
 
-// CHECK: fdiv  %st(0)
+// CHECK: fdiv  %st
 // CHECK:  encoding: [0xd8,0xf0]
-        fdiv %st(0), %st
+        fdiv %st, %st
 
 // radr://8017519
 // CHECK: movl  %cs, %eax
 // CHECK:  encoding: [0x8c,0xc8]
         movl %cs, %eax
 
 // CHECK: movw  %cs, %ax
 // CHECK:  encoding: [0x66,0x8c,0xc8]

llvm/trunk/test/MC/X86/x86-64.s

 // CHECK: fs
 // CHECK: movb (%eax), %al
         fs;movb 0(%eax), %al
 
 // CHECK: gs
 // CHECK: movb (%eax), %al
         gs;movb 0(%eax), %al
 
-// CHECK: fadd %st(0)
+// CHECK: fadd %st
 // CHECK: fadd %st(1)
 // CHECK: fadd %st(7)
 
-fadd %st(0)
+fadd %st
 fadd %st(1)
 fadd %st(7)
 
 // CHECK: leal 0, %eax
         leal 0, %eax
 
 // rdar://7986634 - Insensitivity on opcodes.
 // CHECK: int3

 // CHECK: insl  %dx, %es:(%rdi) 
 
 // rdar://8431422
 
 // CHECK: fxch %st(1)
 // CHECK: fucom %st(1)
 // CHECK: fucomp %st(1)
 // CHECK: faddp %st(1)
-// CHECK: faddp %st(0)
+// CHECK: faddp %st
 // CHECK: fsubp %st(1)
 // CHECK: fsubrp %st(1)
 // CHECK: fmulp %st(1)
 // CHECK: fdivp %st(1)
 // CHECK: fdivrp %st(1)
 
 fxch
 fucom

 enter $0x7ace,$0x7f
 
 
 // rdar://8456364
 // CHECK: movw  %cs, %ax
 mov %cs, %ax
 
 // rdar://8456391
-fcmovb %st(1), %st(0)   // CHECK: fcmovb  %st(1), %st(0)
-fcmove %st(1), %st(0)   // CHECK: fcmove  %st(1), %st(0)
-fcmovbe %st(1), %st(0)  // CHECK: fcmovbe  %st(1), %st(0)
-fcmovu %st(1), %st(0)   // CHECK: fcmovu   %st(1), %st(0)
-
-fcmovnb %st(1), %st(0)  // CHECK: fcmovnb  %st(1), %st(0)
-fcmovne %st(1), %st(0)  // CHECK: fcmovne  %st(1), %st(0)
-fcmovnbe %st(1), %st(0) // CHECK: fcmovnbe  %st(1), %st(0)
-fcmovnu %st(1), %st(0)  // CHECK: fcmovnu  %st(1), %st(0)
+fcmovb %st(1), %st   // CHECK: fcmovb %st(1), %st
+fcmove %st(1), %st   // CHECK: fcmove %st(1), %st
+fcmovbe %st(1), %st  // CHECK: fcmovbe  %st(1), %st
+fcmovu %st(1), %st   // CHECK: fcmovu  %st(1), %st
+
+fcmovnb %st(1), %st  // CHECK: fcmovnb  %st(1), %st
+fcmovne %st(1), %st  // CHECK: fcmovne  %st(1), %st
+fcmovnbe %st(1), %st // CHECK: fcmovnbe %st(1), %st
+fcmovnu %st(1), %st  // CHECK: fcmovnu  %st(1), %st
 
-fcmovnae %st(1), %st(0) // CHECK: fcmovb  %st(1), %st(0)
-fcmovna %st(1), %st(0)  // CHECK: fcmovbe  %st(1), %st(0)
+fcmovnae %st(1), %st // CHECK: fcmovb %st(1), %st
+fcmovna %st(1), %st  // CHECK: fcmovbe  %st(1), %st
 
-fcmovae %st(1), %st(0)  // CHECK: fcmovnb  %st(1), %st(0)
-fcmova %st(1), %st(0)   // CHECK: fcmovnbe  %st(1), %st(0)
+fcmovae %st(1), %st  // CHECK: fcmovnb  %st(1), %st
+fcmova %st(1), %st   // CHECK: fcmovnbe %st(1), %st
 
 // rdar://8456417
 .byte (88 + 1) & 15  // CHECK: .byte  9
 
 // rdar://8456412
 mov %rdx, %cr0
 // CHECK: movq  %rdx, %cr0
 // CHECK: encoding: [0x0f,0x22,0xc2]

 
 // rdar://8456371 - Handle commutable instructions written backward.
 // CHECK:   faddp %st(1)
 // CHECK: fmulp %st(2)
 faddp %st, %st(1)
 fmulp %st, %st(2)
 
 // rdar://8468087 - Encode these accurately, they are not synonyms.
-// CHECK: fmul  %st(0), %st(1)
+// CHECK: fmul  %st, %st(1)
 // CHECK: encoding: [0xdc,0xc9]
 // CHECK: fmul  %st(1)
 // CHECK: encoding: [0xd8,0xc9]
 fmul %st, %st(1)
 fmul %st(1), %st
 
-// CHECK: fadd  %st(0), %st(1)
+// CHECK: fadd  %st, %st(1)
 // CHECK: encoding: [0xdc,0xc1]
 // CHECK: fadd  %st(1)
 // CHECK: encoding: [0xd8,0xc1]
 fadd %st, %st(1)
 fadd %st(1), %st
 
 
 // rdar://8416805

 movmskpd  %xmm6, %rax
 // CHECK: movmskpd  %xmm6, %eax
 // CHECK: encoding: [0x66,0x0f,0x50,0xc6]
 movmskpd  %xmm6, %eax
 // CHECK: movmskpd  %xmm6, %eax
 // CHECK: encoding: [0x66,0x0f,0x50,0xc6]
 
 // rdar://8491845 - Gas supports commuted forms of non-commutable instructions.
-fdivrp %st(0), %st(1) // CHECK: encoding: [0xde,0xf9]
-fdivrp %st(1), %st(0) // CHECK: encoding: [0xde,0xf9]
+fdivrp %st, %st(1) // CHECK: encoding: [0xde,0xf9]
+fdivrp %st(1), %st // CHECK: encoding: [0xde,0xf9]
 
-fsubrp %st(0), %st(1) // CHECK: encoding: [0xde,0xe9]
-fsubrp %st(1), %st(0) // CHECK: encoding: [0xde,0xe9]
+fsubrp %st, %st(1) // CHECK: encoding: [0xde,0xe9]
+fsubrp %st(1), %st // CHECK: encoding: [0xde,0xe9]
 
 // also PR8861
-fdivp %st(0), %st(1) // CHECK: encoding: [0xde,0xf1]
-fdivp %st(1), %st(0) // CHECK: encoding: [0xde,0xf1]
+fdivp %st, %st(1) // CHECK: encoding: [0xde,0xf1]
+fdivp %st(1), %st // CHECK: encoding: [0xde,0xf1]
 
 
 movl  foo(%rip), %eax
 // CHECK: movl  foo(%rip), %eax
 // CHECK: encoding: [0x8b,0x05,A,A,A,A]
 // CHECK: fixup A - offset: 2, value: foo-4, kind: reloc_riprel_4byte
 
 movb  $12, foo(%rip)

 stac
 
 // CHECK: faddp %st(1)
 // CHECK: fmulp %st(1)
 // CHECK: fsubp %st(1)
 // CHECK: fsubrp %st(1)
 // CHECK: fdivp %st(1)
 // CHECK: fdivrp %st(1)
-faddp %st(0), %st(1)
-fmulp %st(0), %st(1)
-fsubp %st(0), %st(1)
-fsubrp %st(0), %st(1)
-fdivp %st(0), %st(1)
-fdivrp %st(0), %st(1)
+faddp %st, %st(1)
+fmulp %st, %st(1)
+fsubp %st, %st(1)
+fsubrp %st, %st(1)
+fdivp %st, %st(1)
+fdivrp %st, %st(1)
 
 // CHECK: faddp %st(1)
 // CHECK: fmulp %st(1)
 // CHECK: fsubp %st(1)
 // CHECK: fsubrp %st(1)
 // CHECK: fdivp %st(1)
 // CHECK: fdivrp %st(1)
-faddp %st(1), %st(0)
-fmulp %st(1), %st(0)
-fsubp %st(1), %st(0)
-fsubrp %st(1), %st(0)
-fdivp %st(1), %st(0)
-fdivrp %st(1), %st(0)
+faddp %st(1), %st
+fmulp %st(1), %st
+fsubp %st(1), %st
+fsubrp %st(1), %st
+fdivp %st(1), %st
+fdivrp %st(1), %st
 
 // CHECK: faddp %st(1)
 // CHECK: fmulp %st(1)
 // CHECK: fsubp %st(1)
 // CHECK: fsubrp %st(1)
 // CHECK: fdivp %st(1)
 // CHECK: fdivrp %st(1)
 faddp %st(1)

 fdivrp
 
 // CHECK: fadd %st(1)
 // CHECK: fmul %st(1)
 // CHECK: fsub %st(1)
 // CHECK: fsubr %st(1)
 // CHECK: fdiv %st(1)
 // CHECK: fdivr %st(1)
-fadd %st(1), %st(0)
-fmul %st(1), %st(0)
-fsub %st(1), %st(0)
-fsubr %st(1), %st(0)
-fdiv %st(1), %st(0)
-fdivr %st(1), %st(0)
-
-// CHECK: fadd %st(0), %st(1)
-// CHECK: fmul %st(0), %st(1)
-// CHECK: fsub %st(0), %st(1)
-// CHECK: fsubr %st(0), %st(1)
-// CHECK: fdiv %st(0), %st(1)
-// CHECK: fdivr %st(0), %st(1)
-fadd %st(0), %st(1)
-fmul %st(0), %st(1)
-fsub %st(0), %st(1)
-fsubr %st(0), %st(1)
-fdiv %st(0), %st(1)
-fdivr %st(0), %st(1)
+fadd %st(1), %st
+fmul %st(1), %st
+fsub %st(1), %st
+fsubr %st(1), %st
+fdiv %st(1), %st
+fdivr %st(1), %st
+
+// CHECK: fadd %st, %st(1)
+// CHECK: fmul %st, %st(1)
+// CHECK: fsub %st, %st(1)
+// CHECK: fsubr %st, %st(1)
+// CHECK: fdiv %st, %st(1)
+// CHECK: fdivr %st, %st(1)
+fadd %st, %st(1)
+fmul %st, %st(1)
+fsub %st, %st(1)
+fsubr %st, %st(1)
+fdiv %st, %st(1)
+fdivr %st, %st(1)
 
 // CHECK: fadd %st(1)
 // CHECK: fmul %st(1)
 // CHECK: fsub %st(1)
 // CHECK: fsubr %st(1)
 // CHECK: fdiv %st(1)
 // CHECK: fdivr %st(1)
 fadd %st(1)

llvm/trunk/test/tools/llvm-mca/X86/Atom/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=atom -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      99    49.50                 U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      5     5.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      5     5.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     fadd  %st(2)
 # CHECK-NEXT:  1      5     5.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  1      5     5.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      5     5.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     faddp %st(2)
 # CHECK-NEXT:  1      5     5.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  1      5     5.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.50                  U     fbld  (%ecx)
 # CHECK-NEXT:  1      100   0.50                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  1      25    12.50                 U     fnclex
-# CHECK-NEXT:  1      9     4.50                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      9     4.50                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      9     4.50                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      9     4.50                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      9     4.50                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      9     4.50                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      9     4.50                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      9     4.50                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      9     4.50                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      9     4.50                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      9     4.50                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      9     4.50                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      9     4.50                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      9     4.50                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      9     4.50                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      9     4.50                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      5     5.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     fcom  %st(3)
 # CHECK-NEXT:  1      5     5.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  1      5     5.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      5     5.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     fcomp %st(3)
 # CHECK-NEXT:  1      5     5.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  1      5     5.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcompp
 # CHECK-NEXT:  1      9     4.50                  U     fcomi %st(3)
 # CHECK-NEXT:  1      9     4.50                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      174   87.00                 U     fcos
 # CHECK-NEXT:  1      1     0.50                  U     fdecstp
-# CHECK-NEXT:  1      34    17.00                 U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      34    17.00                 U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      34    17.00                 U     fdiv  %st(2)
 # CHECK-NEXT:  1      34    17.00   *             U     fdivs (%ecx)
 # CHECK-NEXT:  1      34    17.00   *             U     fdivl (%eax)
 # CHECK-NEXT:  1      34    17.00                 U     fdivp %st(1)
 # CHECK-NEXT:  1      34    17.00                 U     fdivp %st(2)
 # CHECK-NEXT:  1      34    17.00   *             U     fidivs  (%ecx)
 # CHECK-NEXT:  1      34    17.00   *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      34    17.00                 U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      34    17.00                 U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      34    17.00                 U     fdivr %st(2)
 # CHECK-NEXT:  1      34    17.00   *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  1      34    17.00   *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      34    17.00                 U     fdivrp  %st(1)
 # CHECK-NEXT:  1      34    17.00                 U     fdivrp  %st(2)
 # CHECK-NEXT:  1      34    17.00   *             U     fidivrs (%ecx)
 # CHECK-NEXT:  1      34    17.00   *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      1     0.50                  U     ffree %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     ffree %st
 # CHECK-NEXT:  1      5     5.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  1      5     5.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  1      5     5.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  1      5     5.00                  U     ficompl (%eax)
 # CHECK-NEXT:  1      5     5.00    *             U     filds (%edx)
 # CHECK-NEXT:  1      5     5.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  1      5     5.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fincstp
 # CHECK-NEXT:  1      63    31.50                 U     fninit
 # CHECK-NEXT:  1      6     3.00           *      U     fists (%edx)
 # CHECK-NEXT:  1      6     3.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  1      6     3.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  1      6     3.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  1      6     3.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  1      2     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  1      2     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  1      2     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     1.00                  U     fld %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fld %st
 # CHECK-NEXT:  1      1     1.00    *             U     flds  (%edx)
 # CHECK-NEXT:  1      1     1.00    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      4     2.00    *             U     fldt  (%eax)
 # CHECK-NEXT:  1      5     2.50    *             U     fldcw (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fldenv  (%eax)
 # CHECK-NEXT:  1      6     3.00                  U     fld1
 # CHECK-NEXT:  1      10    5.00                  U     fldl2e
 # CHECK-NEXT:  1      10    5.00                  U     fldl2t
 # CHECK-NEXT:  1      10    5.00                  U     fldlg2
 # CHECK-NEXT:  1      10    5.00                  U     fldln2
 # CHECK-NEXT:  1      10    5.00                  U     fldpi
 # CHECK-NEXT:  1      1     0.50                  U     fldz
-# CHECK-NEXT:  1      4     4.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      4     4.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      4     4.00                  U     fmul  %st(2)
 # CHECK-NEXT:  1      4     4.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  1      4     4.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      4     4.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      4     4.00                  U     fmulp %st(2)
 # CHECK-NEXT:  1      4     4.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  1      4     4.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      183   91.50                 U     fpatan
 # CHECK-NEXT:  1      55    27.50                 U     fprem
 # CHECK-NEXT:  1      71    35.50                 U     fprem1
 # CHECK-NEXT:  1      168   84.00                 U     fptan
 # CHECK-NEXT:  1      46    23.00                 U     frndint
 # CHECK-NEXT:  1      100   0.50                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      77    38.50                 U     fscale
 # CHECK-NEXT:  1      174   87.00                 U     fsin
 # CHECK-NEXT:  1      174   87.00                 U     fsincos
 # CHECK-NEXT:  1      71    35.50                 U     fsqrt
-# CHECK-NEXT:  1      2     1.00                  U     fst %st(0)
+# CHECK-NEXT:  1      2     1.00                  U     fst %st
 # CHECK-NEXT:  1      2     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      2     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      2     1.00                  U     fstp  %st(0)
+# CHECK-NEXT:  1      2     1.00                  U     fstp  %st
 # CHECK-NEXT:  1      2     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  1      2     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  1      5     2.50           *      U     fstpt (%eax)
 # CHECK-NEXT:  1      8     4.00           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnstenv (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     frstor  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     wait
 # CHECK-NEXT:  1      100   0.50                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      5     5.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      5     5.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     fsub  %st(2)
 # CHECK-NEXT:  1      5     5.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  1      5     5.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      5     5.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     fsubp %st(2)
 # CHECK-NEXT:  1      5     5.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  1      5     5.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      5     5.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      5     5.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     fsubr %st(2)
 # CHECK-NEXT:  1      5     5.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  1      5     5.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      5     5.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      5     5.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  1      5     5.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  1      5     5.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      9     4.50                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]
 # CHECK-NEXT: 1624.00 1416.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    Instructions:
 # CHECK-NEXT: 49.50  49.50  f2xm1
 # CHECK-NEXT:  -     1.00   fabs
-# CHECK-NEXT: 5.00    -     fadd  %st(0), %st(1)
+# CHECK-NEXT: 5.00    -     fadd  %st, %st(1)
 # CHECK-NEXT: 5.00    -     fadd  %st(2)
 # CHECK-NEXT: 5.00    -     fadds (%ecx)
 # CHECK-NEXT: 5.00    -     faddl (%ecx)
 # CHECK-NEXT: 5.00    -     faddp %st(1)
 # CHECK-NEXT: 5.00    -     faddp %st(2)
 # CHECK-NEXT: 5.00    -     fiadds  (%ecx)
 # CHECK-NEXT: 5.00    -     fiaddl  (%ecx)
 # CHECK-NEXT: 0.50   0.50   fbld  (%ecx)
 # CHECK-NEXT: 0.50   0.50   fbstp (%eax)
 # CHECK-NEXT:  -     1.00   fchs
 # CHECK-NEXT: 12.50  12.50  fnclex
-# CHECK-NEXT: 4.50   4.50   fcmovb  %st(1), %st(0)
-# CHECK-NEXT: 4.50   4.50   fcmovbe %st(1), %st(0)
-# CHECK-NEXT: 4.50   4.50   fcmove  %st(1), %st(0)
-# CHECK-NEXT: 4.50   4.50   fcmovnb %st(1), %st(0)
-# CHECK-NEXT: 4.50   4.50   fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT: 4.50   4.50   fcmovne %st(1), %st(0)
-# CHECK-NEXT: 4.50   4.50   fcmovnu %st(1), %st(0)
-# CHECK-NEXT: 4.50   4.50   fcmovu  %st(1), %st(0)
+# CHECK-NEXT: 4.50   4.50   fcmovb  %st(1), %st
+# CHECK-NEXT: 4.50   4.50   fcmovbe %st(1), %st
+# CHECK-NEXT: 4.50   4.50   fcmove  %st(1), %st
+# CHECK-NEXT: 4.50   4.50   fcmovnb %st(1), %st
+# CHECK-NEXT: 4.50   4.50   fcmovnbe  %st(1), %st
+# CHECK-NEXT: 4.50   4.50   fcmovne %st(1), %st
+# CHECK-NEXT: 4.50   4.50   fcmovnu %st(1), %st
+# CHECK-NEXT: 4.50   4.50   fcmovu  %st(1), %st
 # CHECK-NEXT: 5.00    -     fcom  %st(1)
 # CHECK-NEXT: 5.00    -     fcom  %st(3)
 # CHECK-NEXT: 5.00    -     fcoms (%ecx)
 # CHECK-NEXT: 5.00    -     fcoml (%eax)
 # CHECK-NEXT: 5.00    -     fcomp %st(1)
 # CHECK-NEXT: 5.00    -     fcomp %st(3)
 # CHECK-NEXT: 5.00    -     fcomps  (%ecx)
 # CHECK-NEXT: 5.00    -     fcompl  (%eax)
 # CHECK-NEXT:  -     1.00   fcompp
 # CHECK-NEXT: 4.50   4.50   fcomi %st(3)
 # CHECK-NEXT: 4.50   4.50   fcompi  %st(3)
 # CHECK-NEXT: 87.00  87.00  fcos
 # CHECK-NEXT: 0.50   0.50   fdecstp
-# CHECK-NEXT: 17.00  17.00  fdiv  %st(0), %st(1)
+# CHECK-NEXT: 17.00  17.00  fdiv  %st, %st(1)
 # CHECK-NEXT: 17.00  17.00  fdiv  %st(2)
 # CHECK-NEXT: 17.00  17.00  fdivs (%ecx)
 # CHECK-NEXT: 17.00  17.00  fdivl (%eax)
 # CHECK-NEXT: 17.00  17.00  fdivp %st(1)
 # CHECK-NEXT: 17.00  17.00  fdivp %st(2)
 # CHECK-NEXT: 17.00  17.00  fidivs  (%ecx)
 # CHECK-NEXT: 17.00  17.00  fidivl  (%eax)
-# CHECK-NEXT: 17.00  17.00  fdivr %st(0), %st(1)
+# CHECK-NEXT: 17.00  17.00  fdivr %st, %st(1)
 # CHECK-NEXT: 17.00  17.00  fdivr %st(2)
 # CHECK-NEXT: 17.00  17.00  fdivrs  (%ecx)
 # CHECK-NEXT: 17.00  17.00  fdivrl  (%eax)
 # CHECK-NEXT: 17.00  17.00  fdivrp  %st(1)
 # CHECK-NEXT: 17.00  17.00  fdivrp  %st(2)
 # CHECK-NEXT: 17.00  17.00  fidivrs (%ecx)
 # CHECK-NEXT: 17.00  17.00  fidivrl (%eax)
-# CHECK-NEXT: 0.50   0.50   ffree %st(0)
+# CHECK-NEXT: 0.50   0.50   ffree %st
 # CHECK-NEXT: 5.00    -     ficoms  (%ecx)
 # CHECK-NEXT: 5.00    -     ficoml  (%eax)
 # CHECK-NEXT: 5.00    -     ficomps (%ecx)
 # CHECK-NEXT: 5.00    -     ficompl (%eax)
 # CHECK-NEXT: 5.00   5.00   filds (%edx)
 # CHECK-NEXT: 5.00   5.00   fildl (%ecx)
 # CHECK-NEXT: 5.00   5.00   fildll  (%eax)
 # CHECK-NEXT: 0.50   0.50   fincstp
 # CHECK-NEXT: 31.50  31.50  fninit
 # CHECK-NEXT: 3.00   3.00   fists (%edx)
 # CHECK-NEXT: 3.00   3.00   fistl (%ecx)
 # CHECK-NEXT: 3.00   3.00   fistps  (%edx)
 # CHECK-NEXT: 3.00   3.00   fistpl  (%ecx)
 # CHECK-NEXT: 3.00   3.00   fistpll (%eax)
 # CHECK-NEXT: 1.00   1.00   fisttps (%edx)
 # CHECK-NEXT: 1.00   1.00   fisttpl (%ecx)
 # CHECK-NEXT: 1.00   1.00   fisttpll  (%eax)
-# CHECK-NEXT: 1.00    -     fld %st(0)
+# CHECK-NEXT: 1.00    -     fld %st
 # CHECK-NEXT: 1.00    -     flds  (%edx)
 # CHECK-NEXT: 1.00    -     fldl  (%ecx)
 # CHECK-NEXT: 2.00   2.00   fldt  (%eax)
 # CHECK-NEXT: 2.50   2.50   fldcw (%eax)
 # CHECK-NEXT: 0.50   0.50   fldenv  (%eax)
 # CHECK-NEXT: 3.00   3.00   fld1
 # CHECK-NEXT: 5.00   5.00   fldl2e
 # CHECK-NEXT: 5.00   5.00   fldl2t
 # CHECK-NEXT: 5.00   5.00   fldlg2
 # CHECK-NEXT: 5.00   5.00   fldln2
 # CHECK-NEXT: 5.00   5.00   fldpi
 # CHECK-NEXT: 0.50   0.50   fldz
-# CHECK-NEXT: 4.00    -     fmul  %st(0), %st(1)
+# CHECK-NEXT: 4.00    -     fmul  %st, %st(1)
 # CHECK-NEXT: 4.00    -     fmul  %st(2)
 # CHECK-NEXT: 4.00    -     fmuls (%ecx)
 # CHECK-NEXT: 4.00    -     fmull (%eax)
 # CHECK-NEXT: 4.00    -     fmulp %st(1)
 # CHECK-NEXT: 4.00    -     fmulp %st(2)
 # CHECK-NEXT: 4.00    -     fimuls  (%ecx)
 # CHECK-NEXT: 4.00    -     fimull  (%eax)
 # CHECK-NEXT: 0.50   0.50   fnop
 # CHECK-NEXT: 91.50  91.50  fpatan
 # CHECK-NEXT: 27.50  27.50  fprem
 # CHECK-NEXT: 35.50  35.50  fprem1
 # CHECK-NEXT: 84.00  84.00  fptan
 # CHECK-NEXT: 23.00  23.00  frndint
 # CHECK-NEXT: 0.50   0.50   frstor  (%eax)
 # CHECK-NEXT: 0.50   0.50   fnsave  (%eax)
 # CHECK-NEXT: 38.50  38.50  fscale
 # CHECK-NEXT: 87.00  87.00  fsin
 # CHECK-NEXT: 87.00  87.00  fsincos
 # CHECK-NEXT: 35.50  35.50  fsqrt
-# CHECK-NEXT: 1.00   1.00   fst %st(0)
+# CHECK-NEXT: 1.00   1.00   fst %st
 # CHECK-NEXT: 1.00   1.00   fsts  (%edx)
 # CHECK-NEXT: 1.00   1.00   fstl  (%ecx)
-# CHECK-NEXT: 1.00   1.00   fstp  %st(0)
+# CHECK-NEXT: 1.00   1.00   fstp  %st
 # CHECK-NEXT: 1.00   1.00   fstpl (%edx)
 # CHECK-NEXT: 1.00   1.00   fstpl (%ecx)
 # CHECK-NEXT: 2.50   2.50   fstpt (%eax)
 # CHECK-NEXT: 4.00   4.00   fnstcw  (%eax)
 # CHECK-NEXT: 0.50   0.50   fnstenv (%eax)
 # CHECK-NEXT: 0.50   0.50   fnstsw  (%eax)
 # CHECK-NEXT: 0.50   0.50   frstor  (%eax)
 # CHECK-NEXT: 0.50   0.50   wait
 # CHECK-NEXT: 0.50   0.50   fnsave  (%eax)
-# CHECK-NEXT: 5.00    -     fsub  %st(0), %st(1)
+# CHECK-NEXT: 5.00    -     fsub  %st, %st(1)
 # CHECK-NEXT: 5.00    -     fsub  %st(2)
 # CHECK-NEXT: 5.00    -     fsubs (%ecx)
 # CHECK-NEXT: 5.00    -     fsubl (%eax)
 # CHECK-NEXT: 5.00    -     fsubp %st(1)
 # CHECK-NEXT: 5.00    -     fsubp %st(2)
 # CHECK-NEXT: 5.00    -     fisubs  (%ecx)
 # CHECK-NEXT: 5.00    -     fisubl  (%eax)
-# CHECK-NEXT: 5.00    -     fsubr %st(0), %st(1)
+# CHECK-NEXT: 5.00    -     fsubr %st, %st(1)
 # CHECK-NEXT: 5.00    -     fsubr %st(2)
 # CHECK-NEXT: 5.00    -     fsubrs  (%ecx)
 # CHECK-NEXT: 5.00    -     fsubrl  (%eax)
 # CHECK-NEXT: 5.00    -     fsubrp  %st(1)
 # CHECK-NEXT: 5.00    -     fsubrp  %st(2)
 # CHECK-NEXT: 5.00    -     fisubrs (%ecx)
 # CHECK-NEXT: 5.00    -     fisubrl (%eax)
 # CHECK-NEXT: 4.50   4.50   ftst

llvm/trunk/test/tools/llvm-mca/X86/BdVer2/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=bdver2 -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.50                  U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      5     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      5     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.50                  U     fbld  (%ecx)
 # CHECK-NEXT:  1      100   0.50                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  1      100   0.50                  U     fnclex
-# CHECK-NEXT:  1      1     1.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      1     1.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      1     1.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      1     1.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      1     1.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      1     1.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      1     1.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      1     1.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      1     1.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      1     1.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      1     1.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      1     1.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      1     1.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      1     1.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      1     1.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  2      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  2      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  1      6     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  1      6     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  2      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  2      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  1      6     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  1      6     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fcompp
 # CHECK-NEXT:  2      1     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  2      1     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.50                  U     fcos
 # CHECK-NEXT:  1      100   0.50                  U     fdecstp
-# CHECK-NEXT:  1      9     9.50                  U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      9     9.50                  U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      9     9.50                  U     fdiv  %st(2)
 # CHECK-NEXT:  1      14    9.50    *             U     fdivs (%ecx)
 # CHECK-NEXT:  1      14    9.50    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      9     9.50                  U     fdivp %st(1)
 # CHECK-NEXT:  1      9     9.50                  U     fdivp %st(2)
 # CHECK-NEXT:  1      14    9.50    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  1      14    9.50    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      9     9.50                  U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      9     9.50                  U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      9     9.50                  U     fdivr %st(2)
 # CHECK-NEXT:  1      14    9.50    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  1      14    9.50    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      9     9.50                  U     fdivrp  %st(1)
 # CHECK-NEXT:  1      9     9.50                  U     fdivrp  %st(2)
 # CHECK-NEXT:  1      14    9.50    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  1      14    9.50    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      100   0.50                  U     ffree %st(0)
+# CHECK-NEXT:  1      100   0.50                  U     ffree %st
 # CHECK-NEXT:  2      6     1.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  2      6     1.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  2      6     1.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  2      6     1.00                  U     ficompl (%eax)
 # CHECK-NEXT:  1      5     0.50    *             U     filds (%edx)
 # CHECK-NEXT:  1      5     0.50    *             U     fildl (%ecx)
 # CHECK-NEXT:  1      5     0.50    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fincstp
 # CHECK-NEXT:  1      100   0.50                  U     fninit
 # CHECK-NEXT:  1      1     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.50                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fld %st
 # CHECK-NEXT:  1      5     0.50    *             U     flds  (%edx)
 # CHECK-NEXT:  1      5     0.50    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      5     0.50    *             U     fldt  (%eax)
 # CHECK-NEXT:  1      5     0.50    *             U     fldcw (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fldenv  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fld1
 # CHECK-NEXT:  1      3     1.00                  U     fldl2e
 # CHECK-NEXT:  1      3     1.00                  U     fldl2t
 # CHECK-NEXT:  1      3     1.00                  U     fldlg2
 # CHECK-NEXT:  1      3     1.00                  U     fldln2
 # CHECK-NEXT:  1      3     1.00                  U     fldpi
 # CHECK-NEXT:  1      3     1.00                  U     fldz
-# CHECK-NEXT:  1      5     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      100   0.50                  U     fpatan
 # CHECK-NEXT:  1      100   0.50                  U     fprem
 # CHECK-NEXT:  1      100   0.50                  U     fprem1
 # CHECK-NEXT:  1      100   0.50                  U     fptan
 # CHECK-NEXT:  1      100   0.50                  U     frndint
 # CHECK-NEXT:  1      100   0.50                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fscale
 # CHECK-NEXT:  1      100   0.50                  U     fsin
 # CHECK-NEXT:  1      100   0.50                  U     fsincos
 # CHECK-NEXT:  1      1     17.50                 U     fsqrt
-# CHECK-NEXT:  1      1     0.50                  U     fst %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fst %st
 # CHECK-NEXT:  1      1     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     0.50                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fstp  %st
 # CHECK-NEXT:  1      1     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  1      1     0.50           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnstenv (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     wait
 # CHECK-NEXT:  1      100   0.50                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      5     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      5     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      5     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      5     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0.0]  [0.1]  [1]    [2]    [3]    [4]    [5]    [6]    [7.0]  [7.1]  [8.0]  [8.1]  [9]    [10]   [11]   [12]   [13]   [14]   [15]   [16.0] [16.1] [17]   [18]
 # CHECK-NEXT: 24.00  24.00   -      -      -     36.00  20.00   -     201.50 201.50  -      -      -     7.00   48.00  40.00   -      -      -     17.50  17.50   -     13.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0.0]  [0.1]  [1]    [2]    [3]    [4]    [5]    [6]    [7.0]  [7.1]  [8.0]  [8.1]  [9]    [10]   [11]   [12]   [13]   [14]   [15]   [16.0] [16.1] [17]   [18]   Instructions:
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     f2xm1
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fabs
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fadd %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fadd %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fadd %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fadds  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     faddl  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     faddp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     faddp  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fiadds (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fiaddl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fbld (%ecx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fbstp  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fchs
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fnclex
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmove %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovnb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovnbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovne  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovnu  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovu %st(1), %st(0)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovb %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovbe  %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmove %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovnb  %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovnbe %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovne  %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovnu  %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcmovu %st(1), %st
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcom %st(1)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcom %st(3)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fcoms  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fcoml  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcomp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcomp  %st(3)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fcomps (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fcompl (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fcompp
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcomi  %st(3)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fcompi %st(3)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fcos
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fdecstp
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdiv %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdiv %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdiv %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fdivs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fdivl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdivp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdivp  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fidivs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fidivl (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdivr  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdivr  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdivr  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fdivrs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fdivrl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdivrp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fdivrp %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fidivrs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     9.50   9.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fidivrl  (%eax)
-# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     ffree  %st(0)
+# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     ffree  %st
 # CHECK-NEXT: 0.50   0.50    -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     ficoms (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     ficoml (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     ficomps  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -     1.00    -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     ficompl  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     filds  (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     fildl  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     fildll (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fincstp
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fninit
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fists  (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fistl  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fistps (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fistpl (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fistpll  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fisttps  (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fisttpl  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fisttpll (%eax)
-# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fld  %st(0)
+# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fld  %st
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     flds (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     fldl (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     fldt (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     0.50   0.50    -      -     fldcw  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fldenv (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fld1
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fldl2e
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fldl2t
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fldlg2
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fldln2
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fldpi
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fldz
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fmul %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fmul %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fmul %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fmuls  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fmull  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fmulp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     fmulp  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fimuls (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -     0.50   0.50    -      -     fimull (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fnop
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fpatan
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fprem
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fprem1
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fptan
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     frndint
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     frstor (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fnsave (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fscale
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fsin
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fsincos
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     17.50  17.50   -      -      -      -      -     1.00    -      -      -      -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fst  %st(0)
+# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fst  %st
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fsts (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fstl (%ecx)
-# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fstp %st(0)
+# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fstp %st
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fstpl  (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fstpl  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     1.00   fstpt  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fnstcw (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fnstenv  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fnstsw (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     frstor (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     wait
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -      -      -      -      -     fnsave (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsub %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsub %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsub %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fsubs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fsubl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsubp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsubp  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fisubs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fisubl (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsubr  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsubr  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsubr  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fsubrs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fsubrl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsubrp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -      -      -      -      -     fsubrp %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fisubrs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50   0.50    -      -      -      -     1.00    -      -      -      -     0.50   0.50    -      -     fisubrl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50   0.50    -      -      -      -      -     1.00    -      -      -      -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/Broadwell/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=broadwell -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.25                  U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  2      9     1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  2      9     1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  3      12    2.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  3      12    2.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.25                  U     fbld  (%ecx)
 # CHECK-NEXT:  2      1     1.00                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  4      4     1.00                  U     fnclex
-# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  2      7     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  2      7     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  2      7     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  2      7     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fcompp
 # CHECK-NEXT:  1      3     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  1      3     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.25                  U     fcos
 # CHECK-NEXT:  2      2     1.00                  U     fdecstp
-# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdiv  %st(2)
 # CHECK-NEXT:  2      21    1.00    *             U     fdivs (%ecx)
 # CHECK-NEXT:  2      21    1.00    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(2)
 # CHECK-NEXT:  3      24    1.00    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  3      24    1.00    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      20    1.00                  U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      20    1.00                  U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivr %st(2)
 # CHECK-NEXT:  2      26    1.00    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  2      26    1.00    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(2)
 # CHECK-NEXT:  3      29    1.00    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  3      29    1.00    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      100   0.25                  U     ffree %st(0)
+# CHECK-NEXT:  1      100   0.25                  U     ffree %st
 # CHECK-NEXT:  3      10    2.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  3      10    2.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  3      10    2.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  3      10    2.00                  U     ficompl (%eax)
 # CHECK-NEXT:  2      9     1.00    *             U     filds (%edx)
 # CHECK-NEXT:  2      9     1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  2      9     1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fincstp
 # CHECK-NEXT:  15     75    6.00                  U     fninit
 # CHECK-NEXT:  3      4     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.25                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fld %st
 # CHECK-NEXT:  1      6     0.50    *             U     flds  (%edx)
 # CHECK-NEXT:  1      6     0.50    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      6     0.50    *             U     fldt  (%eax)
 # CHECK-NEXT:  3      7     1.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  64     60    14.00                 U     fldenv  (%eax)
 # CHECK-NEXT:  2      1     1.00                  U     fld1
 # CHECK-NEXT:  2      1     1.00                  U     fldl2e
 # CHECK-NEXT:  2      1     1.00                  U     fldl2t
 # CHECK-NEXT:  2      1     1.00                  U     fldlg2
 # CHECK-NEXT:  2      1     1.00                  U     fldln2
 # CHECK-NEXT:  2      1     1.00                  U     fldpi
 # CHECK-NEXT:  1      1     0.50                  U     fldz
-# CHECK-NEXT:  1      5     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  2      11    1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  2      11    1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  3      14    1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  3      14    1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      100   0.25                  U     fpatan
 # CHECK-NEXT:  1      100   0.25                  U     fprem
 # CHECK-NEXT:  1      100   0.25                  U     fprem1
 # CHECK-NEXT:  1      100   0.25                  U     fptan
 # CHECK-NEXT:  1      100   0.25                  U     frndint
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fscale
 # CHECK-NEXT:  1      100   0.25                  U     fsin
 # CHECK-NEXT:  1      100   0.25                  U     fsincos
 # CHECK-NEXT:  1      23    9.00                  U     fsqrt
-# CHECK-NEXT:  1      1     0.25                  U     fst %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fst %st
 # CHECK-NEXT:  1      1     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     0.25                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fstp  %st
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  3      2     1.00           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  100    115   19.50                 U     fnstenv (%eax)
 # CHECK-NEXT:  3      4     1.00                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  2      2     0.50                  U     wait
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  2      9     1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  2      9     1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  3      12    2.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  3      12    2.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  2      9     1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  2      9     1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  3      12    2.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  3      12    2.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]
 # CHECK-NEXT:  -     9.00   116.92 145.92 49.00  49.00  27.00  59.42  69.75  9.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    Instructions:
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     f2xm1
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fabs
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fadds (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     faddl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fiaddl  (%ecx)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fbld  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fbstp (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fchs
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -     1.00   1.00    -     fnclex
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcom  %st(3)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcoms (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcoml (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcomp %st(3)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcomps  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcompl  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fcompp
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcomi %st(3)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fcos
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fdecstp
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivl (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivs  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivl  (%eax)
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrl  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivrs (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivrl (%eax)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     ffree %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     ffree %st
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficoms  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficoml  (%eax)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficomps (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficompl (%eax)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     filds (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fildl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fildll  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fincstp
 # CHECK-NEXT:  -      -     3.00   3.00    -      -      -     7.50   1.50    -     fninit
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fists (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistps  (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistpll (%eax)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fisttps (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fisttpll  (%eax)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fld %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fld %st
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     flds  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldl  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldt  (%eax)
 # CHECK-NEXT:  -      -     1.50   0.50   0.50   0.50    -      -      -      -     fldcw (%eax)
 # CHECK-NEXT:  -      -     18.92  11.42  4.00   4.00    -     10.92  14.75   -     fldenv  (%eax)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fld1
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldl2e
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldl2t
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldlg2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldln2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldpi
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fldz
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmuls (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmull (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fimuls  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fimull  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fnop
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fpatan
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fprem
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fprem1
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fptan
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frndint
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fnsave  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fscale
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsin
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsincos
 # CHECK-NEXT:  -     9.00   1.00    -      -      -      -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fst %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fst %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstl  (%ecx)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fstp  %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fstp  %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -     1.00   0.33   fnstcw  (%eax)
 # CHECK-NEXT:  -      -     27.00  16.50  3.67   3.67   11.00  15.50  19.00  3.67   fnstenv (%eax)
 # CHECK-NEXT:  -      -     1.00    -     0.33   0.33   1.00    -      -     0.33   fnstsw  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -     0.50   0.50    -     wait
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubs (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubl  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubrl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/BtVer2/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=btver2 -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.50                  U     f2xm1
 # CHECK-NEXT:  1      2     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  1      8     1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  1      8     1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  1      8     1.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  1      8     1.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.50                  U     fbld  (%ecx)
 # CHECK-NEXT:  1      100   0.50                  U     fbstp (%eax)
 # CHECK-NEXT:  1      2     1.00                  U     fchs
 # CHECK-NEXT:  1      100   0.50                  U     fnclex
-# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      3     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  1      8     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  1      8     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  1      8     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  1      8     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fcompp
 # CHECK-NEXT:  1      3     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  1      3     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.50                  U     fcos
 # CHECK-NEXT:  1      100   0.50                  U     fdecstp
-# CHECK-NEXT:  1      19    19.00                 U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      19    19.00                 U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      19    19.00                 U     fdiv  %st(2)
 # CHECK-NEXT:  1      24    19.00   *             U     fdivs (%ecx)
 # CHECK-NEXT:  1      24    19.00   *             U     fdivl (%eax)
 # CHECK-NEXT:  1      19    19.00                 U     fdivp %st(1)
 # CHECK-NEXT:  1      19    19.00                 U     fdivp %st(2)
 # CHECK-NEXT:  1      24    19.00   *             U     fidivs  (%ecx)
 # CHECK-NEXT:  1      24    19.00   *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      19    19.00                 U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      19    19.00                 U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      19    19.00                 U     fdivr %st(2)
 # CHECK-NEXT:  1      24    19.00   *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  1      24    19.00   *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      19    19.00                 U     fdivrp  %st(1)
 # CHECK-NEXT:  1      19    19.00                 U     fdivrp  %st(2)
 # CHECK-NEXT:  1      24    19.00   *             U     fidivrs (%ecx)
 # CHECK-NEXT:  1      24    19.00   *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      100   0.50                  U     ffree %st(0)
+# CHECK-NEXT:  1      100   0.50                  U     ffree %st
 # CHECK-NEXT:  1      8     1.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  1      8     1.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  1      8     1.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  1      8     1.00                  U     ficompl (%eax)
 # CHECK-NEXT:  1      3     1.00    *             U     filds (%edx)
 # CHECK-NEXT:  1      3     1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  1      3     1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fincstp
 # CHECK-NEXT:  1      100   0.50                  U     fninit
 # CHECK-NEXT:  1      1     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.50                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fld %st
 # CHECK-NEXT:  1      3     1.00    *             U     flds  (%edx)
 # CHECK-NEXT:  1      3     1.00    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      3     1.00    *             U     fldt  (%eax)
 # CHECK-NEXT:  1      3     1.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fldenv  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fld1
 # CHECK-NEXT:  1      3     1.00                  U     fldl2e
 # CHECK-NEXT:  1      3     1.00                  U     fldl2t
 # CHECK-NEXT:  1      3     1.00                  U     fldlg2
 # CHECK-NEXT:  1      3     1.00                  U     fldln2
 # CHECK-NEXT:  1      3     1.00                  U     fldpi
 # CHECK-NEXT:  1      3     1.00                  U     fldz
-# CHECK-NEXT:  1      2     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      2     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      2     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  1      7     1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  1      7     1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      2     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      2     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  1      7     1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  1      7     1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      100   0.50                  U     fpatan
 # CHECK-NEXT:  1      100   0.50                  U     fprem
 # CHECK-NEXT:  1      100   0.50                  U     fprem1
 # CHECK-NEXT:  1      100   0.50                  U     fptan
 # CHECK-NEXT:  1      100   0.50                  U     frndint
 # CHECK-NEXT:  1      100   0.50                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fscale
 # CHECK-NEXT:  1      100   0.50                  U     fsin
 # CHECK-NEXT:  1      100   0.50                  U     fsincos
 # CHECK-NEXT:  1      35    35.00                 U     fsqrt
-# CHECK-NEXT:  1      1     0.50                  U     fst %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fst %st
 # CHECK-NEXT:  1      1     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     0.50                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fstp  %st
 # CHECK-NEXT:  1      1     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  1      1     0.50           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnstenv (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.50                  U     wait
 # CHECK-NEXT:  1      100   0.50                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  1      8     1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  1      8     1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  1      8     1.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  1      8     1.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  1      8     1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  1      8     1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  1      8     1.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  1      8     1.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   [11]   [12]   [13]
 # CHECK-NEXT: 42.00  20.00   -     54.00  349.00 54.00  34.00  39.00   -     13.00  7.00    -      -      -
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   [11]   [12]   [13]   Instructions:
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     f2xm1
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fabs
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fadds (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     faddl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fiaddl  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fbld  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fbstp (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fchs
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fnclex
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcmovu  %st(1), %st
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcom  %st(1)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcom  %st(3)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fcoms (%ecx)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fcoml (%eax)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcomp %st(1)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcomp %st(3)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fcomps  (%ecx)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fcompl  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fcompp
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcomi %st(3)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fcompi  %st(3)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fcos
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fdecstp
-# CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fdivs (%ecx)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fdivl (%eax)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fidivs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fidivl  (%eax)
-# CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fdivrs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fdivrl  (%eax)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00    -      -      -      -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fidivrs (%ecx)
 # CHECK-NEXT:  -      -      -      -     19.00   -     1.00   1.00    -      -      -      -      -      -     fidivrl (%eax)
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     ffree %st(0)
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     ffree %st
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     ficoms  (%ecx)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     ficoml  (%eax)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     ficomps (%ecx)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     ficompl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -      -      -     filds (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -      -      -     fildl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -      -      -     fildll  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fincstp
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fninit
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fists (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fistl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fistps  (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fistpll (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fisttps (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fisttpll  (%eax)
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fld %st(0)
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fld %st
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -      -      -     flds  (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -      -      -     fldl  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -      -      -     fldt  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -      -      -     fldcw (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fldenv  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -     1.00    -      -      -     1.00    -      -      -     fld1
 # CHECK-NEXT:  -      -      -      -      -      -     1.00    -      -      -     1.00    -      -      -     fldl2e
 # CHECK-NEXT:  -      -      -      -      -      -     1.00    -      -      -     1.00    -      -      -     fldl2t
 # CHECK-NEXT:  -      -      -      -      -      -     1.00    -      -      -     1.00    -      -      -     fldlg2
 # CHECK-NEXT:  -      -      -      -      -      -     1.00    -      -      -     1.00    -      -      -     fldln2
 # CHECK-NEXT:  -      -      -      -      -      -     1.00    -      -      -     1.00    -      -      -     fldpi
 # CHECK-NEXT:  -      -      -      -      -      -     1.00    -      -      -     1.00    -      -      -     fldz
-# CHECK-NEXT:  -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00    -      -      -      -      -      -     fmuls (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00    -      -      -      -      -      -     fmull (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00    -      -      -      -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00    -      -      -      -      -      -     fimuls  (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00    -      -      -      -      -      -     fimull  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fnop
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fpatan
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fprem
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fprem1
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fptan
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     frndint
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     frstor  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fnsave  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fscale
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fsin
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fsincos
 # CHECK-NEXT:  -      -      -      -     35.00   -     1.00    -      -      -      -      -      -      -     fsqrt
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fst %st(0)
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fst %st
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fstl  (%ecx)
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fstp  %st(0)
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fstp  %st
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -     1.00    -      -      -      -     fstpt (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fnstcw  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fnstenv (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fnstsw  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     frstor  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     wait
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -      -      -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fsubs (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fsubl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fisubl  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -     1.00    -     1.00    -      -      -      -      -      -     fisubrl (%eax)
 # CHECK-NEXT: 1.00    -      -     1.00    -     1.00    -      -      -      -      -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/Generic/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.33                  U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.33                  U     fbld  (%ecx)
 # CHECK-NEXT:  1      100   0.33                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  1      100   0.33                  U     fnclex
-# CHECK-NEXT:  3      3     2.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  3      3     2.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fcompp
 # CHECK-NEXT:  3      3     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  3      3     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.33                  U     fcos
 # CHECK-NEXT:  1      1     1.00                  U     fdecstp
-# CHECK-NEXT:  1      14    14.00                 U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      14    14.00                 U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdiv  %st(2)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivs (%ecx)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      14    14.00                 U     fdivp %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdivp %st(2)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      14    14.00                 U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      14    14.00                 U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdivr %st(2)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      14    14.00                 U     fdivrp  %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdivrp  %st(2)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      1     1.00                  U     ffree %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     ffree %st
 # CHECK-NEXT:  3      11    2.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  3      11    2.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficompl (%eax)
 # CHECK-NEXT:  2      10    1.00    *             U     filds (%edx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fincstp
 # CHECK-NEXT:  4      5     1.33                  U     fninit
 # CHECK-NEXT:  4      9     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  3      5     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  3      5     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  3      5     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     1.00                  U     fld %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fld %st
 # CHECK-NEXT:  3      9     1.00    *             U     flds  (%edx)
 # CHECK-NEXT:  3      9     1.00    *             U     fldl  (%ecx)
 # CHECK-NEXT:  3      9     1.00    *             U     fldt  (%eax)
 # CHECK-NEXT:  5      8     2.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fldenv  (%eax)
 # CHECK-NEXT:  2      1     1.00                  U     fld1
 # CHECK-NEXT:  2      1     1.00                  U     fldl2e
 # CHECK-NEXT:  2      1     1.00                  U     fldl2t
 # CHECK-NEXT:  2      1     1.00                  U     fldlg2
 # CHECK-NEXT:  2      1     1.00                  U     fldln2
 # CHECK-NEXT:  2      1     1.00                  U     fldpi
 # CHECK-NEXT:  1      1     1.00                  U     fldz
-# CHECK-NEXT:  1      5     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  2      12    1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  2      12    1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  3      15    1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  3      15    1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fnop
 # CHECK-NEXT:  1      100   0.33                  U     fpatan
 # CHECK-NEXT:  1      100   0.33                  U     fprem
 # CHECK-NEXT:  1      100   0.33                  U     fprem1
 # CHECK-NEXT:  1      100   0.33                  U     fptan
 # CHECK-NEXT:  1      100   0.33                  U     frndint
 # CHECK-NEXT:  1      100   0.33                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fscale
 # CHECK-NEXT:  1      100   0.33                  U     fsin
 # CHECK-NEXT:  1      100   0.33                  U     fsincos
 # CHECK-NEXT:  1      24    24.00                 U     fsqrt
-# CHECK-NEXT:  1      1     1.00                  U     fst %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fst %st
 # CHECK-NEXT:  3      6     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  3      6     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     1.00                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fstp  %st
 # CHECK-NEXT:  3      6     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  3      6     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  3      6     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  4      7     1.00           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fnstenv (%eax)
 # CHECK-NEXT:  4      7     1.00                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     wait
 # CHECK-NEXT:  1      100   0.33                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6.0]  [6.1]
 # CHECK-NEXT:  -     136.00 52.67  90.67  17.00  54.67  34.00  34.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6.0]  [6.1]  Instructions:
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     f2xm1
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fabs
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fadds (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   faddl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fiaddl  (%ecx)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fbld  (%ecx)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fbstp (%eax)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fchs
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnclex
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcom  %st(3)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcoms (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcoml (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcomp %st(3)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcomps  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcompl  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fcompp
 # CHECK-NEXT:  -      -     1.00   1.00    -     1.00    -      -     fcomi %st(3)
 # CHECK-NEXT:  -      -     1.00   1.00    -     1.00    -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fcos
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fdecstp
-# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivl (%eax)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivs  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivl  (%eax)
-# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivrs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivrl  (%eax)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivrs (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivrl (%eax)
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     ffree %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     ffree %st
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficoms  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficoml  (%eax)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficomps (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficompl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   filds (%edx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fildl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fildll  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fincstp
 # CHECK-NEXT:  -      -     1.00   1.00    -     2.00    -      -     fninit
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fists (%edx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistps  (%edx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistpll (%eax)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     0.50   0.50   fisttps (%edx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     0.50   0.50   fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     0.50   0.50   fisttpll  (%eax)
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fld %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fld %st
 # CHECK-NEXT:  -      -     0.50   0.50    -     1.00   0.50   0.50   flds  (%edx)
 # CHECK-NEXT:  -      -     0.50   0.50    -     1.00   0.50   0.50   fldl  (%ecx)
 # CHECK-NEXT:  -      -     0.50   0.50    -     1.00   0.50   0.50   fldt  (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00   2.00   1.00   1.00   fldcw (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fldenv  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -     1.00    -      -     fld1
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldl2e
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldl2t
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldlg2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldln2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldpi
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fldz
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fmuls (%ecx)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fmull (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fimuls  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fimull  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fnop
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fpatan
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fprem
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fprem1
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fptan
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     frndint
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnsave  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fscale
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fsin
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fsincos
 # CHECK-NEXT:  -     24.00  1.00    -      -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fst %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fst %st
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstl  (%ecx)
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fstp  %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fstp  %st
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00   1.00   1.00   1.00   fnstcw  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnstenv (%eax)
 # CHECK-NEXT:  -      -     1.00    -     1.00    -     1.00   1.00   fnstsw  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     wait
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubs (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubl  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubrl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/Haswell/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=haswell -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.25                  U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  43     47    10.75                 U     fbld  (%ecx)
 # CHECK-NEXT:  2      1     1.00                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  4      4     1.00                  U     fnclex
-# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  2      1     0.50                  U     fcompp
 # CHECK-NEXT:  3      1     0.50                  U     fcomi %st(3)
 # CHECK-NEXT:  3      1     0.50                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.25                  U     fcos
 # CHECK-NEXT:  2      2     1.00                  U     fdecstp
-# CHECK-NEXT:  1      24    1.00                  U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      24    1.00                  U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdiv  %st(2)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivs (%ecx)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      24    1.00                  U     fdivp %st(1)
 # CHECK-NEXT:  1      24    1.00                  U     fdivp %st(2)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      20    1.00                  U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      20    1.00                  U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      24    1.00                  U     fdivr %st(2)
 # CHECK-NEXT:  2      27    1.00    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  2      27    1.00    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(2)
 # CHECK-NEXT:  3      30    1.00    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  3      30    1.00    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      1     0.50                  U     ffree %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     ffree %st
 # CHECK-NEXT:  3      11    2.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  3      11    2.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficompl (%eax)
 # CHECK-NEXT:  2      10    1.00    *             U     filds (%edx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fincstp
 # CHECK-NEXT:  15     75    6.00                  U     fninit
 # CHECK-NEXT:  3      4     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.50                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fld %st
 # CHECK-NEXT:  1      7     0.50    *             U     flds  (%edx)
 # CHECK-NEXT:  1      7     0.50    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      7     0.50    *             U     fldt  (%eax)
 # CHECK-NEXT:  3      7     1.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  64     61    14.00                 U     fldenv  (%eax)
 # CHECK-NEXT:  2      1     1.00                  U     fld1
 # CHECK-NEXT:  2      1     1.00                  U     fldl2e
 # CHECK-NEXT:  2      1     1.00                  U     fldl2t
 # CHECK-NEXT:  2      1     1.00                  U     fldlg2
 # CHECK-NEXT:  2      1     1.00                  U     fldln2
 # CHECK-NEXT:  2      1     1.00                  U     fldpi
 # CHECK-NEXT:  1      1     0.50                  U     fldz
-# CHECK-NEXT:  1      5     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  2      12    1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  2      12    1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  3      15    1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  3      15    1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      100   0.25                  U     fpatan
 # CHECK-NEXT:  28     19    7.00                  U     fprem
 # CHECK-NEXT:  41     27    10.25                 U     fprem1
 # CHECK-NEXT:  1      100   0.25                  U     fptan
 # CHECK-NEXT:  17     11    4.25                  U     frndint
 # CHECK-NEXT:  90     1     22.50                 U     frstor  (%eax)
 # CHECK-NEXT:  147    1     36.75                 U     fnsave  (%eax)
 # CHECK-NEXT:  50     75    12.50                 U     fscale
 # CHECK-NEXT:  1      100   0.25                  U     fsin
 # CHECK-NEXT:  1      100   0.25                  U     fsincos
 # CHECK-NEXT:  1      23    17.00                 U     fsqrt
-# CHECK-NEXT:  1      1     0.50                  U     fst %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fst %st
 # CHECK-NEXT:  1      1     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     0.50                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fstp  %st
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  3      2     1.00           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  100    115   19.50                 U     fnstenv (%eax)
 # CHECK-NEXT:  3      4     1.00                  U     fnstsw  (%eax)
 # CHECK-NEXT:  90     1     22.50                 U     frstor  (%eax)
 # CHECK-NEXT:  2      2     0.50                  U     wait
 # CHECK-NEXT:  147    1     36.75                 U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]
 # CHECK-NEXT:  -     17.00  121.42 145.42 49.00  49.00  27.00  56.92  65.25  9.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    Instructions:
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     f2xm1
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fabs
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fadds (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     faddl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fiaddl  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     fbld  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fbstp (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fchs
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -     1.00   1.00    -     fnclex
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcom  %st(3)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcoms (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcoml (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcomp %st(3)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcomps  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fcompl  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fcompp
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fcomi %st(3)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fcos
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fdecstp
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivl (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivs  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivl  (%eax)
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrl  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivrs (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fidivrl (%eax)
-# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     ffree %st(0)
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     ffree %st
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficoms  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficoml  (%eax)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficomps (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     ficompl (%eax)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     filds (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fildl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fildll  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fincstp
 # CHECK-NEXT:  -      -     3.00   3.00    -      -      -     7.50   1.50    -     fninit
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fists (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistps  (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fistpll (%eax)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fisttps (%edx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.33   0.33   1.00    -      -     0.33   fisttpll  (%eax)
-# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fld %st(0)
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fld %st
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     flds  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldl  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldt  (%eax)
 # CHECK-NEXT:  -      -     1.50   0.50   0.50   0.50    -      -      -      -     fldcw (%eax)
 # CHECK-NEXT:  -      -     18.92  11.42  4.00   4.00    -     10.92  14.75   -     fldenv  (%eax)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fld1
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldl2e
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldl2t
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldlg2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldln2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -      -      -     fldpi
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fldz
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmuls (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmull (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fimuls  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00   0.50   0.50    -      -      -      -     fimull  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fnop
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fpatan
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     fprem
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     fprem1
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fptan
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     frndint
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     fnsave  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     fscale
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsin
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsincos
 # CHECK-NEXT:  -     17.00  1.00    -      -      -      -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fst %st(0)
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fst %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstl  (%ecx)
-# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fstp  %st(0)
+# CHECK-NEXT:  -      -     0.50   0.50    -      -      -      -      -      -     fstp  %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -     1.00   0.33   fnstcw  (%eax)
 # CHECK-NEXT:  -      -     27.00  16.50  3.67   3.67   11.00  15.50  19.00  3.67   fnstenv (%eax)
 # CHECK-NEXT:  -      -     1.00    -     0.33   0.33   1.00    -      -     0.33   fnstsw  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -     0.50   0.50    -     wait
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubs (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubl  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   0.50   0.50    -      -      -      -     fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -     2.00   0.50   0.50    -      -      -      -     fisubrl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/SLM/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=slm -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   1.00                  U     f2xm1
 # CHECK-NEXT:  1      1     0.50                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  1      6     1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  1      6     1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  1      6     1.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  1      6     1.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   1.00                  U     fbld  (%ecx)
 # CHECK-NEXT:  1      100   1.00                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fchs
 # CHECK-NEXT:  1      100   1.00                  U     fnclex
-# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      3     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  1      6     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  1      6     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  1      6     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  1      6     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     fcompp
 # CHECK-NEXT:  1      3     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  1      3     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   1.00                  U     fcos
 # CHECK-NEXT:  1      100   1.00                  U     fdecstp
-# CHECK-NEXT:  1      19    17.00                 U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      19    17.00                 U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      19    17.00                 U     fdiv  %st(2)
 # CHECK-NEXT:  1      22    17.00   *             U     fdivs (%ecx)
 # CHECK-NEXT:  1      22    17.00   *             U     fdivl (%eax)
 # CHECK-NEXT:  1      19    17.00                 U     fdivp %st(1)
 # CHECK-NEXT:  1      19    17.00                 U     fdivp %st(2)
 # CHECK-NEXT:  1      22    17.00   *             U     fidivs  (%ecx)
 # CHECK-NEXT:  1      22    17.00   *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      19    17.00                 U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      19    17.00                 U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      19    17.00                 U     fdivr %st(2)
 # CHECK-NEXT:  1      22    17.00   *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  1      22    17.00   *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      19    17.00                 U     fdivrp  %st(1)
 # CHECK-NEXT:  1      19    17.00                 U     fdivrp  %st(2)
 # CHECK-NEXT:  1      22    17.00   *             U     fidivrs (%ecx)
 # CHECK-NEXT:  1      22    17.00   *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      100   1.00                  U     ffree %st(0)
+# CHECK-NEXT:  1      100   1.00                  U     ffree %st
 # CHECK-NEXT:  1      6     1.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  1      6     1.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  1      6     1.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  1      6     1.00                  U     ficompl (%eax)
 # CHECK-NEXT:  1      3     1.00    *             U     filds (%edx)
 # CHECK-NEXT:  1      3     1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  1      3     1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     fincstp
 # CHECK-NEXT:  1      100   1.00                  U     fninit
 # CHECK-NEXT:  1      1     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.50                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fld %st
 # CHECK-NEXT:  1      3     1.00    *             U     flds  (%edx)
 # CHECK-NEXT:  1      3     1.00    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      3     1.00    *             U     fldt  (%eax)
 # CHECK-NEXT:  1      3     1.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     fldenv  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fld1
 # CHECK-NEXT:  2      1     1.00                  U     fldl2e
 # CHECK-NEXT:  2      1     1.00                  U     fldl2t
 # CHECK-NEXT:  2      1     1.00                  U     fldlg2
 # CHECK-NEXT:  2      1     1.00                  U     fldln2
 # CHECK-NEXT:  2      1     1.00                  U     fldpi
 # CHECK-NEXT:  1      1     0.50                  U     fldz
-# CHECK-NEXT:  1      5     2.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      5     2.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      5     2.00                  U     fmul  %st(2)
 # CHECK-NEXT:  1      8     2.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  1      8     2.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      5     2.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      5     2.00                  U     fmulp %st(2)
 # CHECK-NEXT:  1      8     2.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  1      8     2.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      100   1.00                  U     fpatan
 # CHECK-NEXT:  1      100   1.00                  U     fprem
 # CHECK-NEXT:  1      100   1.00                  U     fprem1
 # CHECK-NEXT:  1      100   1.00                  U     fptan
 # CHECK-NEXT:  1      100   1.00                  U     frndint
 # CHECK-NEXT:  1      100   1.00                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     fscale
 # CHECK-NEXT:  1      100   1.00                  U     fsin
 # CHECK-NEXT:  1      100   1.00                  U     fsincos
 # CHECK-NEXT:  1      40    40.00                 U     fsqrt
-# CHECK-NEXT:  1      1     0.50                  U     fst %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fst %st
 # CHECK-NEXT:  1      1     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     0.50                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fstp  %st
 # CHECK-NEXT:  1      1     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  1      1     0.50           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     fnstenv (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   1.00                  U     wait
 # CHECK-NEXT:  1      100   1.00                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  1      6     1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  1      6     1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  1      6     1.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  1      6     1.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  1      6     1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  1      6     1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  1      6     1.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  1      6     1.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]
 # CHECK-NEXT:  -     312.00 16.00  65.00  61.00  9.50   9.50   52.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    Instructions:
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     f2xm1
 # CHECK-NEXT:  -      -      -     0.50   0.50    -      -      -     fabs
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fadds (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   faddl (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fiaddl  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fbld  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fbstp (%eax)
 # CHECK-NEXT:  -      -      -     0.50   0.50    -      -      -     fchs
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fnclex
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcom  %st(3)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fcoms (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fcoml (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcomp %st(3)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fcomps  (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fcompl  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcompp
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcomi %st(3)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcos
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fdecstp
-# CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fdivs (%ecx)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fdivl (%eax)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fidivs  (%ecx)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fidivl  (%eax)
-# CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fdivrs  (%ecx)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fdivrl  (%eax)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fidivrs (%ecx)
 # CHECK-NEXT:  -     17.00   -     1.00    -      -      -     1.00   fidivrl (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     ffree %st(0)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     ffree %st
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   ficoms  (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   ficoml  (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   ficomps (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   ficompl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00   filds (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00   fildl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00   fildll  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fincstp
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fninit
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fists (%edx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fistl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fistps  (%edx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fistpll (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fisttps (%edx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fisttpll  (%eax)
-# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -     fld %st(0)
+# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -     fld %st
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00   flds  (%edx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00   fldl  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00   fldt  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00   fldcw (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fldenv  (%eax)
 # CHECK-NEXT:  -      -      -     0.50   0.50    -      -      -     fld1
 # CHECK-NEXT:  -      -      -     1.00   1.00    -      -      -     fldl2e
 # CHECK-NEXT:  -      -      -     1.00   1.00    -      -      -     fldl2t
 # CHECK-NEXT:  -      -      -     1.00   1.00    -      -      -     fldlg2
 # CHECK-NEXT:  -      -      -     1.00   1.00    -      -      -     fldln2
 # CHECK-NEXT:  -      -      -     1.00   1.00    -      -      -     fldpi
 # CHECK-NEXT:  -      -      -     0.50   0.50    -      -      -     fldz
-# CHECK-NEXT:  -      -     2.00   1.00    -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -     2.00   1.00    -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -     2.00   1.00    -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -     2.00   1.00    -      -      -     1.00   fmuls (%ecx)
 # CHECK-NEXT:  -      -     2.00   1.00    -      -      -     1.00   fmull (%eax)
 # CHECK-NEXT:  -      -     2.00   1.00    -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -     2.00   1.00    -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -     2.00   1.00    -      -      -     1.00   fimuls  (%ecx)
 # CHECK-NEXT:  -      -     2.00   1.00    -      -      -     1.00   fimull  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -     fnop
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fpatan
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fprem
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fprem1
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fptan
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     frndint
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fnsave  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fscale
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsin
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsincos
 # CHECK-NEXT:  -     40.00   -     1.00    -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -     fst %st(0)
+# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -     fst %st
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fstl  (%ecx)
-# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -     fstp  %st(0)
+# CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -     fstp  %st
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50   1.00   fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -      -     0.50   0.50    -     fnstcw  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fnstenv (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fnstsw  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     wait
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fsubs (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fsubl (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fisubl  (%eax)
-# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -     1.00   fisubrl (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00    -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/SandyBridge/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=sandybridge -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.33                  U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.33                  U     fbld  (%ecx)
 # CHECK-NEXT:  1      100   0.33                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  1      100   0.33                  U     fnclex
-# CHECK-NEXT:  3      3     2.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  3      3     2.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  3      3     2.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  3      3     2.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fcompp
 # CHECK-NEXT:  3      3     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  3      3     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.33                  U     fcos
 # CHECK-NEXT:  1      1     1.00                  U     fdecstp
-# CHECK-NEXT:  1      14    14.00                 U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      14    14.00                 U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdiv  %st(2)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivs (%ecx)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      14    14.00                 U     fdivp %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdivp %st(2)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      14    14.00                 U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      14    14.00                 U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdivr %st(2)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  2      31    1.00    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      14    14.00                 U     fdivrp  %st(1)
 # CHECK-NEXT:  1      14    14.00                 U     fdivrp  %st(2)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  3      34    1.00    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      1     1.00                  U     ffree %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     ffree %st
 # CHECK-NEXT:  3      11    2.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  3      11    2.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficompl (%eax)
 # CHECK-NEXT:  2      10    1.00    *             U     filds (%edx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fincstp
 # CHECK-NEXT:  4      5     1.33                  U     fninit
 # CHECK-NEXT:  4      9     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  4      9     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  3      5     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  3      5     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  3      5     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     1.00                  U     fld %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fld %st
 # CHECK-NEXT:  3      9     1.00    *             U     flds  (%edx)
 # CHECK-NEXT:  3      9     1.00    *             U     fldl  (%ecx)
 # CHECK-NEXT:  3      9     1.00    *             U     fldt  (%eax)
 # CHECK-NEXT:  5      8     2.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fldenv  (%eax)
 # CHECK-NEXT:  2      1     1.00                  U     fld1
 # CHECK-NEXT:  2      1     1.00                  U     fldl2e
 # CHECK-NEXT:  2      1     1.00                  U     fldl2t
 # CHECK-NEXT:  2      1     1.00                  U     fldlg2
 # CHECK-NEXT:  2      1     1.00                  U     fldln2
 # CHECK-NEXT:  2      1     1.00                  U     fldpi
 # CHECK-NEXT:  1      1     1.00                  U     fldz
-# CHECK-NEXT:  1      5     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      5     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  2      12    1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  2      12    1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      5     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  3      15    1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  3      15    1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fnop
 # CHECK-NEXT:  1      100   0.33                  U     fpatan
 # CHECK-NEXT:  1      100   0.33                  U     fprem
 # CHECK-NEXT:  1      100   0.33                  U     fprem1
 # CHECK-NEXT:  1      100   0.33                  U     fptan
 # CHECK-NEXT:  1      100   0.33                  U     frndint
 # CHECK-NEXT:  1      100   0.33                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fscale
 # CHECK-NEXT:  1      100   0.33                  U     fsin
 # CHECK-NEXT:  1      100   0.33                  U     fsincos
 # CHECK-NEXT:  1      24    24.00                 U     fsqrt
-# CHECK-NEXT:  1      1     1.00                  U     fst %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fst %st
 # CHECK-NEXT:  3      6     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  3      6     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     1.00                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     1.00                  U     fstp  %st
 # CHECK-NEXT:  3      6     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  3      6     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  3      6     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  4      7     1.00           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     fnstenv (%eax)
 # CHECK-NEXT:  4      7     1.00                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.33                  U     wait
 # CHECK-NEXT:  1      100   0.33                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6.0]  [6.1]
 # CHECK-NEXT:  -     136.00 52.67  90.67  17.00  54.67  34.00  34.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6.0]  [6.1]  Instructions:
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     f2xm1
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fabs
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fadds (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   faddl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fiaddl  (%ecx)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fbld  (%ecx)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fbstp (%eax)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fchs
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnclex
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -     0.50    -      -     2.50    -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcom  %st(3)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcoms (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcoml (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fcomp %st(3)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcomps  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fcompl  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fcompp
 # CHECK-NEXT:  -      -     1.00   1.00    -     1.00    -      -     fcomi %st(3)
 # CHECK-NEXT:  -      -     1.00   1.00    -     1.00    -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fcos
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fdecstp
-# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivl (%eax)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivs  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivl  (%eax)
-# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivrs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fdivrl  (%eax)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -     14.00  1.00    -      -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivrs (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fidivrl (%eax)
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     ffree %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     ffree %st
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficoms  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficoml  (%eax)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficomps (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   ficompl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   filds (%edx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fildl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fildll  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fincstp
 # CHECK-NEXT:  -      -     1.00   1.00    -     2.00    -      -     fninit
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fists (%edx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistps  (%edx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     1.00   1.00   fistpll (%eax)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     0.50   0.50   fisttps (%edx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     0.50   0.50   fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -     1.00   1.00    -     0.50   0.50   fisttpll  (%eax)
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fld %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fld %st
 # CHECK-NEXT:  -      -     0.50   0.50    -     1.00   0.50   0.50   flds  (%edx)
 # CHECK-NEXT:  -      -     0.50   0.50    -     1.00   0.50   0.50   fldl  (%ecx)
 # CHECK-NEXT:  -      -     0.50   0.50    -     1.00   0.50   0.50   fldt  (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00   2.00   1.00   1.00   fldcw (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fldenv  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -     1.00    -      -     fld1
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldl2e
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldl2t
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldlg2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldln2
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -      -     fldpi
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fldz
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fmuls (%ecx)
 # CHECK-NEXT:  -      -     1.00    -      -      -     0.50   0.50   fmull (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fimuls  (%ecx)
 # CHECK-NEXT:  -      -     1.00   1.00    -      -     0.50   0.50   fimull  (%eax)
 # CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fnop
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fpatan
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fprem
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fprem1
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fptan
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     frndint
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnsave  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fscale
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fsin
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fsincos
 # CHECK-NEXT:  -     24.00  1.00    -      -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fst %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fst %st
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstl  (%ecx)
-# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fstp  %st(0)
+# CHECK-NEXT:  -      -      -      -      -     1.00    -      -     fstp  %st
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     1.00    -     1.00   1.00   fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -     1.00   1.00   1.00   1.00   fnstcw  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnstenv (%eax)
 # CHECK-NEXT:  -      -     1.00    -     1.00    -     1.00   1.00   fnstsw  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     wait
 # CHECK-NEXT:  -      -     0.33   0.33    -     0.33    -      -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubs (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubl  (%eax)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -     1.00    -      -     0.50   0.50   fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -     2.00    -      -     0.50   0.50   fisubrl (%eax)
 # CHECK-NEXT:  -      -      -     1.00    -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/SkylakeClient/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=skylake -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.25                  U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.25                  U     fbld  (%ecx)
 # CHECK-NEXT:  2      1     1.00                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  4      4     1.00                  U     fnclex
-# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fcompp
 # CHECK-NEXT:  1      2     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  1      2     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.25                  U     fcos
 # CHECK-NEXT:  2      2     1.00                  U     fdecstp
-# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdiv  %st(2)
 # CHECK-NEXT:  2      22    1.00    *             U     fdivs (%ecx)
 # CHECK-NEXT:  2      22    1.00    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(2)
 # CHECK-NEXT:  3      25    1.00    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  3      25    1.00    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      20    1.00                  U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      20    1.00                  U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivr %st(2)
 # CHECK-NEXT:  2      27    1.00    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  2      27    1.00    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(2)
 # CHECK-NEXT:  3      30    1.00    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  3      30    1.00    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      100   0.25                  U     ffree %st(0)
+# CHECK-NEXT:  1      100   0.25                  U     ffree %st
 # CHECK-NEXT:  3      11    2.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  3      11    2.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficompl (%eax)
 # CHECK-NEXT:  2      10    1.00    *             U     filds (%edx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fincstp
 # CHECK-NEXT:  15     75    6.00                  U     fninit
 # CHECK-NEXT:  3      4     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.25                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fld %st
 # CHECK-NEXT:  1      7     0.50    *             U     flds  (%edx)
 # CHECK-NEXT:  1      7     0.50    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      7     0.50    *             U     fldt  (%eax)
 # CHECK-NEXT:  3      7     1.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  64     62    14.00                 U     fldenv  (%eax)
 # CHECK-NEXT:  2      1     1.00                  U     fld1
 # CHECK-NEXT:  2      1     1.00                  U     fldl2e
 # CHECK-NEXT:  2      1     1.00                  U     fldl2t
 # CHECK-NEXT:  2      1     1.00                  U     fldlg2
 # CHECK-NEXT:  2      1     1.00                  U     fldln2
 # CHECK-NEXT:  2      1     1.00                  U     fldpi
 # CHECK-NEXT:  1      1     0.50                  U     fldz
-# CHECK-NEXT:  1      4     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      4     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      4     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  2      11    1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  2      11    1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      4     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      4     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  3      14    1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  3      14    1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      100   0.25                  U     fpatan
 # CHECK-NEXT:  1      100   0.25                  U     fprem
 # CHECK-NEXT:  1      100   0.25                  U     fprem1
 # CHECK-NEXT:  1      100   0.25                  U     fptan
 # CHECK-NEXT:  1      100   0.25                  U     frndint
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fscale
 # CHECK-NEXT:  1      100   0.25                  U     fsin
 # CHECK-NEXT:  1      100   0.25                  U     fsincos
 # CHECK-NEXT:  1      21    7.00                  U     fsqrt
-# CHECK-NEXT:  1      1     0.25                  U     fst %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fst %st
 # CHECK-NEXT:  1      1     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     0.25                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fstp  %st
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  3      2     1.00           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  100    106   19.50                 U     fnstenv (%eax)
 # CHECK-NEXT:  3      3     1.00                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  2      2     0.50                  U     wait
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      2     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]
 # CHECK-NEXT:  -     7.00   126.75 52.25  49.00  49.00  27.00  149.75 69.25  9.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    Instructions:
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     f2xm1
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fabs
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fadds (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     faddl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fiaddl  (%ecx)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fbld  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fbstp (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fchs
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -     1.00   1.00    -     fnclex
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcom  %st(3)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcoms (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcoml (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcomp %st(3)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcomps  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcompl  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fcompp
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fcomi %st(3)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fcos
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fdecstp
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivl (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivl  (%eax)
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrl  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivrs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivrl (%eax)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     ffree %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     ffree %st
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficoms  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficoml  (%eax)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficomps (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficompl (%eax)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     filds (%edx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fildl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fildll  (%eax)
 # CHECK-NEXT:  -      -     0.50    -      -      -      -     0.50    -      -     fincstp
 # CHECK-NEXT:  -      -     3.00   1.50    -      -      -     9.00   1.50    -     fninit
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fists (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistps  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistpll (%eax)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fisttps (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fisttpll  (%eax)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fld %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fld %st
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     flds  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldl  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldt  (%eax)
 # CHECK-NEXT:  -      -     1.50    -     0.50   0.50    -     0.50    -      -     fldcw (%eax)
 # CHECK-NEXT:  -      -     19.25  9.75   4.00   4.00    -     12.25  14.75   -     fldenv  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fld1
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldl2e
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldl2t
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldlg2
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldln2
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldpi
 # CHECK-NEXT:  -      -     0.50    -      -      -      -     0.50    -      -     fldz
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmuls (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmull (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fimuls  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fimull  (%eax)
 # CHECK-NEXT:  -      -     0.50    -      -      -      -     0.50    -      -     fnop
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fpatan
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fprem
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fprem1
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fptan
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frndint
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fnsave  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fscale
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsin
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsincos
 # CHECK-NEXT:  -     7.00   1.00    -      -      -      -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fst %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fst %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstl  (%ecx)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fstp  %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fstp  %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -     1.00   0.33   fnstcw  (%eax)
 # CHECK-NEXT:  -      -     27.00  8.50   3.67   3.67   11.00  23.50  19.00  3.67   fnstenv (%eax)
 # CHECK-NEXT:  -      -     1.00    -     0.33   0.33   1.00    -      -     0.33   fnstsw  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -     0.50   0.50    -     wait
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubs (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubl  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubrl (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/SkylakeServer/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=skylake-avx512 -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.25                  U     f2xm1
 # CHECK-NEXT:  1      1     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.25                  U     fbld  (%ecx)
 # CHECK-NEXT:  2      1     1.00                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  4      4     1.00                  U     fnclex
-# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      3     1.00                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      3     1.00                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  2      8     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  2      8     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fcompp
 # CHECK-NEXT:  1      2     1.00                  U     fcomi %st(3)
 # CHECK-NEXT:  1      2     1.00                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.25                  U     fcos
 # CHECK-NEXT:  2      2     1.00                  U     fdecstp
-# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdiv  %st(2)
 # CHECK-NEXT:  2      22    1.00    *             U     fdivs (%ecx)
 # CHECK-NEXT:  2      22    1.00    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(2)
 # CHECK-NEXT:  3      25    1.00    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  3      25    1.00    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      20    1.00                  U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      20    1.00                  U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivr %st(2)
 # CHECK-NEXT:  2      27    1.00    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  2      27    1.00    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(1)
 # CHECK-NEXT:  1      20    1.00                  U     fdivrp  %st(2)
 # CHECK-NEXT:  3      30    1.00    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  3      30    1.00    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      100   0.25                  U     ffree %st(0)
+# CHECK-NEXT:  1      100   0.25                  U     ffree %st
 # CHECK-NEXT:  3      11    2.00                  U     ficoms  (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficoml  (%eax)
 # CHECK-NEXT:  3      11    2.00                  U     ficomps (%ecx)
 # CHECK-NEXT:  3      11    2.00                  U     ficompl (%eax)
 # CHECK-NEXT:  2      10    1.00    *             U     filds (%edx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fincstp
 # CHECK-NEXT:  15     75    6.00                  U     fninit
 # CHECK-NEXT:  3      4     1.00           *      U     fists (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistps  (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fistpll (%eax)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttps (%edx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  3      4     1.00           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.25                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fld %st
 # CHECK-NEXT:  1      7     0.50    *             U     flds  (%edx)
 # CHECK-NEXT:  1      7     0.50    *             U     fldl  (%ecx)
 # CHECK-NEXT:  1      7     0.50    *             U     fldt  (%eax)
 # CHECK-NEXT:  3      7     1.00    *             U     fldcw (%eax)
 # CHECK-NEXT:  64     62    14.00                 U     fldenv  (%eax)
 # CHECK-NEXT:  2      1     1.00                  U     fld1
 # CHECK-NEXT:  2      1     1.00                  U     fldl2e
 # CHECK-NEXT:  2      1     1.00                  U     fldl2t
 # CHECK-NEXT:  2      1     1.00                  U     fldlg2
 # CHECK-NEXT:  2      1     1.00                  U     fldln2
 # CHECK-NEXT:  2      1     1.00                  U     fldpi
 # CHECK-NEXT:  1      1     0.50                  U     fldz
-# CHECK-NEXT:  1      4     1.00                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      4     1.00                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      4     1.00                  U     fmul  %st(2)
 # CHECK-NEXT:  2      11    1.00    *             U     fmuls (%ecx)
 # CHECK-NEXT:  2      11    1.00    *             U     fmull (%eax)
 # CHECK-NEXT:  1      4     1.00                  U     fmulp %st(1)
 # CHECK-NEXT:  1      4     1.00                  U     fmulp %st(2)
 # CHECK-NEXT:  3      14    1.00    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  3      14    1.00    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     0.50                  U     fnop
 # CHECK-NEXT:  1      100   0.25                  U     fpatan
 # CHECK-NEXT:  1      100   0.25                  U     fprem
 # CHECK-NEXT:  1      100   0.25                  U     fprem1
 # CHECK-NEXT:  1      100   0.25                  U     fptan
 # CHECK-NEXT:  1      100   0.25                  U     frndint
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fscale
 # CHECK-NEXT:  1      100   0.25                  U     fsin
 # CHECK-NEXT:  1      100   0.25                  U     fsincos
 # CHECK-NEXT:  1      21    7.00                  U     fsqrt
-# CHECK-NEXT:  1      1     0.25                  U     fst %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fst %st
 # CHECK-NEXT:  1      1     1.00           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     1.00           *      U     fstl  (%ecx)
-# CHECK-NEXT:  1      1     0.25                  U     fstp  %st(0)
+# CHECK-NEXT:  1      1     0.25                  U     fstp  %st
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%edx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpl (%ecx)
 # CHECK-NEXT:  2      1     1.00           *      U     fstpt (%eax)
 # CHECK-NEXT:  3      2     1.00           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  100    106   19.50                 U     fnstenv (%eax)
 # CHECK-NEXT:  3      3     1.00                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  2      2     0.50                  U     wait
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  2      10    1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  3      13    2.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      2     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]
 # CHECK-NEXT:  -     7.00   126.75 52.25  49.00  49.00  27.00  149.75 69.25  9.00
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    Instructions:
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     f2xm1
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fabs
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fadd  %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fadds (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     faddl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     faddp %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fiadds  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fiaddl  (%ecx)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fbld  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fbstp (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fchs
 # CHECK-NEXT:  -      -     1.00   1.00    -      -      -     1.00   1.00    -     fnclex
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -      -     1.00    -      -      -      -      -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcom  %st(3)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcoms (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcoml (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fcomp %st(3)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcomps  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fcompl  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fcompp
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fcomi %st(3)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fcos
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fdecstp
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdiv  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivl (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivp %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivl  (%eax)
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivr %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrs  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fdivrl  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fdivrp  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivrs (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fidivrl (%eax)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     ffree %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     ffree %st
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficoms  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficoml  (%eax)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficomps (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     ficompl (%eax)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     filds (%edx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fildl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fildll  (%eax)
 # CHECK-NEXT:  -      -     0.50    -      -      -      -     0.50    -      -     fincstp
 # CHECK-NEXT:  -      -     3.00   1.50    -      -      -     9.00   1.50    -     fninit
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fists (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistps  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistpl  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fistpll (%eax)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fisttps (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fisttpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00   1.00    -     0.33   fisttpll  (%eax)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fld %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fld %st
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     flds  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldl  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -      -      -      -     fldt  (%eax)
 # CHECK-NEXT:  -      -     1.50    -     0.50   0.50    -     0.50    -      -     fldcw (%eax)
 # CHECK-NEXT:  -      -     19.25  9.75   4.00   4.00    -     12.25  14.75   -     fldenv  (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fld1
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldl2e
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldl2t
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldlg2
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldln2
 # CHECK-NEXT:  -      -     1.00    -      -      -      -     1.00    -      -     fldpi
 # CHECK-NEXT:  -      -     0.50    -      -      -      -     0.50    -      -     fldz
-# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmul  %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmuls (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -      -      -      -     fmull (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     fmulp %st(2)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fimuls  (%ecx)
 # CHECK-NEXT:  -      -     1.00    -     0.50   0.50    -     1.00    -      -     fimull  (%eax)
 # CHECK-NEXT:  -      -     0.50    -      -      -      -     0.50    -      -     fnop
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fpatan
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fprem
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fprem1
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fptan
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frndint
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fnsave  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fscale
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsin
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fsincos
 # CHECK-NEXT:  -     7.00   1.00    -      -      -      -      -      -      -     fsqrt
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fst %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fst %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fsts  (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstl  (%ecx)
-# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fstp  %st(0)
+# CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fstp  %st
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%edx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpl (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -      -     0.33   fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -     0.33   0.33   1.00    -     1.00   0.33   fnstcw  (%eax)
 # CHECK-NEXT:  -      -     27.00  8.50   3.67   3.67   11.00  23.50  19.00  3.67   fnstenv (%eax)
 # CHECK-NEXT:  -      -     1.00    -     0.33   0.33   1.00    -      -     0.33   fnstsw  (%eax)
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     frstor  (%eax)
 # CHECK-NEXT:  -      -     0.50   0.50    -      -      -     0.50   0.50    -     wait
 # CHECK-NEXT:  -      -     0.25   0.25    -      -      -     0.25   0.25    -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsub  %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubs (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubp %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubl  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubr %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubrs  (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     1.00    -      -     fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -     fsubrp  %st(2)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubrs (%ecx)
 # CHECK-NEXT:  -      -      -      -     0.50   0.50    -     2.00    -      -     fisubrl (%eax)
 # CHECK-NEXT:  -      -     1.00    -      -      -      -      -      -      -     ftst

llvm/trunk/test/tools/llvm-mca/X86/Znver1/resources-x87.s

 # NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
 # RUN: llvm-mca -mtriple=x86_64-unknown-unknown -mcpu=znver1 -instruction-tables < %s | FileCheck %s
 
 f2xm1
 
 fabs
 
-fadd %st(0), %st(1)
+fadd %st, %st(1)
 fadd %st(2)
 fadds (%ecx)
 faddl (%ecx)
 faddp %st(1)
 faddp %st(2)
 fiadds (%ecx)
 fiaddl (%ecx)
 
 fbld (%ecx)
 fbstp (%eax)
 
 fchs
 
 fnclex
 
-fcmovb %st(1), %st(0)
-fcmovbe %st(1), %st(0)
-fcmove %st(1), %st(0)
-fcmovnb %st(1), %st(0)
-fcmovnbe %st(1), %st(0)
-fcmovne %st(1), %st(0)
-fcmovnu %st(1), %st(0)
-fcmovu %st(1), %st(0)
+fcmovb %st(1), %st
+fcmovbe %st(1), %st
+fcmove %st(1), %st
+fcmovnb %st(1), %st
+fcmovnbe %st(1), %st
+fcmovne %st(1), %st
+fcmovnu %st(1), %st
+fcmovu %st(1), %st
 
 fcom %st(1)
 fcom %st(3)
 fcoms (%ecx)
 fcoml (%eax)
 fcomp %st(1)
 fcomp %st(3)
 fcomps (%ecx)
 fcompl (%eax)
 fcompp
 
 fcomi %st(3)
 fcompi %st(3)
 
 fcos
 
 fdecstp
 
-fdiv %st(0), %st(1)
+fdiv %st, %st(1)
 fdiv %st(2)
 fdivs (%ecx)
 fdivl (%eax)
 fdivp %st(1)
 fdivp %st(2)
 fidivs (%ecx)
 fidivl (%eax)
 
-fdivr %st(0), %st(1)
+fdivr %st, %st(1)
 fdivr %st(2)
 fdivrs (%ecx)
 fdivrl (%eax)
 fdivrp %st(1)
 fdivrp %st(2)
 fidivrs (%ecx)
 fidivrl (%eax)
 
-ffree %st(0)
+ffree %st
 
 ficoms (%ecx)
 ficoml (%eax)
 ficomps (%ecx)
 ficompl (%eax)
 
 filds (%edx)
 fildl (%ecx)
 fildll (%eax)
 
 fincstp
 
 fninit
 
 fists (%edx)
 fistl (%ecx)
 fistps (%edx)
 fistpl (%ecx)
 fistpll (%eax)
 
 fisttps (%edx)
 fisttpl (%ecx)
 fisttpll (%eax)
 
-fld %st(0)
+fld %st
 flds (%edx)
 fldl (%ecx)
 fldt (%eax)
 
 fldcw (%eax)
 fldenv (%eax)
 
 fld1
 fldl2e
 fldl2t
 fldlg2
 fldln2
 fldpi
 fldz
 
-fmul %st(0), %st(1)
+fmul %st, %st(1)
 fmul %st(2)
 fmuls (%ecx)
 fmull (%eax)
 fmulp %st(1)
 fmulp %st(2)
 fimuls (%ecx)
 fimull (%eax)
 

 fscale
 
 fsin
 
 fsincos
 
 fsqrt
 
-fst %st(0)
+fst %st
 fsts (%edx)
 fstl (%ecx)
-fstp %st(0)
+fstp %st
 fstpl (%edx)
 fstpl (%ecx)
 fstpt (%eax)
 
 fnstcw (%eax)
 fnstenv (%eax)
 fnstsw (%eax)
 
 frstor (%eax)
 fsave (%eax)
 
-fsub %st(0), %st(1)
+fsub %st, %st(1)
 fsub %st(2)
 fsubs (%ecx)
 fsubl (%eax)
 fsubp %st(1)
 fsubp %st(2)
 fisubs (%ecx)
 fisubl (%eax)
 
-fsubr %st(0), %st(1)
+fsubr %st, %st(1)
 fsubr %st(2)
 fsubrs (%ecx)
 fsubrl (%eax)
 fsubrp %st(1)
 fsubrp %st(2)
 fisubrs (%ecx)
 fisubrl (%eax)
 

 # CHECK-NEXT: [3]: RThroughput
 # CHECK-NEXT: [4]: MayLoad
 # CHECK-NEXT: [5]: MayStore
 # CHECK-NEXT: [6]: HasSideEffects (U)
 
 # CHECK:      [1]    [2]    [3]    [4]    [5]    [6]    Instructions:
 # CHECK-NEXT:  1      100   0.25                  U     f2xm1
 # CHECK-NEXT:  1      2     1.00                  U     fabs
-# CHECK-NEXT:  1      3     1.00                  U     fadd  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fadd  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fadd  %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fadds (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     faddl (%ecx)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     faddp %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fiadds  (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fiaddl  (%ecx)
 # CHECK-NEXT:  1      100   0.25                  U     fbld  (%ecx)
 # CHECK-NEXT:  1      100   0.25                  U     fbstp (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fchs
 # CHECK-NEXT:  1      100   0.25                  U     fnclex
-# CHECK-NEXT:  1      100   0.25                  U     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  1      100   0.25                  U     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  1      100   0.25                  U     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  1      100   0.25                  U     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  1      100   0.25                  U     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  1      100   0.25                  U     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  1      100   0.25                  U     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  1      100   0.25                  U     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  1      100   0.25                  U     fcmovb  %st(1), %st
+# CHECK-NEXT:  1      100   0.25                  U     fcmovbe %st(1), %st
+# CHECK-NEXT:  1      100   0.25                  U     fcmove  %st(1), %st
+# CHECK-NEXT:  1      100   0.25                  U     fcmovnb %st(1), %st
+# CHECK-NEXT:  1      100   0.25                  U     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  1      100   0.25                  U     fcmovne %st(1), %st
+# CHECK-NEXT:  1      100   0.25                  U     fcmovnu %st(1), %st
+# CHECK-NEXT:  1      100   0.25                  U     fcmovu  %st(1), %st
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcom  %st(3)
 # CHECK-NEXT:  1      8     1.00                  U     fcoms (%ecx)
 # CHECK-NEXT:  1      8     1.00                  U     fcoml (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(1)
 # CHECK-NEXT:  1      1     1.00                  U     fcomp %st(3)
 # CHECK-NEXT:  1      8     1.00                  U     fcomps  (%ecx)
 # CHECK-NEXT:  1      8     1.00                  U     fcompl  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fcompp
 # CHECK-NEXT:  1      9     0.50                  U     fcomi %st(3)
 # CHECK-NEXT:  1      9     0.50                  U     fcompi  %st(3)
 # CHECK-NEXT:  1      100   0.25                  U     fcos
 # CHECK-NEXT:  1      11    1.00                  U     fdecstp
-# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  1      15    1.00                  U     fdiv  %st, %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdiv  %st(2)
 # CHECK-NEXT:  1      22    1.00    *             U     fdivs (%ecx)
 # CHECK-NEXT:  1      22    1.00    *             U     fdivl (%eax)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivp %st(2)
 # CHECK-NEXT:  1      22    1.00    *             U     fidivs  (%ecx)
 # CHECK-NEXT:  1      22    1.00    *             U     fidivl  (%eax)
-# CHECK-NEXT:  1      15    1.00                  U     fdivr %st(0), %st(1)
+# CHECK-NEXT:  1      15    1.00                  U     fdivr %st, %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivr %st(2)
 # CHECK-NEXT:  1      22    1.00    *             U     fdivrs  (%ecx)
 # CHECK-NEXT:  1      22    1.00    *             U     fdivrl  (%eax)
 # CHECK-NEXT:  1      15    1.00                  U     fdivrp  %st(1)
 # CHECK-NEXT:  1      15    1.00                  U     fdivrp  %st(2)
 # CHECK-NEXT:  1      22    1.00    *             U     fidivrs (%ecx)
 # CHECK-NEXT:  1      22    1.00    *             U     fidivrl (%eax)
-# CHECK-NEXT:  1      11    1.00                  U     ffree %st(0)
+# CHECK-NEXT:  1      11    1.00                  U     ffree %st
 # CHECK-NEXT:  2      12    1.50                  U     ficoms  (%ecx)
 # CHECK-NEXT:  2      12    1.50                  U     ficoml  (%eax)
 # CHECK-NEXT:  2      12    1.50                  U     ficomps (%ecx)
 # CHECK-NEXT:  2      12    1.50                  U     ficompl (%eax)
 # CHECK-NEXT:  2      11    1.00    *             U     filds (%edx)
 # CHECK-NEXT:  2      11    1.00    *             U     fildl (%ecx)
 # CHECK-NEXT:  2      11    1.00    *             U     fildll  (%eax)
 # CHECK-NEXT:  1      11    1.00                  U     fincstp
 # CHECK-NEXT:  1      100   0.25                  U     fninit
 # CHECK-NEXT:  1      12    0.50           *      U     fists (%edx)
 # CHECK-NEXT:  1      12    0.50           *      U     fistl (%ecx)
 # CHECK-NEXT:  1      12    0.50           *      U     fistps  (%edx)
 # CHECK-NEXT:  1      12    0.50           *      U     fistpl  (%ecx)
 # CHECK-NEXT:  1      12    0.50           *      U     fistpll (%eax)
 # CHECK-NEXT:  1      12    0.50           *      U     fisttps (%edx)
 # CHECK-NEXT:  1      12    0.50           *      U     fisttpl (%ecx)
 # CHECK-NEXT:  1      12    0.50           *      U     fisttpll  (%eax)
-# CHECK-NEXT:  1      1     0.50                  U     fld %st(0)
+# CHECK-NEXT:  1      1     0.50                  U     fld %st
 # CHECK-NEXT:  1      8     0.50    *             U     flds  (%edx)
 # CHECK-NEXT:  1      8     0.50    *             U     fldl  (%ecx)
 # CHECK-NEXT:  2      1     0.50    *             U     fldt  (%eax)
 # CHECK-NEXT:  1      100   0.25    *             U     fldcw (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fldenv  (%eax)
 # CHECK-NEXT:  1      11    1.00                  U     fld1
 # CHECK-NEXT:  1      11    1.00                  U     fldl2e
 # CHECK-NEXT:  1      11    1.00                  U     fldl2t
 # CHECK-NEXT:  1      11    1.00                  U     fldlg2
 # CHECK-NEXT:  1      11    1.00                  U     fldln2
 # CHECK-NEXT:  1      11    1.00                  U     fldpi
 # CHECK-NEXT:  1      8     0.50                  U     fldz
-# CHECK-NEXT:  1      3     0.50                  U     fmul  %st(0), %st(1)
+# CHECK-NEXT:  1      3     0.50                  U     fmul  %st, %st(1)
 # CHECK-NEXT:  1      3     0.50                  U     fmul  %st(2)
 # CHECK-NEXT:  2      10    0.50    *             U     fmuls (%ecx)
 # CHECK-NEXT:  2      10    0.50    *             U     fmull (%eax)
 # CHECK-NEXT:  1      3     0.50                  U     fmulp %st(1)
 # CHECK-NEXT:  1      3     0.50                  U     fmulp %st(2)
 # CHECK-NEXT:  2      10    0.50    *             U     fimuls  (%ecx)
 # CHECK-NEXT:  2      10    0.50    *             U     fimull  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     fnop
 # CHECK-NEXT:  1      100   0.25                  U     fpatan
 # CHECK-NEXT:  1      100   0.25                  U     fprem
 # CHECK-NEXT:  1      100   0.25                  U     fprem1
 # CHECK-NEXT:  1      100   0.25                  U     fptan
 # CHECK-NEXT:  1      100   0.25                  U     frndint
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fscale
 # CHECK-NEXT:  1      100   0.25                  U     fsin
 # CHECK-NEXT:  1      100   0.25                  U     fsincos
 # CHECK-NEXT:  1      20    20.00                 U     fsqrt
-# CHECK-NEXT:  2      5     0.50                  U     fst %st(0)
+# CHECK-NEXT:  2      5     0.50                  U     fst %st
 # CHECK-NEXT:  1      1     0.50           *      U     fsts  (%edx)
 # CHECK-NEXT:  1      1     0.50           *      U     fstl  (%ecx)
-# CHECK-NEXT:  2      5     0.50                  U     fstp  %st(0)
+# CHECK-NEXT:  2      5     0.50                  U     fstp  %st
 # CHECK-NEXT:  1      1     0.50           *      U     fstpl (%edx)
 # CHECK-NEXT:  1      1     0.50           *      U     fstpl (%ecx)
 # CHECK-NEXT:  1      5     0.50           *      U     fstpt (%eax)
 # CHECK-NEXT:  1      100   0.25           *      U     fnstcw  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fnstenv (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     fnstsw  (%eax)
 # CHECK-NEXT:  1      100   0.25                  U     frstor  (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     wait
 # CHECK-NEXT:  1      100   0.25                  U     fnsave  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsub  %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsub  %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsub  %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubs (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubl (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubp %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubs  (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubl  (%eax)
-# CHECK-NEXT:  1      3     1.00                  U     fsubr %st(0), %st(1)
+# CHECK-NEXT:  1      3     1.00                  U     fsubr %st, %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubr %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubrs  (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fsubrl  (%eax)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(1)
 # CHECK-NEXT:  1      3     1.00                  U     fsubrp  %st(2)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubrs (%ecx)
 # CHECK-NEXT:  1      10    1.00    *             U     fisubrl (%eax)
 # CHECK-NEXT:  1      1     1.00                  U     ftst

 # CHECK:      Resource pressure per iteration:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   [11]
 # CHECK-NEXT: 32.50  32.50   -      -      -      -      -     54.50  6.00   8.00   64.50   -
 
 # CHECK:      Resource pressure by instruction:
 # CHECK-NEXT: [0]    [1]    [2]    [3]    [4]    [5]    [6]    [7]    [8]    [9]    [10]   [11]   Instructions:
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     f2xm1
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fabs
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fadd  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fadd  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fadd  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fadds (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     faddl (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     faddp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     faddp %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fiadds  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fiaddl  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fbld  (%ecx)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fbstp (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fchs
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fnclex
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovb  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovbe %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmove  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovnb %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovnbe  %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovne %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovnu %st(1), %st(0)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovu  %st(1), %st(0)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovb  %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovbe %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmove  %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovnb %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovnbe  %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovne %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovnu %st(1), %st
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcmovu  %st(1), %st
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fcom  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fcom  %st(3)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fcoms (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fcoml (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fcomp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fcomp %st(3)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fcomps  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fcompl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fcompp
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     0.50    -     0.50    -      -     fcomi %st(3)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     0.50    -     0.50    -      -     fcompi  %st(3)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fcos
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fdecstp
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdiv  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdiv  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdiv  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fdivs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fdivl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdivp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdivp %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fidivs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fidivl  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdivr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdivr %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdivr %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fdivrs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fdivrl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdivrp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     1.00    -     fdivrp  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fidivrs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fidivrl (%eax)
-# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     ffree %st(0)
+# CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     ffree %st
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.50    -      -     1.50    -     ficoms  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.50    -      -     1.50    -     ficoml  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.50    -      -     1.50    -     ficomps (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.50    -      -     1.50    -     ficompl (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     filds (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fildl (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fildll  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fincstp
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fninit
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fists (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fistl (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fistps  (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fistpl  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fistpll (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fisttps (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fisttpl (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fisttpll  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50    -     0.50    -     fld %st(0)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -     0.50    -     0.50    -     fld %st
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -     flds  (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -     fldl  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50    -     0.50    -     fldt  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fldcw (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fldenv  (%eax)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fld1
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fldl2e
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fldl2t
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fldlg2
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fldln2
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -     1.00    -     fldpi
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -     0.50    -     0.50    -     fldz
-# CHECK-NEXT:  -      -      -      -      -      -      -     0.50   0.50    -      -      -     fmul  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     0.50   0.50    -      -      -     fmul  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     0.50   0.50    -      -      -     fmul  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     0.50   0.50    -      -      -     fmuls (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     0.50   0.50    -      -      -     fmull (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     0.50   0.50    -      -      -     fmulp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     0.50   0.50    -      -      -     fmulp %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     0.50   0.50    -      -      -     fimuls  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     0.50   0.50    -      -      -     fimull  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fnop
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fpatan
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fprem
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fprem1
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fptan
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     frndint
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fnsave  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fscale
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fsin
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fsincos
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -     20.00   -     fsqrt
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -     0.50   0.50    -     fst %st(0)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -     0.50   0.50    -     fst %st
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -     fsts  (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -     fstl  (%ecx)
-# CHECK-NEXT:  -      -      -      -      -      -      -      -      -     0.50   0.50    -     fstp  %st(0)
+# CHECK-NEXT:  -      -      -      -      -      -      -      -      -     0.50   0.50    -     fstp  %st
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -     fstpl (%edx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -      -      -      -     fstpl (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -      -      -     0.50   0.50    -     fstpt (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fnstcw  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fnstenv (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fnstsw  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     frstor  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     wait
 # CHECK-NEXT:  -      -      -      -      -      -      -      -      -      -      -      -     fnsave  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsub  %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsub  %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsub  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fsubs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fsubl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsubp %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsubp %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fisubs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fisubl  (%eax)
-# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsubr %st(0), %st(1)
+# CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsubr %st, %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsubr %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fsubrs  (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fsubrl  (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsubrp  %st(1)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     fsubrp  %st(2)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fisubrs (%ecx)
 # CHECK-NEXT: 0.50   0.50    -      -      -      -      -     1.00    -      -      -      -     fisubrl (%eax)
 # CHECK-NEXT:  -      -      -      -      -      -      -     1.00    -      -      -      -     ftst