test/CodeGen/X86/win32_sret.ll - llvm-project/llvm - Git at Google

 ; We specify -mcpu explicitly to avoid instruction reordering that happens on
 ; some setups (e.g., Atom) from affecting the output.
 ; RUN: llc < %s -mcpu=core2 -mtriple=i686-pc-win32 | FileCheck %s -check-prefix=WIN32
 ; RUN: llc < %s -mcpu=core2 -mtriple=i686-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X86
 ; RUN: llc < %s -mcpu=core2 -mtriple=i686-pc-cygwin | FileCheck %s -check-prefix=CYGWIN
 ; RUN: llc < %s -mcpu=core2 -mtriple=i386-pc-linux | FileCheck %s -check-prefix=LINUX
 ; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i686-pc-win32 | FileCheck %s -check-prefix=WIN32
 ; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i686-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X86
 ; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i686-pc-cygwin | FileCheck %s -check-prefix=CYGWIN
 ; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i386-pc-linux | FileCheck %s -check-prefix=LINUX

 ; The SysV ABI used by most Unixes and Mingw on x86 specifies that an sret pointer
 ; is callee-cleanup. However, in MSVC's cdecl calling convention, sret pointer
 ; arguments are caller-cleanup like normal arguments.

 define void @sret1(ptr sret(i8) %x) nounwind {
 entry:
 ; WIN32-LABEL:      _sret1:
 ; WIN32:      movb $42, ({{%e[abcd]x}})
 ; WIN32-NOT:  popl %eax
 ; WIN32:    {{retl$}}

 ; MINGW_X86-LABEL:  _sret1:
 ; MINGW_X86:  {{retl$}}

 ; CYGWIN-LABEL:     _sret1:
 ; CYGWIN:     retl $4

 ; LINUX-LABEL:      sret1:
 ; LINUX:      retl $4

   store i8 42, ptr %x, align 4
   ret void
 }

 define void @sret2(ptr sret(i8) %x, i8 %y) nounwind {
 entry:
 ; WIN32-LABEL:      _sret2:
 ; WIN32:      movb {{.*}}, ({{%e[abcd]x}})
 ; WIN32-NOT:  popl %eax
 ; WIN32:    {{retl$}}

 ; MINGW_X86-LABEL:  _sret2:
 ; MINGW_X86:  {{retl$}}

 ; CYGWIN-LABEL:     _sret2:
 ; CYGWIN:     retl $4

 ; LINUX-LABEL:      sret2:
 ; LINUX:      retl $4

   store i8 %y, ptr %x
   ret void
 }

 define void @sret3(ptr sret(i8) %x, ptr %y) nounwind {
 entry:
 ; WIN32-LABEL:      _sret3:
 ; WIN32:      movb $42, ([[REG1:%e[abcd]x]])
 ; WIN32-NOT:  movb $13, ([[REG1]])
 ; WIN32-NOT:  popl %eax
 ; WIN32:    {{retl$}}

 ; MINGW_X86-LABEL:  _sret3:
 ; MINGW_X86:  {{retl$}}

 ; CYGWIN-LABEL:     _sret3:
 ; CYGWIN:     retl $4

 ; LINUX-LABEL:      sret3:
 ; LINUX:      retl $4

   store i8 42, ptr %x
   store i8 13, ptr %y
   ret void
 }

 ; PR15556
 %struct.S4 = type { i32, i32, i32 }

 define void @sret4(ptr noalias sret(%struct.S4) %agg.result) {
 entry:
 ; WIN32-LABEL:     _sret4:
 ; WIN32:     movl $42, ({{%e[abcd]x}})
 ; WIN32-NOT: popl %eax
 ; WIN32:   {{retl$}}

 ; MINGW_X86-LABEL: _sret4:
 ; MINGW_X86: {{retl$}}

 ; CYGWIN-LABEL:    _sret4:
 ; CYGWIN:    retl $4

 ; LINUX-LABEL:     sret4:
 ; LINUX:     retl $4

   store i32 42, ptr %agg.result, align 4
   ret void
 }

 %struct.S5 = type { i32 }
 %class.C5 = type { i8 }

 define x86_thiscallcc void @"\01?foo@C5@@QAE?AUS5@@XZ"(ptr noalias sret(%struct.S5) %agg.result, ptr %this) {
 entry:
   %this.addr = alloca ptr, align 4
   store ptr %this, ptr %this.addr, align 4
   %this1 = load ptr, ptr %this.addr
   store i32 42, ptr %agg.result, align 4
   ret void
 ; WIN32-LABEL:     {{^}}"?foo@C5@@QAE?AUS5@@XZ":
 ; MINGW_X86-LABEL: {{^}}"?foo@C5@@QAE?AUS5@@XZ":
 ; CYGWIN-LABEL:    {{^}}"?foo@C5@@QAE?AUS5@@XZ":
 ; LINUX-LABEL:     {{^}}"?foo@C5@@QAE?AUS5@@XZ":

 ; The address of the return structure is passed as an implicit parameter.
 ; In the -O0 build, %eax is spilled at the beginning of the function, hence we
 ; should match both 4(%esp) and 8(%esp).
 ; WIN32:     {{[48]}}(%esp), [[REG:%e[abcd]x]]
 ; WIN32:     movl $42, ([[REG]])
 ; WIN32:     retl $4
 }

 define void @call_foo5() {
 entry:
   %c = alloca %class.C5, align 1
   %s = alloca %struct.S5, align 4
   call x86_thiscallcc void @"\01?foo@C5@@QAE?AUS5@@XZ"(ptr sret(%struct.S5) %s, ptr %c)
 ; WIN32-LABEL:      {{^}}_call_foo5:
 ; MINGW_X86-LABEL:  {{^}}_call_foo5:
 ; CYGWIN-LABEL:     {{^}}_call_foo5:
 ; LINUX-LABEL:      {{^}}call_foo5:


 ; Load the address of the result and put it onto stack
 ; The this pointer goes to ECX.
 ; (through %ecx in the -O0 build).
 ; WIN32-DAG:  leal {{[0-9]*}}(%esp), %e{{[a-d]}}x
 ; WIN32-DAG:  {{leal [1-9]+\(%esp\)|movl %esp}}, %ecx
 ; WIN32-DAG:  {{pushl %e[a-d]x|movl %e[a-d]x, \(%esp\)}}
 ; WIN32-NEXT: calll "?foo@C5@@QAE?AUS5@@XZ"
 ; WIN32:      retl
   ret void
 }


 %struct.test6 = type { i32, i32, i32 }
 define void @test6_f(ptr %x) nounwind {
 ; WIN32-LABEL: _test6_f:
 ; MINGW_X86-LABEL: _test6_f:
 ; CYGWIN-LABEL: _test6_f:
 ; LINUX-LABEL: test6_f:

 ; The %x argument is moved to %ecx. It will be the this pointer.
 ; WIN32-DAG: movl    {{16|20}}(%esp), %ecx


 ; The sret pointer is (%esp)
 ; WIN32-DAG:      {{leal 4\(%esp\)|movl %esp}}, %eax
 ; WIN32-DAG:      {{pushl   %eax|movl %eax, \(%esp\)}}

 ; The sret pointer is %ecx
 ; The %x argument is moved to (%esp). It will be the this pointer.
 ; MINGW_X86-DAG:  {{leal 4\(%esp\)|movl %esp}}, %ecx
 ; MINGW_X86-DAG: {{pushl   16\(%esp\)|movl %eax, \(%esp\)}}
 ; MINGW_X86-NEXT: calll   _test6_g

 ; CYGWIN-DAG:  {{leal 4\(%esp\)|movl %esp}}, %ecx
 ; CYGWIN-DAG:  {{pushl   16\(%esp\)|movl %eax, \(%esp\)}}
 ; CYGWIN-NEXT: calll   _test6_g

   %tmp = alloca %struct.test6, align 4
   call x86_thiscallcc void @test6_g(ptr sret(%struct.test6) %tmp, ptr %x)
   ret void
 }
 declare x86_thiscallcc void @test6_g(ptr sret(%struct.test6), ptr)

 ; Flipping the parameters at the IR level generates the same code.
 %struct.test7 = type { i32, i32, i32 }
 define void @test7_f(ptr %x) nounwind {
 ; WIN32-LABEL: _test7_f:
 ; MINGW_X86-LABEL: _test7_f:
 ; CYGWIN-LABEL: _test7_f:
 ; LINUX-LABEL: test7_f:

 ; The %x argument is moved to %ecx on all OSs. It will be the this pointer.
 ; WIN32:      movl    {{16|20}}(%esp), %ecx
 ; MINGW_X86:  movl    {{16|20}}(%esp), %ecx
 ; CYGWIN:     movl    {{16|20}}(%esp), %ecx

 ; The sret pointer is (%esp)
 ; WIN32:      {{leal 4\(%esp\)|movl %esp}}, %eax
 ; WIN32-NEXT:     {{pushl   %eax|movl %eax, \(%esp\)}}
 ; MINGW_X86:      {{leal 4\(%esp\)|movl %esp}}, %eax
 ; MINGW_X86-NEXT: {{pushl   %eax|movl %eax, \(%esp\)}}
 ; CYGWIN:      {{leal 4\(%esp\)|movl %esp}}, %eax
 ; CYGWIN-NEXT: {{pushl   %eax|movl %eax, \(%esp\)}}

   %tmp = alloca %struct.test7, align 4
   call x86_thiscallcc void @test7_g(ptr %x, ptr sret(%struct.test7) %tmp)
   ret void
 }

 define x86_thiscallcc void @test7_g(ptr %in, ptr sret(%struct.test7) %out) {
   %v = load i32, ptr %in
   store i32 %v, ptr %out
   call void @clobber_eax()
   ret void

 ; Make sure we return the second parameter in %eax.
 ; WIN32-LABEL: _test7_g:
 ; WIN32: calll _clobber_eax
 ; WIN32: movl {{.*}}, %eax
 ; WIN32: retl
 }

 declare void @clobber_eax()

 ; Test what happens if the first parameter has to be split by codegen.
 ; Realistically, no frontend will generate code like this, but here it is for
 ; completeness.
 define void @test8_f(i64 inreg %a, ptr sret(i64) %out) {
   store i64 %a, ptr %out
   call void @clobber_eax()
   ret void

 ; WIN32-LABEL: _test8_f:
 ; WIN32: movl {{[0-9]+}}(%esp), %[[out:[a-z]+]]
 ; WIN32-DAG: movl {{%e[abcd]x}}, 4(%[[out]])
 ; WIN32-DAG: movl {{%e[abcd]x}}, (%[[out]])
 ; WIN32: calll _clobber_eax
 ; WIN32: movl {{.*}}, %eax
 ; WIN32: retl
 }
	; We specify -mcpu explicitly to avoid instruction reordering that happens on
	; some setups (e.g., Atom) from affecting the output.
	; RUN: llc < %s -mcpu=core2 -mtriple=i686-pc-win32 \| FileCheck %s -check-prefix=WIN32
	; RUN: llc < %s -mcpu=core2 -mtriple=i686-pc-mingw32 \| FileCheck %s -check-prefix=MINGW_X86
	; RUN: llc < %s -mcpu=core2 -mtriple=i686-pc-cygwin \| FileCheck %s -check-prefix=CYGWIN
	; RUN: llc < %s -mcpu=core2 -mtriple=i386-pc-linux \| FileCheck %s -check-prefix=LINUX
	; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i686-pc-win32 \| FileCheck %s -check-prefix=WIN32
	; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i686-pc-mingw32 \| FileCheck %s -check-prefix=MINGW_X86
	; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i686-pc-cygwin \| FileCheck %s -check-prefix=CYGWIN
	; RUN: llc < %s -mcpu=core2 -O0 -mtriple=i386-pc-linux \| FileCheck %s -check-prefix=LINUX

	; The SysV ABI used by most Unixes and Mingw on x86 specifies that an sret pointer
	; is callee-cleanup. However, in MSVC's cdecl calling convention, sret pointer
	; arguments are caller-cleanup like normal arguments.

	define void @sret1(ptr sret(i8) %x) nounwind {
	entry:
	; WIN32-LABEL: _sret1:
	; WIN32: movb $42, ({{%e[abcd]x}})
	; WIN32-NOT: popl %eax
	; WIN32: {{retl$}}

	; MINGW_X86-LABEL: _sret1:
	; MINGW_X86: {{retl$}}

	; CYGWIN-LABEL: _sret1:
	; CYGWIN: retl $4

	; LINUX-LABEL: sret1:
	; LINUX: retl $4

	store i8 42, ptr %x, align 4
	ret void
	}

	define void @sret2(ptr sret(i8) %x, i8 %y) nounwind {
	entry:
	; WIN32-LABEL: _sret2:
	; WIN32: movb {{.*}}, ({{%e[abcd]x}})
	; WIN32-NOT: popl %eax
	; WIN32: {{retl$}}

	; MINGW_X86-LABEL: _sret2:
	; MINGW_X86: {{retl$}}

	; CYGWIN-LABEL: _sret2:
	; CYGWIN: retl $4

	; LINUX-LABEL: sret2:
	; LINUX: retl $4

	store i8 %y, ptr %x
	ret void
	}

	define void @sret3(ptr sret(i8) %x, ptr %y) nounwind {
	entry:
	; WIN32-LABEL: _sret3:
	; WIN32: movb $42, ([[REG1:%e[abcd]x]])
	; WIN32-NOT: movb $13, ([[REG1]])
	; WIN32-NOT: popl %eax
	; WIN32: {{retl$}}

	; MINGW_X86-LABEL: _sret3:
	; MINGW_X86: {{retl$}}

	; CYGWIN-LABEL: _sret3:
	; CYGWIN: retl $4

	; LINUX-LABEL: sret3:
	; LINUX: retl $4

	store i8 42, ptr %x
	store i8 13, ptr %y
	ret void
	}

	; PR15556
	%struct.S4 = type { i32, i32, i32 }

	define void @sret4(ptr noalias sret(%struct.S4) %agg.result) {
	entry:
	; WIN32-LABEL: _sret4:
	; WIN32: movl $42, ({{%e[abcd]x}})
	; WIN32-NOT: popl %eax
	; WIN32: {{retl$}}

	; MINGW_X86-LABEL: _sret4:
	; MINGW_X86: {{retl$}}

	; CYGWIN-LABEL: _sret4:
	; CYGWIN: retl $4

	; LINUX-LABEL: sret4:
	; LINUX: retl $4

	store i32 42, ptr %agg.result, align 4
	ret void
	}

	%struct.S5 = type { i32 }
	%class.C5 = type { i8 }

	define x86_thiscallcc void @"\01?foo@C5@@QAE?AUS5@@XZ"(ptr noalias sret(%struct.S5) %agg.result, ptr %this) {
	entry:
	%this.addr = alloca ptr, align 4
	store ptr %this, ptr %this.addr, align 4
	%this1 = load ptr, ptr %this.addr
	store i32 42, ptr %agg.result, align 4
	ret void
	; WIN32-LABEL: {{^}}"?foo@C5@@QAE?AUS5@@XZ":
	; MINGW_X86-LABEL: {{^}}"?foo@C5@@QAE?AUS5@@XZ":
	; CYGWIN-LABEL: {{^}}"?foo@C5@@QAE?AUS5@@XZ":
	; LINUX-LABEL: {{^}}"?foo@C5@@QAE?AUS5@@XZ":

	; The address of the return structure is passed as an implicit parameter.
	; In the -O0 build, %eax is spilled at the beginning of the function, hence we
	; should match both 4(%esp) and 8(%esp).
	; WIN32: {{[48]}}(%esp), [[REG:%e[abcd]x]]
	; WIN32: movl $42, ([[REG]])
	; WIN32: retl $4
	}

	define void @call_foo5() {
	entry:
	%c = alloca %class.C5, align 1
	%s = alloca %struct.S5, align 4
	call x86_thiscallcc void @"\01?foo@C5@@QAE?AUS5@@XZ"(ptr sret(%struct.S5) %s, ptr %c)
	; WIN32-LABEL: {{^}}_call_foo5:
	; MINGW_X86-LABEL: {{^}}_call_foo5:
	; CYGWIN-LABEL: {{^}}_call_foo5:
	; LINUX-LABEL: {{^}}call_foo5:


	; Load the address of the result and put it onto stack
	; The this pointer goes to ECX.
	; (through %ecx in the -O0 build).
	; WIN32-DAG: leal {{[0-9]*}}(%esp), %e{{[a-d]}}x
	; WIN32-DAG: {{leal [1-9]+\(%esp\)\|movl %esp}}, %ecx
	; WIN32-DAG: {{pushl %e[a-d]x\|movl %e[a-d]x, \(%esp\)}}
	; WIN32-NEXT: calll "?foo@C5@@QAE?AUS5@@XZ"
	; WIN32: retl
	ret void
	}


	%struct.test6 = type { i32, i32, i32 }
	define void @test6_f(ptr %x) nounwind {
	; WIN32-LABEL: _test6_f:
	; MINGW_X86-LABEL: _test6_f:
	; CYGWIN-LABEL: _test6_f:
	; LINUX-LABEL: test6_f:

	; The %x argument is moved to %ecx. It will be the this pointer.
	; WIN32-DAG: movl {{16\|20}}(%esp), %ecx


	; The sret pointer is (%esp)
	; WIN32-DAG: {{leal 4\(%esp\)\|movl %esp}}, %eax
	; WIN32-DAG: {{pushl %eax\|movl %eax, \(%esp\)}}

	; The sret pointer is %ecx
	; The %x argument is moved to (%esp). It will be the this pointer.
	; MINGW_X86-DAG: {{leal 4\(%esp\)\|movl %esp}}, %ecx
	; MINGW_X86-DAG: {{pushl 16\(%esp\)\|movl %eax, \(%esp\)}}
	; MINGW_X86-NEXT: calll _test6_g

	; CYGWIN-DAG: {{leal 4\(%esp\)\|movl %esp}}, %ecx
	; CYGWIN-DAG: {{pushl 16\(%esp\)\|movl %eax, \(%esp\)}}
	; CYGWIN-NEXT: calll _test6_g

	%tmp = alloca %struct.test6, align 4
	call x86_thiscallcc void @test6_g(ptr sret(%struct.test6) %tmp, ptr %x)
	ret void
	}
	declare x86_thiscallcc void @test6_g(ptr sret(%struct.test6), ptr)

	; Flipping the parameters at the IR level generates the same code.
	%struct.test7 = type { i32, i32, i32 }
	define void @test7_f(ptr %x) nounwind {
	; WIN32-LABEL: _test7_f:
	; MINGW_X86-LABEL: _test7_f:
	; CYGWIN-LABEL: _test7_f:
	; LINUX-LABEL: test7_f:

	; The %x argument is moved to %ecx on all OSs. It will be the this pointer.
	; WIN32: movl {{16\|20}}(%esp), %ecx
	; MINGW_X86: movl {{16\|20}}(%esp), %ecx
	; CYGWIN: movl {{16\|20}}(%esp), %ecx

	; The sret pointer is (%esp)
	; WIN32: {{leal 4\(%esp\)\|movl %esp}}, %eax
	; WIN32-NEXT: {{pushl %eax\|movl %eax, \(%esp\)}}
	; MINGW_X86: {{leal 4\(%esp\)\|movl %esp}}, %eax
	; MINGW_X86-NEXT: {{pushl %eax\|movl %eax, \(%esp\)}}
	; CYGWIN: {{leal 4\(%esp\)\|movl %esp}}, %eax
	; CYGWIN-NEXT: {{pushl %eax\|movl %eax, \(%esp\)}}

	%tmp = alloca %struct.test7, align 4
	call x86_thiscallcc void @test7_g(ptr %x, ptr sret(%struct.test7) %tmp)
	ret void
	}

	define x86_thiscallcc void @test7_g(ptr %in, ptr sret(%struct.test7) %out) {
	%v = load i32, ptr %in
	store i32 %v, ptr %out
	call void @clobber_eax()
	ret void

	; Make sure we return the second parameter in %eax.
	; WIN32-LABEL: _test7_g:
	; WIN32: calll _clobber_eax
	; WIN32: movl {{.*}}, %eax
	; WIN32: retl
	}

	declare void @clobber_eax()

	; Test what happens if the first parameter has to be split by codegen.
	; Realistically, no frontend will generate code like this, but here it is for
	; completeness.
	define void @test8_f(i64 inreg %a, ptr sret(i64) %out) {
	store i64 %a, ptr %out
	call void @clobber_eax()
	ret void

	; WIN32-LABEL: _test8_f:
	; WIN32: movl {{[0-9]+}}(%esp), %[[out:[a-z]+]]
	; WIN32-DAG: movl {{%e[abcd]x}}, 4(%[[out]])
	; WIN32-DAG: movl {{%e[abcd]x}}, (%[[out]])
	; WIN32: calll _clobber_eax
	; WIN32: movl {{.*}}, %eax
	; WIN32: retl
	}