test/CodeGen/X86/win32_sret.ll

   1 ; RUN: llc < %s -mtriple=i686-pc-win32 | FileCheck %s -check-prefix=WIN32
   2 ; RUN: llc < %s -mtriple=i686-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X86
   3 ; RUN: llc < %s -mtriple=i386-pc-linux | FileCheck %s -check-prefix=LINUX
   4 ; RUN: llc < %s -O0 -mtriple=i686-pc-win32 | FileCheck %s -check-prefix=WIN32
   5 ; RUN: llc < %s -O0 -mtriple=i686-pc-mingw32 | FileCheck %s -check-prefix=MINGW_X86
   6 ; RUN: llc < %s -O0 -mtriple=i386-pc-linux | FileCheck %s -check-prefix=LINUX
   7
   8 ; The SysV ABI used by most Unixes and Mingw on x86 specifies that an sret pointer
   9 ; is callee-cleanup. However, in MSVC's cdecl calling convention, sret pointer
  10 ; arguments are caller-cleanup like normal arguments.
  11
  12 define void @sret1(i8* sret %x) nounwind {
  13 entry:
  14 ; WIN32:      sret1
  15 ; WIN32:      movb $42, (%eax)
  16 ; WIN32-NOT:  popl %eax
  17 ; WIN32:    {{ret$}}
  18
  19 ; MINGW_X86:  sret1
  20 ; MINGW_X86:  ret $4
  21
  22 ; LINUX:      sret1
  23 ; LINUX:      ret $4
  24
  25   store i8 42, i8* %x, align 4
  26   ret void
  27 }
  28
  29 define void @sret2(i8* sret %x, i8 %y) nounwind {
  30 entry:
  31 ; WIN32:      sret2
  32 ; WIN32:      movb {{.*}}, (%eax)
  33 ; WIN32-NOT:  popl %eax
  34 ; WIN32:    {{ret$}}
  35
  36 ; MINGW_X86:  sret2
  37 ; MINGW_X86:  ret $4
  38
  39 ; LINUX:      sret2
  40 ; LINUX:      ret $4
  41
  42   store i8 %y, i8* %x
  43   ret void
  44 }
  45
  46 define void @sret3(i8* sret %x, i8* %y) nounwind {
  47 entry:
  48 ; WIN32:      sret3
  49 ; WIN32:      movb $42, (%eax)
  50 ; WIN32-NOT:  movb $13, (%eax)
  51 ; WIN32-NOT:  popl %eax
  52 ; WIN32:    {{ret$}}
  53
  54 ; MINGW_X86:  sret3
  55 ; MINGW_X86:  ret $4
  56
  57 ; LINUX:      sret3
  58 ; LINUX:      ret $4
  59
  60   store i8 42, i8* %x
  61   store i8 13, i8* %y
  62   ret void
  63 }
  64
  65 ; PR15556
  66 %struct.S4 = type { i32, i32, i32 }
  67
  68 define void @sret4(%struct.S4* noalias sret %agg.result) {
  69 entry:
  70 ; WIN32:     sret4
  71 ; WIN32:     movl $42, (%eax)
  72 ; WIN32-NOT: popl %eax
  73 ; WIN32:   {{ret$}}
  74
  75 ; MINGW_X86: sret4
  76 ; MINGW_X86: ret $4
  77
  78 ; LINUX:     sret4
  79 ; LINUX:     ret $4
  80
  81   %x = getelementptr inbounds %struct.S4* %agg.result, i32 0, i32 0
  82   store i32 42, i32* %x, align 4
  83   ret void
  84 }
  85
  86 %struct.S5 = type { i32 }
  87 %class.C5 = type { i8 }
  88
  89 define x86_thiscallcc void @"\01?foo@C5@@QAE?AUS5@@XZ"(%struct.S5* noalias sret %agg.result, %class.C5* %this) {
  90 entry:
  91   %this.addr = alloca %class.C5*, align 4
  92   store %class.C5* %this, %class.C5** %this.addr, align 4
  93   %this1 = load %class.C5** %this.addr
  94   %x = getelementptr inbounds %struct.S5* %agg.result, i32 0, i32 0
  95   store i32 42, i32* %x, align 4
  96   ret void
  97 ; WIN32:     {{^}}"?foo@C5@@QAE?AUS5@@XZ":
  98
  99 ; The address of the return structure is passed as an implicit parameter.
 100 ; In the -O0 build, %eax is spilled at the beginning of the function, hence we
 101 ; should match both 4(%esp) and 8(%esp).
 102 ; WIN32:     {{[48]}}(%esp), %eax
 103 ; WIN32:     movl $42, (%eax)
 104 ; WIN32:     ret $4
 105 }
 106
 107 define void @call_foo5() {
 108 entry:
 109   %c = alloca %class.C5, align 1
 110   %s = alloca %struct.S5, align 4
 111   call x86_thiscallcc void @"\01?foo@C5@@QAE?AUS5@@XZ"(%struct.S5* sret %s, %class.C5* %c)
 112 ; WIN32:      {{^}}_call_foo5:
 113
 114 ; Load the address of the result and put it onto stack
 115 ; (through %ecx in the -O0 build).
 116 ; WIN32:      leal {{[0-9]+}}(%esp), %eax
 117 ; WIN32:      movl %eax, (%e{{[sc][px]}})
 118
 119 ; The this pointer goes to ECX.
 120 ; FIXME: for some reason, the below checks fail on the Ubuntu Atom D2700 bot.
 121 ; FIXME-NEXT: leal {{[0-9]+}}(%esp), %ecx
 122 ; FIXME-NEXT: calll "?foo@C5@@QAE?AUS5@@XZ"
 123
 124 ; WIN32:      calll "?foo@C5@@QAE?AUS5@@XZ"
 125 ; WIN32:      ret
 126   ret void
 127 }