maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/test/Transforms/GVNHoist/hoist-recursive-geps.ll

107 lines
3.6 KiB
LLVM
Raw Normal View History

[GVNHoist] Factor out reachability to search for anticipable instructions quickly Factor out the reachability such that multiple queries to find reachability of values are fast. This is based on finding the ANTIC points in the CFG which do not change during hoisting. The ANTIC points are basically the dominance-frontiers in the inverse graph. So we introduce a data structure (CHI nodes) to keep track of values flowing out of a basic block. We only do this for values with multiple occurrences in the function as they are the potential hoistable candidates. This patch allows us to hoist instructions to a basic block with >2 successors, as well as deal with infinite loops in a trivial way. Relevant test cases are added to show the functionality as well as regression fixes from PR32821. Regression from previous GVNHoist: We do not hoist fully redundant expressions because fully redundant expressions are already handled by NewGVN Differential Revision: https://reviews.llvm.org/D35918 Reviewers: dberlin, sebpop, gberry, llvm-svn: 313116
2017-09-13 13:28:03 +08:00
; RUN: opt -gvn-hoist -newgvn -gvn-hoist -S < %s | FileCheck %s
; Check that recursive GEPs are hoisted. Since hoisting creates
; fully redundant instructions, newgvn is run to remove them which then
; creates more opportunites for hoisting.
GVN-hoist: improve code generation for recursive GEPs When loading or storing in a field of a struct like "a.b.c", GVN is able to detect the equivalent expressions, and GVN-hoist would fail in the code generation. This is because the GEPs are not hoisted as scalar operations to avoid moving the GEPs too far from their ld/st instruction when the ld/st is not movable. So we end up having to generate code for the GEP of a ld/st when we move the ld/st. In the case of a GEP referring to another GEP as in "a.b.c" we need to code generate all the GEPs necessary to make all the operands available at the new location for the ld/st. With this patch we recursively walk through the GEP operands checking whether all operands are available, and in the case of a GEP operand, it recursively makes all its operands available. Code generation happens from the inner GEPs out until reaching the GEP that appears as an operand of the ld/st. Differential Revision: https://reviews.llvm.org/D22599 llvm-svn: 276841
2016-07-27 13:48:12 +08:00
; CHECK-LABEL: @fun
; CHECK: load
[GVNHoist] Factor out reachability to search for anticipable instructions quickly Factor out the reachability such that multiple queries to find reachability of values are fast. This is based on finding the ANTIC points in the CFG which do not change during hoisting. The ANTIC points are basically the dominance-frontiers in the inverse graph. So we introduce a data structure (CHI nodes) to keep track of values flowing out of a basic block. We only do this for values with multiple occurrences in the function as they are the potential hoistable candidates. This patch allows us to hoist instructions to a basic block with >2 successors, as well as deal with infinite loops in a trivial way. Relevant test cases are added to show the functionality as well as regression fixes from PR32821. Regression from previous GVNHoist: We do not hoist fully redundant expressions because fully redundant expressions are already handled by NewGVN Differential Revision: https://reviews.llvm.org/D35918 Reviewers: dberlin, sebpop, gberry, llvm-svn: 313116
2017-09-13 13:28:03 +08:00
; CHECK: fdiv
GVN-hoist: improve code generation for recursive GEPs When loading or storing in a field of a struct like "a.b.c", GVN is able to detect the equivalent expressions, and GVN-hoist would fail in the code generation. This is because the GEPs are not hoisted as scalar operations to avoid moving the GEPs too far from their ld/st instruction when the ld/st is not movable. So we end up having to generate code for the GEP of a ld/st when we move the ld/st. In the case of a GEP referring to another GEP as in "a.b.c" we need to code generate all the GEPs necessary to make all the operands available at the new location for the ld/st. With this patch we recursively walk through the GEP operands checking whether all operands are available, and in the case of a GEP operand, it recursively makes all its operands available. Code generation happens from the inner GEPs out until reaching the GEP that appears as an operand of the ld/st. Differential Revision: https://reviews.llvm.org/D22599 llvm-svn: 276841
2016-07-27 13:48:12 +08:00
; CHECK: load
; CHECK: load
; CHECK: load
; CHECK: fsub
; CHECK: fmul
[GVNHoist] Factor out reachability to search for anticipable instructions quickly Factor out the reachability such that multiple queries to find reachability of values are fast. This is based on finding the ANTIC points in the CFG which do not change during hoisting. The ANTIC points are basically the dominance-frontiers in the inverse graph. So we introduce a data structure (CHI nodes) to keep track of values flowing out of a basic block. We only do this for values with multiple occurrences in the function as they are the potential hoistable candidates. This patch allows us to hoist instructions to a basic block with >2 successors, as well as deal with infinite loops in a trivial way. Relevant test cases are added to show the functionality as well as regression fixes from PR32821. Regression from previous GVNHoist: We do not hoist fully redundant expressions because fully redundant expressions are already handled by NewGVN Differential Revision: https://reviews.llvm.org/D35918 Reviewers: dberlin, sebpop, gberry, llvm-svn: 313116
2017-09-13 13:28:03 +08:00
; CHECK: fsub
GVN-hoist: only hoist relevant scalar instructions Without this patch, GVN-hoist would think that a branch instruction is a scalar instruction and would try to value number it. The patch filters out all such kind of irrelevant instructions. A bit frustrating is that there is no easy way to discard all those very infrequent instructions, a bit like isa<TerminatorInst> that stands for a large family of instructions. I'm thinking that checking for those very infrequent other instructions would cost us more in compilation time than just letting those instructions getting numbered, so I'm still thinking that a simpler check: if (isa<TerminatorInst>(I)) return false; is better than listing all the other less frequent instructions. Differential Revision: https://reviews.llvm.org/D23929 llvm-svn: 282160
2016-09-22 22:45:40 +08:00
; CHECK: fmul
GVN-hoist: improve code generation for recursive GEPs When loading or storing in a field of a struct like "a.b.c", GVN is able to detect the equivalent expressions, and GVN-hoist would fail in the code generation. This is because the GEPs are not hoisted as scalar operations to avoid moving the GEPs too far from their ld/st instruction when the ld/st is not movable. So we end up having to generate code for the GEP of a ld/st when we move the ld/st. In the case of a GEP referring to another GEP as in "a.b.c" we need to code generate all the GEPs necessary to make all the operands available at the new location for the ld/st. With this patch we recursively walk through the GEP operands checking whether all operands are available, and in the case of a GEP operand, it recursively makes all its operands available. Code generation happens from the inner GEPs out until reaching the GEP that appears as an operand of the ld/st. Differential Revision: https://reviews.llvm.org/D22599 llvm-svn: 276841
2016-07-27 13:48:12 +08:00
; CHECK-NOT: fsub
; CHECK-NOT: fmul
%0 = type { double, double, double }
%1 = type { double, double, double }
%2 = type { %3, %1, %1 }
%3 = type { i32 (...)**, %4, %10*, %11, %11, %11, %11, %11, %11, %11, %11, %11 }
%4 = type { %5 }
%5 = type { %6 }
%6 = type { %7 }
%7 = type { %8 }
%8 = type { %9 }
%9 = type { i64, i64, i8* }
%10 = type <{ i32 (...)**, i32, [4 x i8] }>
%11 = type { [4 x [4 x double]] }
%12 = type <{ %1, %0, i32, [4 x i8] }>
%13 = type { %1, %0, %12, %3*, %14* }
%14 = type opaque
@d = external global %0, align 8
@p = external global %1, align 8
define zeroext i1 @fun(%2*, %12* dereferenceable(56), double*, %13*) {
%5 = alloca %2*, align 8
%6 = alloca %12*, align 8
%7 = alloca double*, align 8
%8 = alloca %13*, align 8
%9 = alloca double, align 8
%10 = alloca double, align 8
%11 = alloca double, align 8
%12 = alloca double, align 8
%13 = alloca double, align 8
%14 = alloca double, align 8
%15 = alloca double, align 8
store %2* %0, %2** %5, align 8
store %12* %1, %12** %6, align 8
store double* %2, double** %7, align 8
store %13* %3, %13** %8, align 8
%16 = load %2*, %2** %5, align 8
%17 = load double, double* getelementptr inbounds (%0, %0* @d, i32 0, i32 0), align 8
%18 = fdiv double 1.000000e+00, %17
store double %18, double* %15, align 8
%19 = load double, double* %15, align 8
%20 = fcmp oge double %19, 0.000000e+00
br i1 %20, label %21, label %36
; <label>:21: ; preds = %4
%22 = getelementptr inbounds %2, %2* %16, i32 0, i32 1
%23 = getelementptr inbounds %1, %1* %22, i32 0, i32 0
%24 = load double, double* %23, align 8
%25 = load double, double* getelementptr inbounds (%1, %1* @p, i32 0, i32 0), align 8
%26 = fsub double %24, %25
%27 = load double, double* %15, align 8
%28 = fmul double %26, %27
store double %28, double* %9, align 8
%29 = getelementptr inbounds %2, %2* %16, i32 0, i32 2
%30 = getelementptr inbounds %1, %1* %29, i32 0, i32 0
%31 = load double, double* %30, align 8
%32 = load double, double* getelementptr inbounds (%1, %1* @p, i32 0, i32 0), align 8
%33 = fsub double %31, %32
%34 = load double, double* %15, align 8
%35 = fmul double %33, %34
store double %35, double* %12, align 8
br label %51
; <label>:36: ; preds = %4
%37 = getelementptr inbounds %2, %2* %16, i32 0, i32 2
%38 = getelementptr inbounds %1, %1* %37, i32 0, i32 0
%39 = load double, double* %38, align 8
%40 = load double, double* getelementptr inbounds (%1, %1* @p, i32 0, i32 0), align 8
%41 = fsub double %39, %40
%42 = load double, double* %15, align 8
%43 = fmul double %41, %42
store double %43, double* %9, align 8
%44 = getelementptr inbounds %2, %2* %16, i32 0, i32 1
%45 = getelementptr inbounds %1, %1* %44, i32 0, i32 0
%46 = load double, double* %45, align 8
%47 = load double, double* getelementptr inbounds (%1, %1* @p, i32 0, i32 0), align 8
%48 = fsub double %46, %47
%49 = load double, double* %15, align 8
%50 = fmul double %48, %49
store double %50, double* %12, align 8
br label %51
; <label>:51: ; preds = %36, %21
%52 = load double, double* %12, align 8
%53 = load double, double* %9, align 8
%54 = fcmp olt double %52, %53
ret i1 %54
GVN-hoist: fix early exit logic The patch splits a complex && if condition into easier to read and understand logic. That wrong early exit condition was letting some instructions with not all operands available pass through when HoistingGeps was true. Differential Revision: https://reviews.llvm.org/D23174 llvm-svn: 277785
2016-08-05 07:49:05 +08:00
}