[X86][ABI] Don't preserve return regs for preserve_all/preserve_most CCs

[AntonBikineev]

Summary

Currently both calling conventions preserve registers that are used to store
a return value. This causes the returned value to be lost:

define i32 @bar() {
  %1 = call preserve_mostcc i32 @foo()
   ret i32 %1
}

define preserve_mostcc i32 @foo() {
  ret i32 2
  ; preserve_mostcc will restore %rax, whatever it was before the call.
}

This contradicts the current documentation (preserve_allcc "behaves
identical to the C calling conventions on how arguments and return
values are passed") and also breaks [[clang::preserve_most]].

This change makes CSRs be preserved iff they are not used to store a
return value (e.g. %rax for scalars, {%rax:%rdx} for __int128, %xmm0
for double). For void functions no additional registers are
preserved, i.e. the behaviour is backward compatible with existing
code.

Juergen, can you please take a look, since you added the CCs originally?
Phoebe, I added you as a reviewer as well, since you touched the X86 CC code recently :)

Thanks!

[AntonBikineev]

Roman, could you please take a look at it (or suggest a reviewer)?

(The context: we want to use the attribute for cold calls in Chromium/V8. Early experiments are quite promising (e.g. showed to improve the hot path by up to 2x)).

[pengfei]

I took a look but fogot to comment. TBH, I know little about preserve_mostcc. I checked the existing test cases all of which declare void return with it. So is it not legal to return value with the CC? If we do not preserve rax, we probably have compatibility issue with pre-built code since it assumes rax is saved by callee.

[AntonBikineev]

So is it not legal to return value with the CC?

According to the documentation, it is legal. In the current implementation it isn't though.

If we do not preserve rax, we probably have compatibility issue with pre-built code since it assumes rax is saved by callee.

That's true - the change may break the existing precompiled code.

As I see it, we should either

• have consistency between the implementation and the docs and early diagnose attribute application on non-void functions, or
• allow %rax to be clobbered by the callee.

[lebedev.ri]

This seems to be missing the code change itself.

[AntonBikineev]

In D141020#4037505, @lebedev.ri wrote:

This seems to be missing the code change itself.

(the code change is essentially in X86CallingConv.td)

[efriedma]

Having a register be both preserved and used to store a return value is obviously a contradiction. However, it's consistent to say that a register is preserved if and only if it is not used to return a value. (Not sure off the top of my head what changes are required to make that work correctly.)

The C calling convention uses RAX/RDX/XMM0/XMM1 to return values, and LLVM additionally allows using RCX/XMM2/XMM3 for certain IR signatures. So I don't think just removing RAX from the list does the right thing.

[pengfei]

In D141020#4038220, @efriedma wrote:

Having a register be both preserved and used to store a return value is obviously a contradiction. However, it's consistent to say that a register is preserved if and only if it is not used to return a value. (Not sure off the top of my head what changes are required to make that work correctly.)

The C calling convention uses RAX/RDX/XMM0/XMM1 to return values, and LLVM additionally allows using RCX/XMM2/XMM3 for certain IR signatures. So I don't think just removing RAX from the list does the right thing.

Agreed! FPRs is not a problem as the doc says they are not preserved. But we do use RDX sometime, e.g.: https://godbolt.org/z/sWKKbjMvz
So yes, we may need a method to override the preserve list when RAX/RDX are used as return registers. Not sure if the current framework support or not.

[efriedma]

FPRs is not a problem as the doc says they are not preserved

MostRegs doesn't, but AllRegs does?

Not sure if the current framework support or not.

X86RegisterInfo::getCalleeSavedRegs has enough information to figure out the correct set of registers; not sure if there's any convenient way to compute it, though. Not sure X86RegisterInfo::getCallPreservedMask has enough information to tell; it looks like the actual signature isn't passed. The callers should have that information available, though.

[ributzka]

If this can be fixed without affecting any potential clients, then I am all for it. In hindsight it might have been better to make a use case specific calling convention instead and not a generic one that everyone could depend on. Oen possible solution would be to make a Chromium specific calling convention and also name it as such. This would provide clear expectations what it is intended for and how is supposed to use it. Furthermore this would give you the option of changing it in the future if the need should arise.

[AntonBikineev]

Thanks everybody for the feedback! Sorry for the delayed response - I was occupied with the regular work.

