; Test the stack protector under XPLINK on z/OS
;
; RUN: llc < %s -mtriple=s390x-ibm-zos -mcpu=z13 --verify-machineinstrs | FileCheck --check-prefixes=CHECK %s

; Test stack protector for non-XPLEAF.

; Small stack frame.
; CHECK-LABEL: func0
; CHECK:                    * DSA Size [[#%#x,DSA_SIZE:]]
; CHECK:                    aghi  4,-[[#%u,mul(div(DSA_SIZE,32),32)]]
; CHECK:                    llgt  [[REG1:[0-9]+]],1208
; CHECK:                    mvc   [[#%u,2040+mul(div(DSA_SIZE,32),32)]](8,4),152([[REG1]])
; ...
; CHECK:                    llgt  [[REG3:[0-9]+]],1208
; CHECK:                    clc   [[#%u,2040+mul(div(DSA_SIZE,32),32)]](8,4),152([[REG3]])
; CHECK:                    jlh   [[FAIL_LABEL:L#BB[0-9_]+]]
; success block
; CHECK:                    aghi  4,[[#%u,mul(div(DSA_SIZE,32),32)]]
; CHECK:                    b     2(7)
; failure block
; CHECK:                    [[FAIL_LABEL]] DS 0H
; invoke __stack_chk_fail
; CHECK:                    lg    6,[[#CHK_FAIL_OFF:]]({{[0-9]+}})
; CHECK:                    lg    5,[[#CHK_FAIL_OFF-8]]({{[0-9]+}})
; CHECK:                    basr  7,6
; CHECK-NEXT:               bcr   0,0

define void @func0() sspreq {
  call i64 (i64) @fun(i64 10)
  ret void
}

; Large stack frame.
; Larger than 1M in XPLINK64.
; CHECK-LABEL: func1
; CHECK:                    * DSA Size [[#%#x,DSA_SIZE:]]
; CHECK:                    stmg  6,{{[0-9]+}},2064(4)
; CHECK:                    llgt  [[REG1:[0-9]+]],1208
; CHECK:                    llilh [[REG_CANARY_OFF_HIGH:[0-9]+]],[[#%u,CANARY_OFF_HIGH:div(DSA_SIZE,65536)]]
; CHECK:                    la    [[REG_CANARY_OFF_HIGH]],0([[REG_CANARY_OFF_HIGH]],4)
; CHECK:                    mvc   [[#%u,2040+mul(div(DSA_SIZE,32),32)-mul(CANARY_OFF_HIGH,65536)]](8,[[REG_CANARY_OFF_HIGH]]),152([[REG1]])
; ...
; CHECK:                    llgt  [[REG3:[0-9]+]],1208
; CHECK:                    llilh [[REG_CANARY_OFF_HIGH_2:[0-9]+]],[[#%u,CANARY_OFF_HIGH_2:div(DSA_SIZE,65536)]]
; CHECK:                    la    [[REG_CANARY_OFF_HIGH_2]],0([[REG_CANARY_OFF_HIGH_2]],4)
; CHECK:                    clc   [[#%u,2040+mul(div(DSA_SIZE,32),32)-mul(CANARY_OFF_HIGH_2,65536)]](8,[[REG_CANARY_OFF_HIGH_2]]),152([[REG3]])
; CHECK:                    jlh   [[FAIL_LABEL:L#BB[0-9_]+]]
; success block
; CHECK:                    agfi  4,[[#%u,mul(div(DSA_SIZE,32),32)]]
; CHECK:                    b     2(7)
; failure block
; CHECK:                    [[FAIL_LABEL]] DS 0H
; invoke __stack_chk_fail
; CHECK:                    lg    6,[[#CHK_FAIL_OFF:]]({{[0-9]+}})
; CHECK:                    lg    5,[[#CHK_FAIL_OFF-8]]({{[0-9]+}})
; CHECK:                    basr  7,6
; CHECK-NEXT:               bcr   0,0

define void @func1() sspreq {
  %arr = alloca [131072 x i64], align 8
  call i64 (ptr) @fun1(ptr %arr)
  ret void
}

; Test converting XPLeaf functions to non-leaf functions if they need stack protection

; Based on func3_64 in call-zos-03.ll
; CHECK-LABEL: func2_64
; CHECK:                    * Entry Flags
; CHECK-NEXT:               *   Bit 1: 0 = Non-leaf function
define i64 @func2_64(i64 %arg0) sspreq {
  %out = add i64 %arg0, 55
  ret i64 %out
}

; Based on func6 in zos-prologue-epilog.ll. R15 is callee-saved, so needs to be
; spilled to the stack before we use it. As a result this currently gets
; converted to a non-leaf function (even without sspreq).
; CHECK-LABEL: func3
; CHECK:                    * Entry Flags
; CHECK-NEXT:               *   Bit 1: 0 = Non-leaf function
define void @func3() local_unnamed_addr sspreq #0 {
entry:
  tail call void asm sideeffect " lhi 15,1\0A", "~{r15}"()
  ret void
}

; Test stack protector for function that uses alloca()

; CHECK-LABEL: func4
; CHECK:                    * DSA Size [[#%#x,DSA_SIZE:]]
; CHECK:                    * Entry Flags
; CHECK-NEXT:               *   Bit 1: 0 = Non-leaf function
; CHECK-NEXT:               *   Bit 2: 1 = Uses alloca
; CHECK:                    stmg  4,[[SPILLHI:[0-9]+]],[[#%u,2048-mul(div(DSA_SIZE,32),32)]](4)
; CHECK:                    aghi  4,-[[#%u,mul(div(DSA_SIZE,32),32)]]
; CHECK:                    lgr   [[ALLOCAREG:[0-9]+]],4
; CHECK:                    llgt  [[REG1:[0-9]+]],1208
; CHECK:                    mvc   [[#%u,2040+mul(div(DSA_SIZE,32),32)]](8,[[ALLOCAREG]]),152([[REG1]])
; ...
; CHECK:                    llgt  [[REG3:[0-9]+]],1208
; CHECK:                    clc   [[#%u,2040+mul(div(DSA_SIZE,32),32)]](8,[[ALLOCAREG]]),152([[REG3]])
; CHECK:                    jlh   [[FAIL_LABEL:L#BB[0-9_]+]]
; success block
; CHECK:                    lmg   4,[[SPILLHI]],2048(4)
; CHECK:                    b     2(7)
; failure block
; CHECK:                    [[FAIL_LABEL]] DS 0H
; invoke __stack_chk_fail
; CHECK:                    lg    6,[[#CHK_FAIL_OFF:]]({{[0-9]+}})
; CHECK:                    lg    5,[[#CHK_FAIL_OFF-8]]({{[0-9]+}})
; CHECK:                    basr  7,6
; CHECK-NEXT:               bcr   0,0

define i64 @func4(i64 %n) sspreq {
  %vla = alloca i64, i64 %n, align 8
  %call = call i64 @fun2(i64 %n, ptr nonnull %vla, ptr nonnull %vla)
  ret i64 %call
}

; Test stack protector off.

; CHECK-LABEL: func5
define void @func5() {
  call i64 (i64) @fun(i64 10)
  ret void
}

declare i64 @fun(i64 %arg0)
declare i64 @fun1(ptr %ptr)
declare i64 @fun2(i64 %n, ptr %arr0, ptr %arr1)

; CHECK-LABEL: L#PPA1_func0_0 DS 0H
; CHECK:                    * PPA1 Flags 2
; CHECK-NOT:                * PPA1 Flags 3
; CHECK:                    *   Bit 3: 1 = STACKPROTECT is enabled

; CHECK-LABEL: L#PPA1_func1_0 DS 0H
; CHECK:                    * PPA1 Flags 2
; CHECK-NOT:                * PPA1 Flags 3
; CHECK:                    *   Bit 3: 1 = STACKPROTECT is enabled

; CHECK-LABEL: L#PPA1_func2_64_0 DS 0H
; CHECK:                    * PPA1 Flags 2
; CHECK-NOT:                * PPA1 Flags 3
; CHECK:                    *   Bit 3: 1 = STACKPROTECT is enabled

; CHECK-LABEL: L#PPA1_func3_0 DS 0H
; CHECK:                    * PPA1 Flags 2
; CHECK-NOT:                * PPA1 Flags 3
; CHECK:                    *   Bit 3: 1 = STACKPROTECT is enabled

; CHECK-LABEL: L#PPA1_func4_0 DS 0H
; CHECK:                    * PPA1 Flags 2
; CHECK-NOT:                * PPA1 Flags 3
; CHECK:                    *   Bit 3: 1 = STACKPROTECT is enabled

; CHECK-LABEL: L#PPA1_func5_0 DS 0H
; CHECK:                    * PPA1 Flags 2
; CHECK-NOT:                * PPA1 Flags 3
; CHECK:                    *   Bit 3: 0 = STACKPROTECT is not enabled