test/CodeGen/X86/win_coreclr_chkstk.ll

   1 ; FIXME: Fix machine verifier issues and remove -verify-machineinstrs=0. PR38376.
   2 ; RUN: llc < %s -mtriple=x86_64-pc-win32-coreclr -verify-machineinstrs=0 | FileCheck %s -check-prefix=WIN_X64
   3 ; RUN: llc < %s -mtriple=x86_64-pc-linux         | FileCheck %s -check-prefix=LINUX
   4
   5 ; By default, windows CoreCLR requires an inline prologue stack expansion check
   6 ; if more than 4096 bytes are allocated on the stack.
   7
   8 ; Prolog stack allocation >= 4096 bytes will require the probe sequence
   9 define i32 @main4k() nounwind {
  10 entry:
  11 ; WIN_X64-LABEL:main4k:
  12 ; WIN_X64: # %bb.0:
  13 ; WIN_X64:      movl    $4096, %eax
  14 ; WIN_X64:      xorq    %rcx, %rcx
  15 ; WIN_X64:      movq    %rsp, %rdx
  16 ; WIN_X64:      subq    %rax, %rdx
  17 ; WIN_X64:      cmovbq  %rcx, %rdx
  18 ; WIN_X64:      movq    %gs:16, %rcx
  19 ; WIN_X64:      cmpq    %rcx, %rdx
  20 ; WIN_X64:      jae     .LBB0_3
  21 ; WIN_X64:# %bb.1:
  22 ; WIN_X64:      andq    $-4096, %rdx
  23 ; WIN_X64:.LBB0_2:
  24 ; WIN_X64:      addq    $-4096, %rcx
  25 ; WIN_X64:      movb    $0, (%rcx)
  26 ; WIN_X64:      cmpq    %rcx, %rdx
  27 ; WIN_X64:      jne     .LBB0_2
  28 ; WIN_X64:.LBB0_3:
  29 ; WIN_X64:      subq    %rax, %rsp
  30 ; WIN_X64:      xorl    %eax, %eax
  31 ; WIN_X64:      addq    $4096, %rsp
  32 ; WIN_X64:      retq
  33 ; LINUX-LABEL:main4k:
  34 ; LINUX-NOT:    movq    %gs:16, %rcx
  35 ; LINUX:        retq
  36   %a = alloca [4096 x i8]
  37   ret i32 0
  38 }
  39
  40 ; Prolog stack allocation >= 4096 bytes will require the probe sequence
  41 ; Case with frame pointer
  42 define i32 @main4k_frame() nounwind "no-frame-pointer-elim"="true" {
  43 entry:
  44 ; WIN_X64-LABEL:main4k_frame:
  45 ; WIN_X64:      movq    %gs:16, %rcx
  46 ; LINUX-LABEL:main4k_frame:
  47 ; LINUX-NOT:    movq    %gs:16, %rcx
  48 ; LINUX:        retq
  49   %a = alloca [4096 x i8]
  50   ret i32 0
  51 }
  52
  53 ; Prolog stack allocation >= 4096 bytes will require the probe sequence
  54 ; Case with INT args
  55 define i32 @main4k_intargs(i32 %x, i32 %y) nounwind {
  56 entry:
  57 ; WIN_X64:      movq    %gs:16, %rcx
  58 ; LINUX-NOT:    movq    %gs:16, %rcx
  59 ; LINUX:        retq
  60   %a = alloca [4096 x i8]
  61   %t = add i32 %x, %y
  62   ret i32 %t
  63 }
  64
  65 ; Prolog stack allocation >= 4096 bytes will require the probe sequence
  66 ; Case with FP regs
  67 define i32 @main4k_fpargs(double %x, double %y) nounwind {
  68 entry:
  69 ; WIN_X64:      movq    %gs:16, %rcx
  70 ; LINUX-NOT:    movq    %gs:16, %rcx
  71 ; LINUX:        retq
  72   %a = alloca [4096 x i8]
  73   ret i32 0
  74 }
  75
  76 ; Prolog stack allocation >= 4096 bytes will require the probe sequence
  77 ; Case with mixed regs
  78 define i32 @main4k_mixargs(double %x, i32 %y) nounwind {
  79 entry:
  80 ; WIN_X64:      movq    %gs:16, %rcx
  81 ; LINUX-NOT:    movq    %gs:16, %rcx
  82 ; LINUX:        retq
  83   %a = alloca [4096 x i8]
  84   ret i32 %y
  85 }
  86
  87 ; Make sure we don't emit the probe for a smaller prolog stack allocation.
  88 define i32 @main128() nounwind {
  89 entry:
  90 ; WIN_X64-NOT:  movq    %gs:16, %rcx
  91 ; WIN_X64:      retq
  92 ; LINUX-NOT:    movq    %gs:16, %rcx
  93 ; LINUX:        retq
  94   %a = alloca [128 x i8]
  95   ret i32 0
  96 }
  97
  98 ; Make sure we don't emit the probe sequence if not on windows even if the
  99 ; caller has the Win64 calling convention.
 100 define win64cc i32 @main4k_win64() nounwind {
 101 entry:
 102 ; WIN_X64:      movq    %gs:16, %rcx
 103 ; LINUX-NOT:    movq    %gs:16, %rcx
 104 ; LINUX:        retq
 105   %a = alloca [4096 x i8]
 106   ret i32 0
 107 }
 108
 109 declare i32 @bar(i8*) nounwind
 110
 111 ; Within-body inline probe expansion
 112 define win64cc i32 @main4k_alloca(i64 %n) nounwind {
 113 entry:
 114 ; WIN_X64:      callq   bar
 115 ; WIN_X64:      movq    %gs:16, [[R:%r.*]]
 116 ; WIN_X64:      callq   bar
 117 ; LINUX:        callq   bar
 118 ; LINUX-NOT:    movq    %gs:16, [[R:%r.*]]
 119 ; LINUX:        callq   bar
 120   %a = alloca i8, i64 1024
 121   %ra = call i32 @bar(i8* %a) nounwind
 122   %b = alloca i8, i64 %n
 123   %rb = call i32 @bar(i8* %b) nounwind
 124   %r = add i32 %ra, %rb
 125   ret i32 %r
 126 }
 127
 128 ; Influence of stack-probe-size attribute
 129 ; Note this is not exposed in coreclr
 130 define i32 @test_probe_size() "stack-probe-size"="8192" nounwind {
 131 ; WIN_X64-NOT:  movq    %gs:16, %rcx
 132 ; WIN_X64:      retq
 133 ; LINUX-NOT:    movq    %gs:16, %rcx
 134 ; LINUX:        retq
 135   %a = alloca [4096 x i8]
 136   ret i32 0
 137 }