However, it's consistent to say that a register is preserved if and only if it is not used to return a value.

I thought about it first, but just found cloberring %rax as a quick fix. But I 100% agree - having a flexible CC would be the best solution:

• would allow callers to use more registers when callees are void,
• would stay backward compatible, assuming the clients are not using the CCs with the return value (as otherwise their code would be broken).

MostRegs doesn't, but AllRegs does?

Yeah, all return registers must be addressed..

Oen possible solution would be to make a Chromium specific calling convention and also name it as such.

I thought about this as well, but preserve_most is conceptually already what we need. It would be better to save a chromium-specific CC for a future use case :)

There is already logic that nicely allows to disable CSRs dynamically, which was introduced for the Intel's regcall CC (here https://reviews.llvm.org/D28566). So I'll just piggyback on it.

[AntonBikineev]

Ptal. Now the change preserves all the declared callee-saved-regs as long as they are not used to return a value. The change should be backward compatible, assuming the user code was correct.

[pengfei]

Looks great!

llvm/test/CodeGen/X86/preserve_allcc64.ll

9

I think it's better to put these 2 tests into a seperate file. It just waste time to run multi times on the other 2 tests.

11–23

This will brings difficulties in future updates, though I think it's rare this file will be affected.

[AntonBikineev]

llvm/test/CodeGen/X86/preserve_allcc64.ll

9

Sure (moved tests returning double into separate files)

11–23

What exactly could break? The order of CSRs?

[AntonBikineev]

Moved unparametrized tests (i.e. ones returning doubles) into separate files.

[AntonBikineev]

(friendly ping...)

We've already started using the CC on void-functions in Chromium/V8, which helped us to improve the runtime (as well as the binary size). Looking forward to apply it more broadly.

[AntonBikineev]

(friendly ping)

[pengfei]

LGTM.

[AntonBikineev]

Thanks, everybody!

[hans]

We bisected Chromium crashes to this revision, see https://crbug.com/1410225#c4 for how to reproduce.

I'll revert this for now.

[hans]

@tstellar We may want to consider the revert for the 16 branch.

llvm/docs/LangRef.rst

     apply for values returned in callee-saved registers.
 
     - On X86-64 the callee preserves all general purpose registers, except for
-      R11. R11 can be used as a scratch register. Floating-point registers
-      (XMMs/YMMs) are not preserved and need to be saved by the caller.
+      R11 and RAX. R11 can be used as a scratch register, whereas RAX is used as
+      a return register. Floating-point registers (XMMs/YMMs) are not preserved
+      and need to be saved by the caller.
 
     The idea behind this convention is to support calls to runtime functions
     that have a hot path and a cold path. The hot path is usually a small piece

llvm/lib/Target/X86/X86CallingConv.td

 // CSRs that are handled explicitly via copies.
 def CSR_64_CXX_TLS_Darwin_ViaCopy : CalleeSavedRegs<(sub CSR_64_TLS_Darwin, RBP)>;
 
-// All GPRs - except r11
-def CSR_64_RT_MostRegs : CalleeSavedRegs<(add CSR_64, RAX, RCX, RDX, RSI, RDI,
-                                              R8, R9, R10)>;
+// All GPRs - except r11 and rax
+def CSR_64_RT_MostRegs : CalleeSavedRegs<(add CSR_64, RCX, RDX, RSI, RDI, R8,
+                                              R9, R10)>;
 
