RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-26 04:32:44 +01:00
Code Issues Projects Releases Wiki Activity
6eb7829d59
llvm-mirror/test/CodeGen/WebAssembly/reg-stackify.ll

454 lines
15 KiB
LLVM
Raw Normal View History

[WebAssembly] Reintroduce ARGUMENT moving logic Reinteroduce the code for moving ARGUMENTS back to the top of the basic block. While the ARGUMENTS physical register prevents sinking and scheduling from moving them, it does not appear to be sufficient to prevent SelectionDAG from moving them down in the initial schedule. This patch introduces a patch that moves them back to the top immediately after SelectionDAG runs. This is still hopefully a temporary solution. http://reviews.llvm.org/D14750 is one alternative, though the review has not been favorable, and proposed alternatives are longer-term and have other downsides. This fixes the main outstanding -verify-machineinstrs failures, so it adds -verify-machineinstrs to several tests. Differential Revision: http://reviews.llvm.org/D15377 llvm-svn: 255125
2015-12-09 17:23:59 +01:00
; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s
[WebAssembly] Support for register stackifying with load and store instructions. llvm-svn: 254076
2015-11-25 17:55:01 +01:00
; Test the register stackifier pass.
[WebAssembly] Add -m:e to the target triple. This enables ELF-style name mangling, which primarily means using ".L" for private symbols. llvm-svn: 257020
2016-01-07 04:19:23 +01:00
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
[WebAssembly] Support for register stackifying with load and store instructions. llvm-svn: 254076
2015-11-25 17:55:01 +01:00
target triple = "wasm32-unknown-unknown"
; No because of pointer aliasing.
; CHECK-LABEL: no0:
; CHECK: return $1{{$}}
define i32 @no0(i32* %p, i32* %q) {
%t = load i32, i32* %q
store i32 0, i32* %p
ret i32 %t
}
; No because of side effects.
; CHECK-LABEL: no1:
; CHECK: return $1{{$}}
define i32 @no1(i32* %p, i32* dereferenceable(4) %q) {
%t = load volatile i32, i32* %q, !invariant.load !0
store volatile i32 0, i32* %p
ret i32 %t
}
; Yes because of invariant load and no side effects.
; CHECK-LABEL: yes0:
; CHECK: return $pop0{{$}}
define i32 @yes0(i32* %p, i32* dereferenceable(4) %q) {
%t = load i32, i32* %q, !invariant.load !0
store i32 0, i32* %p
ret i32 %t
}
; Yes because of no intervening side effects.
; CHECK-LABEL: yes1:
; CHECK: return $pop0{{$}}
define i32 @yes1(i32* %q) {
%t = load volatile i32, i32* %q
ret i32 %t
}
[WebAssembly] Improve the precision of memory and side effect dependence tracking. MachineInstr::isSafeToMove is more conservative than is needed here; use a more explicit check, and incorporate knowledge of some WebAssembly-specific opcodes. llvm-svn: 269736
2016-05-17 06:05:31 +02:00
; Yes because undefined behavior can be sunk past a store.
; CHECK-LABEL: sink_trap:
; CHECK: return $pop0{{$}}
define i32 @sink_trap(i32 %x, i32 %y, i32* %p) {
%t = sdiv i32 %x, %y
store volatile i32 0, i32* %p
ret i32 %t
}
; Yes because the call is readnone.
; CHECK-LABEL: sink_readnone_call:
; CHECK: return $pop0{{$}}
declare i32 @readnone_callee() readnone nounwind
define i32 @sink_readnone_call(i32 %x, i32 %y, i32* %p) {
%t = call i32 @readnone_callee()
store volatile i32 0, i32* %p
ret i32 %t
}
; No because the call is readonly and there's an intervening store.
; CHECK-LABEL: no_sink_readonly_call:
; CHECK: return ${{[0-9]+}}{{$}}
declare i32 @readonly_callee() readonly nounwind
define i32 @no_sink_readonly_call(i32 %x, i32 %y, i32* %p) {
%t = call i32 @readonly_callee()
store i32 0, i32* %p
ret i32 %t
}
[WebAssembly] Fix scheduling dependencies in register-stackified code Add physical register defs to instructions used from stackified instructions to prevent them from being scheduled into the middle of a stack sequence. This is a conservative measure which may be loosened in the future. Differential Revision: http://reviews.llvm.org/D15252 llvm-svn: 254811
2015-12-05 01:51:40 +01:00
; Don't schedule stack uses into the stack. To reduce register pressure, the
; scheduler might be tempted to move the definition of $2 down. However, this
; would risk getting incorrect liveness if the instructions are later
; rearranged to make the stack contiguous.
; CHECK-LABEL: stack_uses:
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
; CHECK: .param i32, i32, i32, i32{{$}}
[WebAssembly] Fix scheduling dependencies in register-stackified code Add physical register defs to instructions used from stackified instructions to prevent them from being scheduled into the middle of a stack sequence. This is a conservative measure which may be loosened in the future. Differential Revision: http://reviews.llvm.org/D15252 llvm-svn: 254811
2015-12-05 01:51:40 +01:00
; CHECK-NEXT: .result i32{{$}}
[WebAssembly] Make CFG stackification independent of basic-block labels. This patch changes the way labels are referenced. Instead of referencing the basic-block label name (eg. .LBB0_0), instructions now just have an immediate which indicates the depth in the control-flow stack to find a label to jump to. This makes them much closer to what we expect to have in the binary encoding, and avoids the problem of basic-block label names not being explicit in the binary encoding. Also, it terminates blocks and loops with end_block and end_loop instructions, rather than basic-block label names, for similar reasons. This will also fix problems where two constructs appear to have the same label, because we no longer explicitly use labels, so consumers that need labels will presumably create their own labels, and presumably they won't reuse labels when they do. This patch does make the code a little more awkward to read; as a partial mitigation, this patch also introduces comments showing where the labels are, and comments on each branch showing where it's branching to. llvm-svn: 257505
2016-01-12 20:14:46 +01:00
; CHECK-NEXT: block{{$}}
[WebAssembly] Rematerialize constants rather than hold them live in registers. Teach the register stackifier to rematerialize constants that have multiple uses instead of leaving them in registers. In the WebAssembly encoding, it's the same code size to materialize most constants as it is to read a value from a register. llvm-svn: 258142
2016-01-19 17:59:23 +01:00
; CHECK-NEXT: i32.const $push13=, 1{{$}}
; CHECK-NEXT: i32.lt_s $push0=, $0, $pop13{{$}}
; CHECK-NEXT: i32.const $push1=, 2{{$}}
; CHECK-NEXT: i32.lt_s $push2=, $1, $pop1{{$}}
; CHECK-NEXT: i32.xor $push5=, $pop0, $pop2{{$}}
; CHECK-NEXT: i32.const $push12=, 1{{$}}
; CHECK-NEXT: i32.lt_s $push3=, $2, $pop12{{$}}
; CHECK-NEXT: i32.const $push11=, 2{{$}}
; CHECK-NEXT: i32.lt_s $push4=, $3, $pop11{{$}}
; CHECK-NEXT: i32.xor $push6=, $pop3, $pop4{{$}}
; CHECK-NEXT: i32.xor $push7=, $pop5, $pop6{{$}}
; CHECK-NEXT: i32.const $push10=, 1{{$}}
; CHECK-NEXT: i32.ne $push8=, $pop7, $pop10{{$}}
[WebAssembly] Update the br_if instructions' operand orders to match the spec. llvm-svn: 260152
2016-02-08 22:50:13 +01:00
; CHECK-NEXT: br_if 0, $pop8{{$}}
[WebAssembly] Rematerialize constants rather than hold them live in registers. Teach the register stackifier to rematerialize constants that have multiple uses instead of leaving them in registers. In the WebAssembly encoding, it's the same code size to materialize most constants as it is to read a value from a register. llvm-svn: 258142
2016-01-19 17:59:23 +01:00
; CHECK-NEXT: i32.const $push9=, 0{{$}}
; CHECK-NEXT: return $pop9{{$}}
[WebAssembly] Improve the precision of memory and side effect dependence tracking. MachineInstr::isSafeToMove is more conservative than is needed here; use a more explicit check, and incorporate knowledge of some WebAssembly-specific opcodes. llvm-svn: 269736
2016-05-17 06:05:31 +02:00
; CHECK-NEXT: .LBB7_2:
[WebAssembly] Make CFG stackification independent of basic-block labels. This patch changes the way labels are referenced. Instead of referencing the basic-block label name (eg. .LBB0_0), instructions now just have an immediate which indicates the depth in the control-flow stack to find a label to jump to. This makes them much closer to what we expect to have in the binary encoding, and avoids the problem of basic-block label names not being explicit in the binary encoding. Also, it terminates blocks and loops with end_block and end_loop instructions, rather than basic-block label names, for similar reasons. This will also fix problems where two constructs appear to have the same label, because we no longer explicitly use labels, so consumers that need labels will presumably create their own labels, and presumably they won't reuse labels when they do. This patch does make the code a little more awkward to read; as a partial mitigation, this patch also introduces comments showing where the labels are, and comments on each branch showing where it's branching to. llvm-svn: 257505
2016-01-12 20:14:46 +01:00
; CHECK-NEXT: end_block{{$}}
[WebAssembly] Rematerialize constants rather than hold them live in registers. Teach the register stackifier to rematerialize constants that have multiple uses instead of leaving them in registers. In the WebAssembly encoding, it's the same code size to materialize most constants as it is to read a value from a register. llvm-svn: 258142
2016-01-19 17:59:23 +01:00
; CHECK-NEXT: i32.const $push14=, 1{{$}}
; CHECK-NEXT: return $pop14{{$}}
[WebAssembly] Implement ReverseBranchCondition, and re-enable MachineBlockPlacement This patch introduces a codegen-only instruction currently named br_unless, which makes it convenient to implement ReverseBranchCondition and re-enable the MachineBlockPlacement pass. Then in a late pass, it lowers br_unless back into br_if. Differential Revision: http://reviews.llvm.org/D14995 llvm-svn: 254826
2015-12-05 04:03:35 +01:00
define i32 @stack_uses(i32 %x, i32 %y, i32 %z, i32 %w) {
[WebAssembly] Fix scheduling dependencies in register-stackified code Add physical register defs to instructions used from stackified instructions to prevent them from being scheduled into the middle of a stack sequence. This is a conservative measure which may be loosened in the future. Differential Revision: http://reviews.llvm.org/D15252 llvm-svn: 254811
2015-12-05 01:51:40 +01:00
entry:
[WebAssembly] Implement ReverseBranchCondition, and re-enable MachineBlockPlacement This patch introduces a codegen-only instruction currently named br_unless, which makes it convenient to implement ReverseBranchCondition and re-enable the MachineBlockPlacement pass. Then in a late pass, it lowers br_unless back into br_if. Differential Revision: http://reviews.llvm.org/D14995 llvm-svn: 254826
2015-12-05 04:03:35 +01:00
%c = icmp sle i32 %x, 0
%d = icmp sle i32 %y, 1
%e = icmp sle i32 %z, 0
%f = icmp sle i32 %w, 1
%g = xor i1 %c, %d
%h = xor i1 %e, %f
%i = xor i1 %g, %h
br i1 %i, label %true, label %false
[WebAssembly] Fix scheduling dependencies in register-stackified code Add physical register defs to instructions used from stackified instructions to prevent them from being scheduled into the middle of a stack sequence. This is a conservative measure which may be loosened in the future. Differential Revision: http://reviews.llvm.org/D15252 llvm-svn: 254811
2015-12-05 01:51:40 +01:00
true:
ret i32 0
false:
ret i32 1
}
[WebAssembly] Fix handling of COPY instructions in WebAssemblyRegStackify. Move RegStackify after coalescing and teach it to use LiveIntervals instead of depending on SSA form. This avoids a problem where a register in a COPY instruction is stackified and then subsequently coalesced with a register that is not stackified. This also puts it after the scheduler, which allows us to simplify the EXPR_STACK constraint, as we no longer have instructions being reordered after stackification and before coloring. llvm-svn: 256402
2015-12-25 01:31:02 +01:00
; Test an interesting case where the load has multiple uses and cannot
[WebAssembly] Enhanced register stackification This patch revamps the RegStackifier pass with a new tree traversal mechanism, enabling three major new features: - Stackification of values with multiple uses, using the result value of set_local - More aggressive stackification of instructions with side effects - Reordering operands in commutative instructions to enable more stackification. llvm-svn: 259009
2016-01-28 02:22:44 +01:00
; be trivially stackified. However, it can be stackified with a tee_local.
[WebAssembly] Fix handling of COPY instructions in WebAssemblyRegStackify. Move RegStackify after coalescing and teach it to use LiveIntervals instead of depending on SSA form. This avoids a problem where a register in a COPY instruction is stackified and then subsequently coalesced with a register that is not stackified. This also puts it after the scheduler, which allows us to simplify the EXPR_STACK constraint, as we no longer have instructions being reordered after stackification and before coloring. llvm-svn: 256402
2015-12-25 01:31:02 +01:00
; CHECK-LABEL: multiple_uses:
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
; CHECK: .param i32, i32, i32{{$}}
[WebAssembly] Make CFG stackification independent of basic-block labels. This patch changes the way labels are referenced. Instead of referencing the basic-block label name (eg. .LBB0_0), instructions now just have an immediate which indicates the depth in the control-flow stack to find a label to jump to. This makes them much closer to what we expect to have in the binary encoding, and avoids the problem of basic-block label names not being explicit in the binary encoding. Also, it terminates blocks and loops with end_block and end_loop instructions, rather than basic-block label names, for similar reasons. This will also fix problems where two constructs appear to have the same label, because we no longer explicitly use labels, so consumers that need labels will presumably create their own labels, and presumably they won't reuse labels when they do. This patch does make the code a little more awkward to read; as a partial mitigation, this patch also introduces comments showing where the labels are, and comments on each branch showing where it's branching to. llvm-svn: 257505
2016-01-12 20:14:46 +01:00
; CHECK-NEXT: .local i32{{$}}
; CHECK-NEXT: block{{$}}
[WebAssembly] Create new registers instead of reusing old ones in RegStackify. This avoids some complications updating LiveIntervals to be aware of the new register lifetimes, because we can just compute new intervals from scratch rather than describe how the old ones have been changed. llvm-svn: 260971
2016-02-16 16:17:21 +01:00
; CHECK-NEXT: i32.load $push[[NUM0:[0-9]+]]=, 0($2){{$}}
; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $3=, $pop[[NUM0]]{{$}}
; CHECK-NEXT: i32.ge_u $push[[NUM2:[0-9]+]]=, $pop[[NUM1]], $1{{$}}
; CHECK-NEXT: br_if 0, $pop[[NUM2]]{{$}}
; CHECK-NEXT: i32.lt_u $push[[NUM3:[0-9]+]]=, $3, $0{{$}}
; CHECK-NEXT: br_if 0, $pop[[NUM3]]{{$}}
[WebAssembly] Fix handling of COPY instructions in WebAssemblyRegStackify. Move RegStackify after coalescing and teach it to use LiveIntervals instead of depending on SSA form. This avoids a problem where a register in a COPY instruction is stackified and then subsequently coalesced with a register that is not stackified. This also puts it after the scheduler, which allows us to simplify the EXPR_STACK constraint, as we no longer have instructions being reordered after stackification and before coloring. llvm-svn: 256402
2015-12-25 01:31:02 +01:00
; CHECK-NEXT: i32.store $discard=, 0($2), $3{{$}}
[WebAssembly] Improve the precision of memory and side effect dependence tracking. MachineInstr::isSafeToMove is more conservative than is needed here; use a more explicit check, and incorporate knowledge of some WebAssembly-specific opcodes. llvm-svn: 269736
2016-05-17 06:05:31 +02:00
; CHECK-NEXT: .LBB8_3:
[WebAssembly] Make CFG stackification independent of basic-block labels. This patch changes the way labels are referenced. Instead of referencing the basic-block label name (eg. .LBB0_0), instructions now just have an immediate which indicates the depth in the control-flow stack to find a label to jump to. This makes them much closer to what we expect to have in the binary encoding, and avoids the problem of basic-block label names not being explicit in the binary encoding. Also, it terminates blocks and loops with end_block and end_loop instructions, rather than basic-block label names, for similar reasons. This will also fix problems where two constructs appear to have the same label, because we no longer explicitly use labels, so consumers that need labels will presumably create their own labels, and presumably they won't reuse labels when they do. This patch does make the code a little more awkward to read; as a partial mitigation, this patch also introduces comments showing where the labels are, and comments on each branch showing where it's branching to. llvm-svn: 257505
2016-01-12 20:14:46 +01:00
; CHECK-NEXT: end_block{{$}}
[WebAssembly] Fix handling of COPY instructions in WebAssemblyRegStackify. Move RegStackify after coalescing and teach it to use LiveIntervals instead of depending on SSA form. This avoids a problem where a register in a COPY instruction is stackified and then subsequently coalesced with a register that is not stackified. This also puts it after the scheduler, which allows us to simplify the EXPR_STACK constraint, as we no longer have instructions being reordered after stackification and before coloring. llvm-svn: 256402
2015-12-25 01:31:02 +01:00
; CHECK-NEXT: return{{$}}
define void @multiple_uses(i32* %arg0, i32* %arg1, i32* %arg2) nounwind {
bb:
br label %loop
loop:
%tmp7 = load i32, i32* %arg2
%tmp8 = inttoptr i32 %tmp7 to i32*
%tmp9 = icmp uge i32* %tmp8, %arg1
%tmp10 = icmp ult i32* %tmp8, %arg0
%tmp11 = or i1 %tmp9, %tmp10
br i1 %tmp11, label %back, label %then
then:
store i32 %tmp7, i32* %arg2
br label %back
back:
br i1 undef, label %return, label %loop
return:
ret void
}
[WebAssembly] Don't stackify stores across instructions with side effects. llvm-svn: 258285
2016-01-20 05:21:16 +01:00
; Don't stackify stores effects across other instructions with side effects.
; CHECK: side_effects:
; CHECK: store
; CHECK-NEXT: call
; CHECK-NEXT: store
; CHECK-NEXT: call
declare void @evoke_side_effects()
define hidden void @stackify_store_across_side_effects(double* nocapture %d) {
entry:
store double 2.0, double* %d
call void @evoke_side_effects()
store double 2.0, double* %d
call void @evoke_side_effects()
ret void
}
[WebAssembly] Enhanced register stackification This patch revamps the RegStackifier pass with a new tree traversal mechanism, enabling three major new features: - Stackification of values with multiple uses, using the result value of set_local - More aggressive stackification of instructions with side effects - Reordering operands in commutative instructions to enable more stackification. llvm-svn: 259009
2016-01-28 02:22:44 +01:00
; Div instructions have side effects and can't be reordered, but this entire
; function should still be able to be stackified because it's already in
; tree order.
; CHECK-LABEL: div_tree:
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
; CHECK: .param i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32{{$}}
[WebAssembly] Enhanced register stackification This patch revamps the RegStackifier pass with a new tree traversal mechanism, enabling three major new features: - Stackification of values with multiple uses, using the result value of set_local - More aggressive stackification of instructions with side effects - Reordering operands in commutative instructions to enable more stackification. llvm-svn: 259009
2016-01-28 02:22:44 +01:00
; CHECK-NEXT: .result i32{{$}}
; CHECK-NEXT: i32.div_s $push0=, $0, $1
; CHECK-NEXT: i32.div_s $push1=, $2, $3
; CHECK-NEXT: i32.div_s $push2=, $pop0, $pop1
; CHECK-NEXT: i32.div_s $push3=, $4, $5
; CHECK-NEXT: i32.div_s $push4=, $6, $7
; CHECK-NEXT: i32.div_s $push5=, $pop3, $pop4
; CHECK-NEXT: i32.div_s $push6=, $pop2, $pop5
; CHECK-NEXT: i32.div_s $push7=, $8, $9
; CHECK-NEXT: i32.div_s $push8=, $10, $11
; CHECK-NEXT: i32.div_s $push9=, $pop7, $pop8
; CHECK-NEXT: i32.div_s $push10=, $12, $13
; CHECK-NEXT: i32.div_s $push11=, $14, $15
; CHECK-NEXT: i32.div_s $push12=, $pop10, $pop11
; CHECK-NEXT: i32.div_s $push13=, $pop9, $pop12
; CHECK-NEXT: i32.div_s $push14=, $pop6, $pop13
; CHECK-NEXT: return $pop14
define i32 @div_tree(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, i32 %j, i32 %k, i32 %l, i32 %m, i32 %n, i32 %o, i32 %p) {
entry:
%div = sdiv i32 %a, %b
%div1 = sdiv i32 %c, %d
%div2 = sdiv i32 %div, %div1
%div3 = sdiv i32 %e, %f
%div4 = sdiv i32 %g, %h
%div5 = sdiv i32 %div3, %div4
%div6 = sdiv i32 %div2, %div5
%div7 = sdiv i32 %i, %j
%div8 = sdiv i32 %k, %l
%div9 = sdiv i32 %div7, %div8
%div10 = sdiv i32 %m, %n
%div11 = sdiv i32 %o, %p
%div12 = sdiv i32 %div10, %div11
%div13 = sdiv i32 %div9, %div12
%div14 = sdiv i32 %div6, %div13
ret i32 %div14
}
; A simple multiple-use case.
; CHECK-LABEL: simple_multiple_use:
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
; CHECK: .param i32, i32{{$}}
[WebAssembly] Create new registers instead of reusing old ones in RegStackify. This avoids some complications updating LiveIntervals to be aware of the new register lifetimes, because we can just compute new intervals from scratch rather than describe how the old ones have been changed. llvm-svn: 260971
2016-02-16 16:17:21 +01:00
; CHECK-NEXT: i32.mul $push[[NUM0:[0-9]+]]=, $1, $0{{$}}
[WebAssembly] Move register stackification and coloring to a late phase. 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
2016-05-10 06:24:02 +02:00
; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}}
[WebAssembly] Create new registers instead of reusing old ones in RegStackify. This avoids some complications updating LiveIntervals to be aware of the new register lifetimes, because we can just compute new intervals from scratch rather than describe how the old ones have been changed. llvm-svn: 260971
2016-02-16 16:17:21 +01:00
; CHECK-NEXT: call use_a@FUNCTION, $pop[[NUM1]]{{$}}
[WebAssembly] Move register stackification and coloring to a late phase. 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
2016-05-10 06:24:02 +02:00
; CHECK-NEXT: call use_b@FUNCTION, $[[NUM2]]{{$}}
[WebAssembly] Enhanced register stackification This patch revamps the RegStackifier pass with a new tree traversal mechanism, enabling three major new features: - Stackification of values with multiple uses, using the result value of set_local - More aggressive stackification of instructions with side effects - Reordering operands in commutative instructions to enable more stackification. llvm-svn: 259009
2016-01-28 02:22:44 +01:00
; CHECK-NEXT: return{{$}}
declare void @use_a(i32)
declare void @use_b(i32)
define void @simple_multiple_use(i32 %x, i32 %y) {
%mul = mul i32 %y, %x
call void @use_a(i32 %mul)
call void @use_b(i32 %mul)
ret void
}
; Multiple uses of the same value in one instruction.
; CHECK-LABEL: multiple_uses_in_same_insn:
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
; CHECK: .param i32, i32{{$}}
[WebAssembly] Create new registers instead of reusing old ones in RegStackify. This avoids some complications updating LiveIntervals to be aware of the new register lifetimes, because we can just compute new intervals from scratch rather than describe how the old ones have been changed. llvm-svn: 260971
2016-02-16 16:17:21 +01:00
; CHECK-NEXT: i32.mul $push[[NUM0:[0-9]+]]=, $1, $0{{$}}
[WebAssembly] Move register stackification and coloring to a late phase. 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
2016-05-10 06:24:02 +02:00
; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}}
; CHECK-NEXT: call use_2@FUNCTION, $pop[[NUM1]], $[[NUM2]]{{$}}
[WebAssembly] Enhanced register stackification This patch revamps the RegStackifier pass with a new tree traversal mechanism, enabling three major new features: - Stackification of values with multiple uses, using the result value of set_local - More aggressive stackification of instructions with side effects - Reordering operands in commutative instructions to enable more stackification. llvm-svn: 259009
2016-01-28 02:22:44 +01:00
; CHECK-NEXT: return{{$}}
declare void @use_2(i32, i32)
define void @multiple_uses_in_same_insn(i32 %x, i32 %y) {
%mul = mul i32 %y, %x
call void @use_2(i32 %mul, i32 %mul)
ret void
}
; Commute operands to achieve better stackifying.
; CHECK-LABEL: commute:
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
; CHECK-NOT: param
; CHECK: .result i32{{$}}
[WebAssembly] Enhanced register stackification This patch revamps the RegStackifier pass with a new tree traversal mechanism, enabling three major new features: - Stackification of values with multiple uses, using the result value of set_local - More aggressive stackification of instructions with side effects - Reordering operands in commutative instructions to enable more stackification. llvm-svn: 259009
2016-01-28 02:22:44 +01:00
; CHECK-NEXT: i32.call $push0=, red@FUNCTION{{$}}
; CHECK-NEXT: i32.call $push1=, green@FUNCTION{{$}}
; CHECK-NEXT: i32.add $push2=, $pop0, $pop1{{$}}
; CHECK-NEXT: i32.call $push3=, blue@FUNCTION{{$}}
; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}}
; CHECK-NEXT: return $pop4{{$}}
declare i32 @red()
declare i32 @green()
declare i32 @blue()
define i32 @commute() {
%call = call i32 @red()
%call1 = call i32 @green()
%add = add i32 %call1, %call
%call2 = call i32 @blue()
%add3 = add i32 %add, %call2
ret i32 %add3
}
[WebAssembly] Don't stackify a register def past a get_local use in the same tree. llvm-svn: 259013
2016-01-28 04:59:09 +01:00
; Don't stackify a register when it would move a the def of the register past
; an implicit get_local for the register.
; CHECK-LABEL: no_stackify_past_use:
; CHECK: i32.call $1=, callee@FUNCTION, $0
; CHECK: i32.const $push0=, 1
; CHECK: i32.add $push1=, $0, $pop0
; CHECK: i32.call $push2=, callee@FUNCTION, $pop1
; CHECK: i32.add $push3=, $1, $pop2
; CHECK: i32.mul $push4=, $1, $pop3
; CHECK: return $pop4
declare i32 @callee(i32)
define i32 @no_stackify_past_use(i32 %arg) {
%tmp1 = call i32 @callee(i32 %arg)
%tmp2 = add i32 %arg, 1
%tmp3 = call i32 @callee(i32 %tmp2)
%tmp5 = add i32 %tmp3, %tmp1
%tmp6 = mul i32 %tmp5, %tmp1
ret i32 %tmp6
}
[WebAssembly] Create new registers instead of reusing old ones in RegStackify. This avoids some complications updating LiveIntervals to be aware of the new register lifetimes, because we can just compute new intervals from scratch rather than describe how the old ones have been changed. llvm-svn: 260971
2016-02-16 16:17:21 +01:00
; Stackify individual defs of virtual registers with multiple defs.
; CHECK-LABEL: multiple_defs:
; CHECK: f64.add $push[[NUM0:[0-9]+]]=, ${{[0-9]+}}, $pop{{[0-9]+}}{{$}}
; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}}
; CHECK-NEXT: f64.select $push{{[0-9]+}}=, $pop{{[0-9]+}}, $pop[[NUM1]], ${{[0-9]+}}{{$}}
; CHECK: $[[NUM2]]=,
define void @multiple_defs(i32 %arg, i32 %arg1, i1 %arg2, i1 %arg3, i1 %arg4) {
bb:
br label %bb5
bb5: ; preds = %bb21, %bb
%tmp = phi double [ 0.000000e+00, %bb ], [ %tmp22, %bb21 ]
%tmp6 = phi double [ 0.000000e+00, %bb ], [ %tmp23, %bb21 ]
%tmp7 = fcmp olt double %tmp6, 2.323450e+01
br i1 %tmp7, label %bb8, label %bb21
bb8: ; preds = %bb17, %bb5
%tmp9 = phi double [ %tmp19, %bb17 ], [ %tmp, %bb5 ]
%tmp10 = fadd double %tmp6, -1.000000e+00
%tmp11 = select i1 %arg2, double -1.135357e+04, double %tmp10
%tmp12 = fadd double %tmp11, %tmp9
br i1 %arg3, label %bb17, label %bb13
bb13: ; preds = %bb8
%tmp14 = or i32 %arg1, 2
%tmp15 = icmp eq i32 %tmp14, 14
%tmp16 = select i1 %tmp15, double -1.135357e+04, double 0xBFCE147AE147B000
br label %bb17
bb17: ; preds = %bb13, %bb8
%tmp18 = phi double [ %tmp16, %bb13 ], [ %tmp10, %bb8 ]
%tmp19 = fadd double %tmp18, %tmp12
%tmp20 = fcmp olt double %tmp6, 2.323450e+01
br i1 %tmp20, label %bb8, label %bb21
bb21: ; preds = %bb17, %bb5
%tmp22 = phi double [ %tmp, %bb5 ], [ %tmp9, %bb17 ]
%tmp23 = fadd double %tmp6, 1.000000e+00
br label %bb5
}
[WebAssemly] Don't move calls or stores past intervening loads The register stackifier currently checks for intervening stores (and loads that may alias them) but doesn't account for the fact that the instruction being moved may affect intervening loads. Differential Revision: http://reviews.llvm.org/D17298 llvm-svn: 261014
2016-02-16 22:44:19 +01:00
; Don't move calls past loads
; CHECK-LABEL: no_stackify_call_past_load:
; CHECK: i32.call $0=, red
; CHECK: i32.const $push0=, 0
; CHECK: i32.load $1=, count($pop0)
@count = hidden global i32 0, align 4
define i32 @no_stackify_call_past_load() {
%a = call i32 @red()
%b = load i32, i32* @count, align 4
call i32 @callee(i32 %a)
ret i32 %b
; use of a
}
; Don't move stores past loads if there may be aliasing
; CHECK-LABEL: no_stackify_store_past_load
[WebAssembly] Move register stackification and coloring to a late phase. 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
2016-05-10 06:24:02 +02:00
; CHECK: i32.store $[[L0:[0-9]+]]=, 0($1), $0
[WebAssemly] Don't move calls or stores past intervening loads The register stackifier currently checks for intervening stores (and loads that may alias them) but doesn't account for the fact that the instruction being moved may affect intervening loads. Differential Revision: http://reviews.llvm.org/D17298 llvm-svn: 261014
2016-02-16 22:44:19 +01:00
; CHECK: i32.load {{.*}}, 0($2)
[WebAssembly] Move register stackification and coloring to a late phase. 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
2016-05-10 06:24:02 +02:00
; CHECK: i32.call {{.*}}, callee@FUNCTION, $[[L0]]{{$}}
[WebAssemly] Don't move calls or stores past intervening loads The register stackifier currently checks for intervening stores (and loads that may alias them) but doesn't account for the fact that the instruction being moved may affect intervening loads. Differential Revision: http://reviews.llvm.org/D17298 llvm-svn: 261014
2016-02-16 22:44:19 +01:00
define i32 @no_stackify_store_past_load(i32 %a, i32* %p1, i32* %p2) {
store i32 %a, i32* %p1
%b = load i32, i32* %p2, align 4
call i32 @callee(i32 %a)
ret i32 %b
}
; Can still stackify past invariant loads.
; CHECK-LABEL: store_past_invar_load
; CHECK: i32.store $push{{.*}}, 0($1), $0
; CHECK: i32.call {{.*}}, callee@FUNCTION, $pop
; CHECK: i32.load $push{{.*}}, 0($2)
; CHECK: return $pop
define i32 @store_past_invar_load(i32 %a, i32* %p1, i32* dereferenceable(4) %p2) {
store i32 %a, i32* %p1
%b = load i32, i32* %p2, !invariant.load !0
call i32 @callee(i32 %a)
ret i32 %b
}
[WebAssembly] Properly ignore llvm.dbg.value instructions. llvm-svn: 261538
2016-02-22 18:45:20 +01:00
; CHECK-LABEL: ignore_dbg_value:
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
; CHECK-NEXT: .Lfunc_begin
[WebAssembly] Properly ignore llvm.dbg.value instructions. llvm-svn: 261538
2016-02-22 18:45:20 +01:00
; CHECK-NEXT: unreachable
declare void @llvm.dbg.value(metadata, i64, metadata, metadata)
define void @ignore_dbg_value() {
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
call void @llvm.dbg.value(metadata i32 0, i64 0, metadata !7, metadata !9), !dbg !10
[WebAssembly] Properly ignore llvm.dbg.value instructions. llvm-svn: 261538
2016-02-22 18:45:20 +01:00
unreachable
}
[WebAssembly] Don't emit epilogue code in the middle of stackified code. llvm-svn: 268679
2016-05-05 22:41:15 +02:00
; Don't stackify an expression that might use the stack into a return, since we
; might insert a prologue before the return.
; CHECK-LABEL: no_stackify_past_epilogue:
; CHECK: return ${{[0-9]+}}{{$}}
declare i32 @use_memory(i32*)
define i32 @no_stackify_past_epilogue() {
%x = alloca i32
%call = call i32 @use_memory(i32* %x)
ret i32 %call
}
[WebAssembly] Stackify induction variable increment instructions. This handles instructions where the defined register is also used, as in "x = x + 1". llvm-svn: 269830
2016-05-17 22:19:47 +02:00
; Stackify a loop induction variable into a loop comparison.
[WebAssembly] Don't stackify calls past stack pointer modifications. llvm-svn: 269843
2016-05-17 23:14:26 +02:00
; CHECK-LABEL: stackify_indvar:
[WebAssembly] Stackify induction variable increment instructions. This handles instructions where the defined register is also used, as in "x = x + 1". llvm-svn: 269830
2016-05-17 22:19:47 +02:00
; CHECK: i32.const $push[[L5:.+]]=, 1{{$}}
; CHECK-NEXT: i32.add $push[[L4:.+]]=, $[[R0:.+]], $pop[[L5]]{{$}}
; CHECK-NEXT: tee_local $push[[L3:.+]]=, $[[R0]]=, $pop[[L4]]{{$}}
; CHECK-NEXT: i32.ne $push[[L2:.+]]=, $0, $pop[[L3]]{{$}}
define void @stackify_indvar(i32 %tmp, i32* %v) #0 {
bb:
br label %bb3
bb3: ; preds = %bb3, %bb2
%tmp4 = phi i32 [ %tmp7, %bb3 ], [ 0, %bb ]
%tmp5 = load volatile i32, i32* %v, align 4
%tmp6 = add nsw i32 %tmp5, %tmp4
store volatile i32 %tmp6, i32* %v, align 4
%tmp7 = add nuw nsw i32 %tmp4, 1
%tmp8 = icmp eq i32 %tmp7, %tmp
br i1 %tmp8, label %bb10, label %bb3
bb10: ; preds = %bb9, %bb
ret void
}
[WebAssembly] Don't stackify calls past stack pointer modifications. llvm-svn: 269843
2016-05-17 23:14:26 +02:00
; Don't stackify a call past a __stack_pointer store.
; CHECK-LABEL: stackpointer_dependency:
; CHECK: call {{.+}}, stackpointer_callee@FUNCTION,
; CHECK: i32.const $push[[L0:.+]]=, __stack_pointer
; CHECK-NEXT: i32.store $discard=, 0($pop[[L0]]),
declare i32 @stackpointer_callee(i8* readnone, i8* readnone)
declare i8* @llvm.frameaddress(i32)
define i32 @stackpointer_dependency(i8* readnone) {
%2 = tail call i8* @llvm.frameaddress(i32 0)
%3 = tail call i32 @stackpointer_callee(i8* %0, i8* %2)
ret i32 %3
}
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
!llvm.module.flags = !{!0}
!llvm.dbg.cu = !{!1}
!0 = !{i32 2, !"Debug Info Version", i32 3}
Update testcase to new debug metadata format. llvm-svn: 266467
2016-04-15 21:32:22 +02:00
!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.9.0 (trunk 266005) (llvm/trunk 266105)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !3)
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
!2 = !DIFile(filename: "test.c", directory: "/")
!3 = !{}
Let the DISubprogram in this test point to the right compile unit. llvm-svn: 266468
2016-04-15 21:38:14 +02:00
!5 = distinct !DISubprogram(name: "test", scope: !2, file: !2, line: 10, type: !6, isLocal: false, isDefinition: true, scopeLine: 11, flags: DIFlagPrototyped, isOptimized: true, unit: !1, variables: !3)
[WebAssembly] Fix debug info in reg-stackify.ll test It lacked a CU and thus became invalid with r266102 llvm-svn: 266114
2016-04-12 22:12:05 +02:00
!6 = !DISubroutineType(types: !3)
!7 = !DILocalVariable(name: "nzcnt", scope: !5, file: !2, line: 15, type: !8)
!8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
!9 = !DIExpression()
!10 = !DILocation(line: 15, column: 6, scope: !5)
Reference in New Issue Copy Permalink