; RUN: llc < %s -march=mips -mcpu=mips2 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP32
; RUN: llc < %s -march=mips -mcpu=mips32 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP32
; RUN: llc < %s -march=mips -mcpu=mips32r6 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP32
; RUN: llc < %s -march=mips64 -mcpu=mips3 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP64,N64
; RUN: llc < %s -march=mips64 -mcpu=mips64 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP64,N64
; RUN: llc < %s -march=mips64 -mcpu=mips64r6 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP64,N64
; RUN: llc < %s -march=mips64 -mcpu=mips3 -target-abi n32 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP64,N32
; RUN: llc < %s -march=mips64 -mcpu=mips64 -target-abi n32 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP64,N32
; RUN: llc < %s -march=mips64 -mcpu=mips64r6 -target-abi n32 -relocation-model=pic | FileCheck %s \
; RUN: --check-prefixes=ALL,GP64,N32
; Check dynamic stack realignment in functions without variable-sized objects.
declare void @helper_01(i32, i32, i32, i32, i32*)
; O32 ABI
define void @func_01() {
entry:
; GP32-LABEL: func_01:
; prologue
; FIXME: We are currently over-allocating stack space. This particular case
; needs a frame of up to between 16 and 512-bytes but currently
; allocates between 1024 and 1536 bytes
; GP32: addiu $sp, $sp, -1024
; GP32: sw $ra, 1020($sp)
; GP32: sw $fp, 1016($sp)
;
; GP32: move $fp, $sp
; GP32: addiu $[[T0:[0-9]+|ra|gp]], $zero, -512
; GP32-NEXT: and $sp, $sp, $[[T0]]
; body
; GP32: addiu $[[T1:[0-9]+]], $sp, 512
; GP32: sw $[[T1]], 16($sp)
; epilogue
; GP32: move $sp, $fp
; GP32: lw $fp, 1016($sp)
; GP32: lw $ra, 1020($sp)
; GP32: addiu $sp, $sp, 1024
%a = alloca i32, align 512
call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a)
ret void
}
declare void @helper_02(i32, i32, i32, i32,
i32, i32, i32, i32, i32*)
; N32/N64 ABIs
define void @func_02() {
entry:
; GP64-LABEL: func_02:
; prologue
; FIXME: We are currently over-allocating stack space. This particular case
; needs a frame of up to between 16 and 512-bytes but currently
; allocates between 1024 and 1536 bytes
; N32: addiu $sp, $sp, -1024
; N64: daddiu $sp, $sp, -1024
; GP64: sd $ra, 1016($sp)
; GP64: sd $fp, 1008($sp)
; N32: sd $gp, 1000($sp)
;
; GP64: move $fp, $sp
; N32: addiu $[[T0:[0-9]+|ra]], $zero, -512
; N64: daddiu $[[T0:[0-9]+|ra]], $zero, -512
; GP64-NEXT: and $sp, $sp, $[[T0]]
; body
; N32: addiu $[[T1:[0-9]+]], $sp, 512
; N64: daddiu $[[T1:[0-9]+]], $sp, 512
; GP64: sd $[[T1]], 0($sp)
; epilogue
; GP64: move $sp, $fp
; N32: ld $gp, 1000($sp)
; GP64: ld $fp, 1008($sp)
; GP64: ld $ra, 1016($sp)
; N32: addiu $sp, $sp, 1024
; N64: daddiu $sp, $sp, 1024
%a = alloca i32, align 512
call void @helper_02(i32 0, i32 0, i32 0, i32 0,
i32 0, i32 0, i32 0, i32 0, i32* %a)
ret void
}
; Verify that we use $fp for referencing incoming arguments.
declare void @helper_03(i32, i32, i32, i32, i32*, i32*)
; O32 ABI
define void @func_03(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32* %b) {
entry:
; GP32-LABEL: func_03:
; body
; FIXME: We are currently over-allocating stack space.
; GP32-DAG: addiu $[[T0:[0-9]+]], $sp, 512
; GP32-DAG: sw $[[T0]], 16($sp)
; GP32-DAG: lw $[[T1:[0-9]+]], 1040($fp)
; GP32-DAG: sw $[[T1]], 20($sp)
%a = alloca i32, align 512
call void @helper_03(i32 0, i32 0, i32 0, i32 0, i32* %a, i32* %b)
ret void
}
declare void @helper_04(i32, i32, i32, i32,
i32, i32, i32, i32, i32*, i32*)
; N32/N64 ABIs
define void @func_04(i32 %p0, i32 %p1, i32 %p2, i32 %p3,
i32 %p4, i32 %p5, i32 %p6, i32 %p7,
i32* %b) {
entry:
; GP64-LABEL: func_04:
; body
; FIXME: We are currently over-allocating stack space.
; N32-DAG: addiu $[[T0:[0-9]+]], $sp, 512
; N64-DAG: daddiu $[[T0:[0-9]+]], $sp, 512
; GP64-DAG: sd $[[T0]], 0($sp)
; GP64-DAG: ld $[[T1:[0-9]+]], 1024($fp)
; GP64-DAG: sd $[[T1]], 8($sp)
%a = alloca i32, align 512
call void @helper_04(i32 0, i32 0, i32 0, i32 0,
i32 0, i32 0, i32 0, i32 0, i32* %a, i32* %b)
ret void
}
; Check dynamic stack realignment in functions with variable-sized objects.
; O32 ABI
define void @func_05(i32 %sz) {
entry:
; GP32-LABEL: func_05:
; prologue
; FIXME: We are currently over-allocating stack space.
; GP32: addiu $sp, $sp, -1024
; GP32: sw $fp, 1020($sp)
; GP32: sw $23, 1016($sp)
;
; GP32: move $fp, $sp
; GP32: addiu $[[T0:[0-9]+|gp]], $zero, -512
; GP32-NEXT: and $sp, $sp, $[[T0]]
; GP32-NEXT: move $23, $sp
; body
; GP32: addiu $[[T1:[0-9]+]], $zero, 222
; GP32: sw $[[T1]], 508($23)
; epilogue
; GP32: move $sp, $fp
; GP32: lw $23, 1016($sp)
; GP32: lw $fp, 1020($sp)
; GP32: addiu $sp, $sp, 1024
%a0 = alloca i32, i32 %sz, align 512
%a1 = alloca i32, align 4
store volatile i32 111, i32* %a0, align 512
store volatile i32 222, i32* %a1, align 4
ret void
}
; N32/N64 ABIs
define void @func_06(i32 %sz) {
entry:
; GP64-LABEL: func_06:
; prologue
; FIXME: We are currently over-allocating stack space.
; N32: addiu $sp, $sp, -1024
; N64: daddiu $sp, $sp, -1024
; GP64: sd $fp, 1016($sp)
; GP64: sd $23, 1008($sp)
;
; GP64: move $fp, $sp
; GP64: addiu $[[T0:[0-9]+|gp]], $zero, -512
; GP64-NEXT: and $sp, $sp, $[[T0]]
; GP64-NEXT: move $23, $sp
; body
; GP64: addiu $[[T1:[0-9]+]], $zero, 222
; GP64: sw $[[T1]], 508($23)
; epilogue
; GP64: move $sp, $fp
; GP64: ld $23, 1008($sp)
; GP64: ld $fp, 1016($sp)
; N32: addiu $sp, $sp, 1024
; N64: daddiu $sp, $sp, 1024
%a0 = alloca i32, i32 %sz, align 512
%a1 = alloca i32, align 4
store volatile i32 111, i32* %a0, align 512
store volatile i32 222, i32* %a1, align 4
ret void
}
; Verify that we use $fp for referencing incoming arguments and $sp for
; building outbound arguments for nested function calls.
; O32 ABI
define void @func_07(i32 %p0, i32 %p1, i32 %p2, i32 %p3, i32 %sz) {
entry:
; GP32-LABEL: func_07:
; body
; FIXME: We are currently over-allocating stack space.
; GP32-DAG: lw $[[T0:[0-9]+]], 1040($fp)
;
; GP32-DAG: addiu $[[T1:[0-9]+]], $zero, 222
; GP32-DAG: sw $[[T1]], 508($23)
;
; GP32-DAG: sw $[[T2:[0-9]+]], 16($sp)
%a0 = alloca i32, i32 %sz, align 512
%a1 = alloca i32, align 4
store volatile i32 111, i32* %a0, align 512
store volatile i32 222, i32* %a1, align 4
call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a1)
ret void
}
; N32/N64 ABIs
define void @func_08(i32 %p0, i32 %p1, i32 %p2, i32 %p3,
i32 %p4, i32 %p5, i32 %p6, i32 %p7,
i32 %sz) {
entry:
; GP64-LABEL: func_08:
; body
; FIXME: We are currently over-allocating stack space.
; N32-DAG: lw $[[T0:[0-9]+]], 1028($fp)
; N64-DAG: lwu $[[T0:[0-9]+]], 1028($fp)
;
; GP64-DAG: addiu $[[T1:[0-9]+]], $zero, 222
; GP64-DAG: sw $[[T1]], 508($23)
;
; GP64-DAG: sd $[[T2:[0-9]+]], 0($sp)
%a0 = alloca i32, i32 %sz, align 512
%a1 = alloca i32, align 4
store volatile i32 111, i32* %a0, align 512
store volatile i32 222, i32* %a1, align 4
call void @helper_02(i32 0, i32 0, i32 0, i32 0,
i32 0, i32 0, i32 0, i32 0, i32* %a1)
ret void
}
; Check that we do not perform dynamic stack realignment in the presence of
; the "no-realign-stack" function attribute.
define void @func_09() "no-realign-stack" {
entry:
; ALL-LABEL: func_09:
; ALL-NOT: and $sp, $sp, $[[T0:[0-9]+|ra|gp]]
%a = alloca i32, align 512
call void @helper_01(i32 0, i32 0, i32 0, i32 0, i32* %a)
ret void
}
define void @func_10(i32 %sz) "no-realign-stack" {
entry:
; ALL-LABEL: func_10:
; ALL-NOT: and $sp, $sp, $[[T0:[0-9]+|ra|gp]]
%a0 = alloca i32, i32 %sz, align 512
%a1 = alloca i32, align 4
store volatile i32 111, i32* %a0, align 512
store volatile i32 222, i32* %a1, align 4
ret void
}