-// All registers - except r11
+// All registers - except r11 and rax
 def CSR_64_RT_AllRegs     : CalleeSavedRegs<(add CSR_64_RT_MostRegs,
                                                  (sequence "XMM%u", 0, 15))>;
 def CSR_64_RT_AllRegs_AVX : CalleeSavedRegs<(add CSR_64_RT_MostRegs,

llvm/test/CodeGen/X86/ipra-reg-usage.ll

 target triple = "x86_64-unknown-unknown"
 declare void @bar1()
 define preserve_allcc void @foo()#0 {
-; CHECK: foo Clobbered Registers: $cs $df $ds $eflags $eip $eiz $es $esp $fpcw $fpsw $fs $gs $hip $hsp $ip $mxcsr $rip $riz $rsp $sp $sph $spl $ss $ssp $tmmcfg $cr0 $cr1 $cr2 $cr3 $cr4 $cr5 $cr6 $cr7 $cr8 $cr9 $cr10 $cr11 $cr12 $cr13 $cr14 $cr15 $dr0 $dr1 $dr2 $dr3 $dr4 $dr5 $dr6 $dr7 $dr8 $dr9 $dr10 $dr11 $dr12 $dr13 $dr14 $dr15 $fp0 $fp1 $fp2 $fp3 $fp4 $fp5 $fp6 $fp7 $k0 $k1 $k2 $k3 $k4 $k5 $k6 $k7 $mm0 $mm1 $mm2 $mm3 $mm4 $mm5 $mm6 $mm7 $r11 $st0 $st1 $st2 $st3 $st4 $st5 $st6 $st7 $tmm0 $tmm1 $tmm2 $tmm3 $tmm4 $tmm5 $tmm6 $tmm7 $xmm16 $xmm17 $xmm18 $xmm19 $xmm20 $xmm21 $xmm22 $xmm23 $xmm24 $xmm25 $xmm26 $xmm27 $xmm28 $xmm29 $xmm30 $xmm31 $ymm0 $ymm1 $ymm2 $ymm3 $ymm4 $ymm5 $ymm6 $ymm7 $ymm8 $ymm9 $ymm10 $ymm11 $ymm12 $ymm13 $ymm14 $ymm15 $ymm16 $ymm17 $ymm18 $ymm19 $ymm20 $ymm21 $ymm22 $ymm23 $ymm24 $ymm25 $ymm26 $ymm27 $ymm28 $ymm29 $ymm30 $ymm31 $zmm0 $zmm1 $zmm2 $zmm3 $zmm4 $zmm5 $zmm6 $zmm7 $zmm8 $zmm9 $zmm10 $zmm11 $zmm12 $zmm13 $zmm14 $zmm15 $zmm16 $zmm17 $zmm18 $zmm19 $zmm20 $zmm21 $zmm22 $zmm23 $zmm24 $zmm25 $zmm26 $zmm27 $zmm28 $zmm29 $zmm30 $zmm31 $r11b $r11bh $r11d $r11w $r11wh $k0_k1 $k2_k3 $k4_k5 $k6_k7
+; CHECK: foo Clobbered Registers: $ah $al $ax $cs $df $ds $eax $eflags $eip $eiz $es $esp $fpcw $fpsw $fs $gs $hax $hip $hsp $ip $mxcsr $rax $rip $riz $rsp $sp $sph $spl $ss $ssp $tmmcfg $cr0 $cr1 $cr2 $cr3 $cr4 $cr5 $cr6 $cr7 $cr8 $cr9 $cr10 $cr11 $cr12 $cr13 $cr14 $cr15 $dr0 $dr1 $dr2 $dr3 $dr4 $dr5 $dr6 $dr7 $dr8 $dr9 $dr10 $dr11 $dr12 $dr13 $dr14 $dr15 $fp0 $fp1 $fp2 $fp3 $fp4 $fp5 $fp6 $fp7 $k0 $k1 $k2 $k3 $k4 $k5 $k6 $k7 $mm0 $mm1 $mm2 $mm3 $mm4 $mm5 $mm6 $mm7 $r11 $st0 $st1 $st2 $st3 $st4 $st5 $st6 $st7 $tmm0 $tmm1 $tmm2 $tmm3 $tmm4 $tmm5 $tmm6 $tmm7 $xmm16 $xmm17 $xmm18 $xmm19 $xmm20 $xmm21 $xmm22 $xmm23 $xmm24 $xmm25 $xmm26 $xmm27 $xmm28 $xmm29 $xmm30 $xmm31 $ymm0 $ymm1 $ymm2 $ymm3 $ymm4 $ymm5 $ymm6 $ymm7 $ymm8 $ymm9 $ymm10 $ymm11 $ymm12 $ymm13 $ymm14 $ymm15 $ymm16 $ymm17 $ymm18 $ymm19 $ymm20 $ymm21 $ymm22 $ymm23 $ymm24 $ymm25 $ymm26 $ymm27 $ymm28 $ymm29 $ymm30 $ymm31 $zmm0 $zmm1 $zmm2 $zmm3 $zmm4 $zmm5 $zmm6 $zmm7 $zmm8 $zmm9 $zmm10 $zmm11 $zmm12 $zmm13 $zmm14 $zmm15 $zmm16 $zmm17 $zmm18 $zmm19 $zmm20 $zmm21 $zmm22 $zmm23 $zmm24 $zmm25 $zmm26 $zmm27 $zmm28 $zmm29 $zmm30 $zmm31 $r11b $r11bh $r11d $r11w $r11wh $k0_k1 $k2_k3 $k4_k5 $k6_k7
   call void @bar1()
   call void @bar2()
   ret void

llvm/test/CodeGen/X86/machine-copy-prop.mir

     NOOP implicit $rax, implicit $rdi
 ...
 ---
-# The second copy is redundant; the call preserves the source and dest register.
+# The first copy is redundant, since the call will clobber the dest register.
 # CHECK-LABEL: name: copyprop0
 # CHECK: bb.0:
-# CHECK-NEXT: $rax = COPY $rdi
 # CHECK-NEXT: CALL64pcrel32 @foo, csr_64_rt_mostregs
-# CHECK-NEXT: NOOP implicit $edi
+# CHECK-NEXT: NOOP implicit killed $edi
+# CHECK-NEXT: $rdi = COPY $rax
 # CHECK-NOT: COPY
 # CHECK-NEXT: NOOP implicit $rax, implicit $rdi
 name: copyprop0

 ---
 # CHECK-LABEL: name: copyprop2
 # CHECK: bb.0:
-# CHECK-NEXT: $rax = COPY $rdi
-# CHECK-NEXT: NOOP implicit $ax
+# CHECK-NEXT: $rcx = COPY $rdi
+# CHECK-NEXT: NOOP implicit $cx
 # CHECK-NEXT: CALL64pcrel32 @foo, csr_64_rt_mostregs
-# CHECK-NOT: $rax = COPY $rdi
-# CHECK-NEXT: NOOP implicit $rax, implicit $rdi
+# CHECK-NOT: $rcx = COPY $rdi
+# CHECK-NEXT: NOOP implicit $rcx, implicit $rdi
 name: copyprop2
 body: |
   bb.0:
-    $rax = COPY $rdi
-    NOOP implicit killed $ax
+    $rcx = COPY $rdi
+    NOOP implicit killed $cx
     CALL64pcrel32 @foo, csr_64_rt_mostregs
-    $rax = COPY $rdi
-    NOOP implicit $rax, implicit $rdi
+    $rcx = COPY $rdi
+    NOOP implicit $rcx, implicit $rdi
 ...
 ---
 # The second copy is not redundant if the source register ($rax) is clobbered

llvm/test/CodeGen/X86/preserve_allcc64.ll

 ;SSE-NEXT:  pushq %rsi
 ;SSE-NEXT:  pushq %rdx
 ;SSE-NEXT:  pushq %rcx
-;SSE-NEXT:  pushq %rax
 ;SSE-NEXT:  pushq %rbp
 ;SSE-NEXT:  pushq %r15
 ;SSE-NEXT:  pushq %r14

 ;SSE-NEXT:  movaps %xmm2
 ;SSE-NEXT:  movaps %xmm1
 ;SSE-NEXT:  movaps %xmm0
+;SSE:       movaps {{.*}} %xmm0
+;SSE-NEXT:  movaps {{.*}} %xmm1
+;SSE-NEXT:  movaps {{.*}} %xmm2
+;SSE-NEXT:  movaps {{.*}} %xmm3
+;SSE-NEXT:  movaps {{.*}} %xmm4
+;SSE-NEXT:  movaps {{.*}} %xmm5
+;SSE-NEXT:  movaps {{.*}} %xmm6
+;SSE-NEXT:  movaps {{.*}} %xmm7
+;SSE-NEXT:  movaps {{.*}} %xmm8
+;SSE-NEXT:  movaps {{.*}} %xmm9
+;SSE-NEXT:  movaps {{.*}} %xmm10
+;SSE-NEXT:  movaps {{.*}} %xmm11
+;SSE-NEXT:  movaps {{.*}} %xmm12
+;SSE-NEXT:  movaps {{.*}} %xmm13
+;SSE-NEXT:  movaps {{.*}} %xmm14
+;SSE-NEXT:  movaps {{.*}} %xmm15
+;SSE:       popq    %rbx
+;SSE-NEXT:  popq    %r12
+;SSE-NEXT:  popq    %r13
+;SSE-NEXT:  popq    %r14
+;SSE-NEXT:  popq    %r15
+;SSE-NEXT:  popq    %rbp
+;SSE-NEXT:  popq    %rcx
+;SSE-NEXT:  popq    %rdx
+;SSE-NEXT:  popq    %rsi
+;SSE-NEXT:  popq    %rdi
+;SSE-NEXT:  popq    %r8
+;SSE-NEXT:  popq    %r9
+;SSE-NEXT:  popq    %r10
+
 ;AVX-LABEL: preserve_allcc1
 ;AVX:       pushq %r10
 ;AVX-NEXT:  pushq %r9

 ;AVX-NEXT:  pushq %rsi
 ;AVX-NEXT:  pushq %rdx
 ;AVX-NEXT:  pushq %rcx
-;AVX-NEXT:  pushq %rax
 ;AVX-NEXT:  pushq %rbp
 ;AVX-NEXT:  pushq %r15
 ;AVX-NEXT:  pushq %r14

 ;AVX-NEXT:  vmovups %ymm2
 ;AVX-NEXT:  vmovups %ymm1
 ;AVX-NEXT:  vmovups %ymm0
+;AVX:       vmovups {{.*}} %ymm0
+;AVX-NEXT:  vmovups {{.*}} %ymm1
+;AVX-NEXT:  vmovups {{.*}} %ymm2
+;AVX-NEXT:  vmovups {{.*}} %ymm3
+;AVX-NEXT:  vmovups {{.*}} %ymm4
+;AVX-NEXT:  vmovups {{.*}} %ymm5
+;AVX-NEXT:  vmovups {{.*}} %ymm6
+;AVX-NEXT:  vmovups {{.*}} %ymm7
+;AVX-NEXT:  vmovups {{.*}} %ymm8
+;AVX-NEXT:  vmovups {{.*}} %ymm9
+;AVX-NEXT:  vmovups {{.*}} %ymm10
+;AVX-NEXT:  vmovups {{.*}} %ymm11
+;AVX-NEXT:  vmovups {{.*}} %ymm12
+;AVX-NEXT:  vmovups {{.*}} %ymm13
+;AVX-NEXT:  vmovups {{.*}} %ymm14
+;AVX-NEXT:  vmovups {{.*}} %ymm15
+;AVX:       popq    %rbx
+;AVX-NEXT:  popq    %r12
+;AVX-NEXT:  popq    %r13
+;AVX-NEXT:  popq    %r14
+;AVX-NEXT:  popq    %r15
+;AVX-NEXT:  popq    %rbp
+;AVX-NEXT:  popq    %rcx
+;AVX-NEXT:  popq    %rdx
+;AVX-NEXT:  popq    %rsi
+;AVX-NEXT:  popq    %rdi
+;AVX-NEXT:  popq    %r8
+;AVX-NEXT:  popq    %r9
+;AVX-NEXT:  popq    %r10
   call void asm sideeffect "", "~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{rbp},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15}"()
   ret void
 }
 
