mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-26 12:43:36 +01:00
13d15dbc40
Move the register stackification and coloring passes to run very late, after PEI, tail duplication, and most other passes. This means that all code emitted and expanded by those passes is now exposed to these passes. This also eliminates the need for prologue/epilogue code to be manually stackified, which significantly simplifies the code. This does require running LiveIntervals a second time. It's useful to think of these late passes not as late optimization passes, but as a domain-specific compression algorithm based on knowledge of liveness information. It's used to compress the code after all conventional optimizations are complete, which is why it uses LiveIntervals at a phase when actual optimization passes don't typically need it. Differential Revision: http://reviews.llvm.org/D20075 llvm-svn: 269012
132 lines
5.5 KiB
LLVM
132 lines
5.5 KiB
LLVM
; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s
|
|
; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -fast-isel | FileCheck %s
|
|
|
|
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
|
|
target triple = "wasm32-unknown-unknown"
|
|
|
|
%SmallStruct = type { i32 }
|
|
%OddStruct = type { i32, i8, i32 }
|
|
%AlignedStruct = type { double, double }
|
|
%BigStruct = type { double, double, double, double, double, double, double, double, double, double, double, i8, i8, i8 }
|
|
%EmptyStruct = type { }
|
|
|
|
%BigArray = type { [33 x i8] }
|
|
|
|
declare void @ext_func(%SmallStruct*)
|
|
declare void @ext_func_empty(%EmptyStruct* byval)
|
|
declare void @ext_byval_func(%SmallStruct* byval)
|
|
declare void @ext_byval_func_align8(%SmallStruct* byval align 8)
|
|
declare void @ext_byval_func_alignedstruct(%AlignedStruct* byval)
|
|
declare void @ext_byval_func_bigarray(%BigArray* byval)
|
|
declare void @ext_byval_func_empty(%EmptyStruct* byval)
|
|
|
|
; CHECK-LABEL: byval_arg
|
|
define void @byval_arg(%SmallStruct* %ptr) {
|
|
; CHECK: .param i32
|
|
; CHECK: i32.const $push[[L4:.+]]=, __stack_pointer
|
|
; Subtract 16 from SP (SP is 16-byte aligned)
|
|
; CHECK: i32.const $push[[L1:.+]]=, __stack_pointer
|
|
; CHECK-NEXT: i32.load $push[[L2:.+]]=, 0($pop[[L1]])
|
|
; CHECK-NEXT: i32.const $push[[L3:.+]]=, 16
|
|
; CHECK-NEXT: i32.sub $push[[L10:.+]]=, $pop[[L2]], $pop[[L3]]
|
|
; Ensure SP is stored back before the call
|
|
; CHECK-NEXT: i32.store $push[[L12:.+]]=, 0($pop[[L4]]), $pop[[L10]]{{$}}
|
|
; CHECK-NEXT: tee_local $push[[L11:.+]]=, $[[SP:.+]]=, $pop[[L12]]{{$}}
|
|
; Copy the SmallStruct argument to the stack (SP+12, original SP-4)
|
|
; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0)
|
|
; CHECK-NEXT: i32.store $discard=, 12($pop[[L11]]), $pop[[L0]]
|
|
; Pass a pointer to the stack slot to the function
|
|
; CHECK-NEXT: i32.const $push[[L5:.+]]=, 12{{$}}
|
|
; CHECK-NEXT: i32.add $push[[ARG:.+]]=, $[[SP]], $pop[[L5]]{{$}}
|
|
; CHECK-NEXT: call ext_byval_func@FUNCTION, $pop[[ARG]]{{$}}
|
|
call void @ext_byval_func(%SmallStruct* byval %ptr)
|
|
; Restore the stack
|
|
; CHECK-NEXT: i32.const $push[[L7:.+]]=, __stack_pointer
|
|
; CHECK-NEXT: i32.const $push[[L6:.+]]=, 16
|
|
; CHECK-NEXT: i32.add $push[[L8:.+]]=, $[[SP]], $pop[[L6]]
|
|
; CHECK-NEXT: i32.store {{.*}}=, 0($pop[[L7]]), $pop[[L8]]
|
|
; CHECK-NEXT: return
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: byval_arg_align8
|
|
define void @byval_arg_align8(%SmallStruct* %ptr) {
|
|
; CHECK: .param i32
|
|
; Don't check the entire SP sequence, just enough to get the alignment.
|
|
; CHECK: i32.const $push[[L1:.+]]=, 16
|
|
; CHECK-NEXT: i32.sub $push[[L10:.+]]=, {{.+}}, $pop[[L1]]
|
|
; CHECK-NEXT: i32.store $push[[L12:.+]]=, 0($pop{{.+}}), $pop[[L10]]{{$}}
|
|
; CHECK-NEXT: tee_local $push[[L11:.+]]=, $[[SP:.+]]=, $pop[[L12]]{{$}}
|
|
; Copy the SmallStruct argument to the stack (SP+8, original SP-8)
|
|
; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0){{$}}
|
|
; CHECK-NEXT: i32.store $discard=, 8($pop[[L11]]), $pop[[L0]]{{$}}
|
|
; Pass a pointer to the stack slot to the function
|
|
; CHECK-NEXT: i32.const $push[[L5:.+]]=, 8{{$}}
|
|
; CHECK-NEXT: i32.add $push[[ARG:.+]]=, $[[SP]], $pop[[L5]]{{$}}
|
|
; CHECK-NEXT: call ext_byval_func_align8@FUNCTION, $pop[[ARG]]{{$}}
|
|
call void @ext_byval_func_align8(%SmallStruct* byval align 8 %ptr)
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: byval_arg_double
|
|
define void @byval_arg_double(%AlignedStruct* %ptr) {
|
|
; CHECK: .param i32
|
|
; Subtract 16 from SP (SP is 16-byte aligned)
|
|
; CHECK: i32.const $push[[L1:.+]]=, 16
|
|
; CHECK-NEXT: i32.sub $push[[L12:.+]]=, {{.+}}, $pop[[L1]]
|
|
; CHECK-NEXT: i32.store $push[[L15:.+]]=, {{.+}}, $pop[[L12]]
|
|
; CHECK-NEXT: tee_local $push[[L14:.+]]=, $[[SP:.+]]=, $pop[[L15]]
|
|
; Copy the AlignedStruct argument to the stack (SP+0, original SP-16)
|
|
; Just check the last load/store pair of the memcpy
|
|
; CHECK: i64.load $push[[L4:.+]]=, 0($0)
|
|
; CHECK-NEXT: i64.store $discard=, 0($[[SP]]), $pop[[L4]]
|
|
; Pass a pointer to the stack slot to the function
|
|
; CHECK-NEXT: call ext_byval_func_alignedstruct@FUNCTION, $[[SP]]
|
|
tail call void @ext_byval_func_alignedstruct(%AlignedStruct* byval %ptr)
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: byval_param
|
|
define void @byval_param(%SmallStruct* byval align 32 %ptr) {
|
|
; CHECK: .param i32
|
|
; %ptr is just a pointer to a struct, so pass it directly through
|
|
; CHECK: call ext_func@FUNCTION, $0
|
|
call void @ext_func(%SmallStruct* %ptr)
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: byval_empty_caller
|
|
define void @byval_empty_caller(%EmptyStruct* %ptr) {
|
|
; CHECK: .param i32
|
|
; CHECK: call ext_byval_func_empty@FUNCTION, $0
|
|
call void @ext_byval_func_empty(%EmptyStruct* byval %ptr)
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: byval_empty_callee
|
|
define void @byval_empty_callee(%EmptyStruct* byval %ptr) {
|
|
; CHECK: .param i32
|
|
; CHECK: call ext_func_empty@FUNCTION, $0
|
|
call void @ext_func_empty(%EmptyStruct* %ptr)
|
|
ret void
|
|
}
|
|
|
|
; Call memcpy for "big" byvals.
|
|
; CHECK-LABEL: big_byval:
|
|
; CHECK: i32.const $push[[L4:.+]]=, __stack_pointer
|
|
; CHECK: i32.const $push[[L1:.+]]=, __stack_pointer
|
|
; CHECK-NEXT: i32.load $push[[L2:.+]]=, 0($pop[[L1]])
|
|
; CHECK-NEXT: i32.const $push[[L3:.+]]=, 131072
|
|
; CHECK-NEXT: i32.sub $push[[L8:.+]]=, $pop[[L2]], $pop[[L3]]
|
|
; CHECK-NEXT: i32.store $push[[L12:.+]]=, 0($pop[[L4]]), $pop[[L8]]{{$}}
|
|
; CHECK-NEXT: i32.const $push[[L0:.+]]=, 131072
|
|
; CHECK-NEXT: i32.call $push[[L11:.+]]=, memcpy@FUNCTION, $pop{{.+}}, ${{.+}}, $pop{{.+}}
|
|
; CHECK-NEXT: tee_local $push[[L9:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}}
|
|
; CHECK-NEXT: call big_byval_callee@FUNCTION,
|
|
%big = type [131072 x i8]
|
|
declare void @big_byval_callee(%big* byval align 1)
|
|
define void @big_byval(%big* byval align 1 %x) {
|
|
call void @big_byval_callee(%big* byval align 1 %x)
|
|
ret void
|
|
}
|