-; Make sure only R11 is saved before the call
+; Make sure RAX and R11 are saved before the call
 declare preserve_allcc void @bar(i64, i64, double, double)
 define void @preserve_allcc2() nounwind {
 entry:
 ;SSE-LABEL: preserve_allcc2
-;SSE:       movq %r11, [[REG:%[a-z0-9]+]]
+;SSE:       movq %rax, [[REG1:%[a-z0-9]+]]
+;SSE:       movq %r11, [[REG2:%[a-z0-9]+]]
 ;SSE-NOT:   movaps %xmm
-;SSE:       movq [[REG]], %r11
+;SSE:       movq [[REG1]], %rax
+;SSE:       movq [[REG2]], %r11
   %a0 = call i64 asm sideeffect "", "={rax}"() nounwind
   %a1 = call i64 asm sideeffect "", "={rcx}"() nounwind
   %a2 = call i64 asm sideeffect "", "={rdx}"() nounwind

llvm/test/CodeGen/X86/preserve_mostcc64.ll

 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7     | FileCheck --check-prefix=SSE %s
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=corei7-avx | FileCheck --check-prefix=AVX %s
 
-; Every GPR should be saved - except r11
+; Every GPR should be saved - except r11 and rax
 define preserve_mostcc void @preserve_mostcc1() nounwind {
 entry:
 ;SSE-LABEL: preserve_mostcc1

 ;SSE-NEXT:  pushq %rsi
 ;SSE-NEXT:  pushq %rdx
 ;SSE-NEXT:  pushq %rcx
-;SSE-NEXT:  pushq %rax
 ;SSE-NEXT:  pushq %rbp
 ;SSE-NEXT:  pushq %r15
 ;SSE-NEXT:  pushq %r14
 ;SSE-NEXT:  pushq %r13
 ;SSE-NEXT:  pushq %r12
 ;SSE-NEXT:  pushq %rbx
+;SSE:       popq    %rbx
+;SSE-NEXT:  popq    %r12
+;SSE-NEXT:  popq    %r13
+;SSE-NEXT:  popq    %r14
+;SSE-NEXT:  popq    %r15
+;SSE-NEXT:  popq    %rbp
+;SSE-NEXT:  popq    %rcx
+;SSE-NEXT:  popq    %rdx
+;SSE-NEXT:  popq    %rsi
+;SSE-NEXT:  popq    %rdi
+;SSE-NEXT:  popq    %r8
+;SSE-NEXT:  popq    %r9
+;SSE-NEXT:  popq    %r10
 ;AVX-LABEL: preserve_mostcc1
 ;AVX:       pushq %r10
 ;AVX-NEXT:  pushq %r9

 ;AVX-NEXT:  pushq %rsi
 ;AVX-NEXT:  pushq %rdx
 ;AVX-NEXT:  pushq %rcx
-;AVX-NEXT:  pushq %rax
 ;AVX-NEXT:  pushq %rbp
 ;AVX-NEXT:  pushq %r15
 ;AVX-NEXT:  pushq %r14
 ;AVX-NEXT:  pushq %r13
 ;AVX-NEXT:  pushq %r12
 ;AVX-NEXT:  pushq %rbx
+;AVX:       popq    %rbx
+;AVX-NEXT:  popq    %r12
+;AVX-NEXT:  popq    %r13
+;AVX-NEXT:  popq    %r14
+;AVX-NEXT:  popq    %r15
+;AVX-NEXT:  popq    %rbp
+;AVX-NEXT:  popq    %rcx
+;AVX-NEXT:  popq    %rdx
+;AVX-NEXT:  popq    %rsi
+;AVX-NEXT:  popq    %rdi
+;AVX-NEXT:  popq    %r8
+;AVX-NEXT:  popq    %r9
+;AVX-NEXT:  popq    %r10
   call void asm sideeffect "", "~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{rbp},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15}"()
   ret void
 }
 
-; Make sure R11 and XMMs are saved before the call
+; Make sure RAX, R11 and XMMs are saved before the call
 declare preserve_mostcc void @foo(i64, i64, double, double)
 define void @preserve_mostcc2() nounwind {
 entry:
 ;SSE-LABEL: preserve_mostcc2
-;SSE:       movq %r11, [[REG:%[a-z0-9]+]]
+;SSE:       movq %rax, [[REG1:%[a-z0-9]+]]
+;SSE:       movq %r11, [[REG2:%[a-z0-9]+]]
 ;SSE:       movaps %xmm2
 ;SSE:       movaps %xmm3
 ;SSE:       movaps %xmm4

 ;SSE:       movaps %xmm13
 ;SSE:       movaps %xmm14
 ;SSE:       movaps %xmm15
-;SSE:       movq [[REG]], %r11
+;SSE:       call
+;SSE:       movq [[REG1]], %rax
+;SSE:       movq [[REG2]], %r11
+;SSE:       movaps {{.*}} %xmm2
+;SSE:       movaps {{.*}} %xmm3
+;SSE:       movaps {{.*}} %xmm4
+;SSE:       movaps {{.*}} %xmm5
+;SSE:       movaps {{.*}} %xmm6
+;SSE:       movaps {{.*}} %xmm7
+;SSE:       movaps {{.*}} %xmm8
+;SSE:       movaps {{.*}} %xmm9
+;SSE:       movaps {{.*}} %xmm10
+;SSE:       movaps {{.*}} %xmm11
+;SSE:       movaps {{.*}} %xmm12
+;SSE:       movaps {{.*}} %xmm13
+;SSE:       movaps {{.*}} %xmm14
+;SSE:       movaps {{.*}} %xmm15
   %a0 = call i64 asm sideeffect "", "={rax}"() nounwind
   %a1 = call i64 asm sideeffect "", "={rcx}"() nounwind
   %a2 = call i64 asm sideeffect "", "={rdx}"() nounwind