RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-16 08:27:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6b494b30f2
llvm/test/Transforms/NewGVN/assume-equal.ll
Piotr Padlewski 4e1eef1855 [Devirtualization] MemDep returns non-local !invariant.group dependencies 
Summary:
Memory Dependence Analysis was limited to return only local dependencies
for invariant.group handling. Now it returns NonLocal when it finds it
and then by asking getNonLocalPointerDependency we get found dep.

Thanks to this we are able to devirtualize loops!

    void indirect(A &a, int n) {
      for (int i = 0 ; i < n; i++)
        a.foo();

    }
    void test(int n) {
      A a;
      indirect(a);
    }

After inlining a.foo() will be changed to direct call, even if foo and A::A()
is external (but only if vtable definition is be available).

Reviewers: nlewycky, dberlin, chandlerc, rsmith

Subscribers: mehdi_amini, davide, llvm-commits

Differential Revision: https://reviews.llvm.org/D28137

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@291762 91177308-0d34-0410-b5e6-96231b3b80d8
2017-01-12 11:33:58 +00:00

275 lines
8.3 KiB
LLVM
Raw Blame History

; XFAIL: *
; RUN: opt < %s -newgvn -S | FileCheck %s
%struct.A = type { i32 (...)** }
@_ZTV1A = available_externally unnamed_addr constant [4 x i8*] [i8* null, i8* bitcast (i8** @_ZTI1A to i8*), i8* bitcast (i32 (%struct.A*)* @_ZN1A3fooEv to i8*), i8* bitcast (i32 (%struct.A*)* @_ZN1A3barEv to i8*)], align 8
@_ZTI1A = external constant i8*
; Checks if indirect calls can be replaced with direct
; assuming that %vtable == @_ZTV1A (with alignment).
; Checking const propagation across other BBs
; CHECK-LABEL: define void @_Z1gb(
define void @_Z1gb(i1 zeroext %p) {
entry:
%call = tail call noalias i8* @_Znwm(i64 8) #4
%0 = bitcast i8* %call to %struct.A*
tail call void @_ZN1AC1Ev(%struct.A* %0) #1
%1 = bitcast i8* %call to i8***
%vtable = load i8**, i8*** %1, align 8
%cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([4 x i8*], [4 x i8*]* @_ZTV1A, i64 0, i64 2)
tail call void @llvm.assume(i1 %cmp.vtables)
br i1 %p, label %if.then, label %if.else
if.then: ; preds = %entry
%vtable1.cast = bitcast i8** %vtable to i32 (%struct.A*)**
%2 = load i32 (%struct.A*)*, i32 (%struct.A*)** %vtable1.cast, align 8
; CHECK: call i32 @_ZN1A3fooEv(
%call2 = tail call i32 %2(%struct.A* %0) #1
br label %if.end
if.else: ; preds = %entry
%vfn47 = getelementptr inbounds i8*, i8** %vtable, i64 1
%vfn4 = bitcast i8** %vfn47 to i32 (%struct.A*)**
; CHECK: call i32 @_ZN1A3barEv(
%3 = load i32 (%struct.A*)*, i32 (%struct.A*)** %vfn4, align 8
%call5 = tail call i32 %3(%struct.A* %0) #1
br label %if.end
if.end: ; preds = %if.else, %if.then
ret void
}
; Check integration with invariant.group handling
; CHECK-LABEL: define void @invariantGroupHandling(i1 zeroext %p) {
define void @invariantGroupHandling(i1 zeroext %p) {
entry:
%call = tail call noalias i8* @_Znwm(i64 8) #4
%0 = bitcast i8* %call to %struct.A*
tail call void @_ZN1AC1Ev(%struct.A* %0) #1
%1 = bitcast i8* %call to i8***
%vtable = load i8**, i8*** %1, align 8, !invariant.group !0
%cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([4 x i8*], [4 x i8*]* @_ZTV1A, i64 0, i64 2)
tail call void @llvm.assume(i1 %cmp.vtables)
br i1 %p, label %if.then, label %if.else
if.then: ; preds = %entry
%vtable1.cast = bitcast i8** %vtable to i32 (%struct.A*)**
%2 = load i32 (%struct.A*)*, i32 (%struct.A*)** %vtable1.cast, align 8
; CHECK: call i32 @_ZN1A3fooEv(
%call2 = tail call i32 %2(%struct.A* %0) #1
%vtable1 = load i8**, i8*** %1, align 8, !invariant.group !0
%vtable2.cast = bitcast i8** %vtable1 to i32 (%struct.A*)**
%call1 = load i32 (%struct.A*)*, i32 (%struct.A*)** %vtable2.cast, align 8
; CHECK: call i32 @_ZN1A3fooEv(
%callx = tail call i32 %call1(%struct.A* %0) #1
%vtable2 = load i8**, i8*** %1, align 8, !invariant.group !0
%vtable3.cast = bitcast i8** %vtable2 to i32 (%struct.A*)**
%call4 = load i32 (%struct.A*)*, i32 (%struct.A*)** %vtable3.cast, align 8
; CHECK: call i32 @_ZN1A3fooEv(
%cally = tail call i32 %call4(%struct.A* %0) #1
%b = bitcast i8* %call to %struct.A**
%vtable3 = load %struct.A*, %struct.A** %b, align 8, !invariant.group !0
%vtable4.cast = bitcast %struct.A* %vtable3 to i32 (%struct.A*)**
%vfun = load i32 (%struct.A*)*, i32 (%struct.A*)** %vtable4.cast, align 8
; CHECK: call i32 @_ZN1A3fooEv(
%unknown = tail call i32 %vfun(%struct.A* %0) #1
br label %if.end
if.else: ; preds = %entry
%vfn47 = getelementptr inbounds i8*, i8** %vtable, i64 1
%vfn4 = bitcast i8** %vfn47 to i32 (%struct.A*)**
; CHECK: call i32 @_ZN1A3barEv(
%3 = load i32 (%struct.A*)*, i32 (%struct.A*)** %vfn4, align 8
%call5 = tail call i32 %3(%struct.A* %0) #1
br label %if.end
if.end: ; preds = %if.else, %if.then
ret void
}
; Checking const propagation in the same BB
; CHECK-LABEL: define i32 @main()
define i32 @main() {
entry:
%call = tail call noalias i8* @_Znwm(i64 8)
%0 = bitcast i8* %call to %struct.A*
tail call void @_ZN1AC1Ev(%struct.A* %0)
%1 = bitcast i8* %call to i8***
%vtable = load i8**, i8*** %1, align 8
%cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([4 x i8*], [4 x i8*]* @_ZTV1A, i64 0, i64 2)
tail call void @llvm.assume(i1 %cmp.vtables)
%vtable1.cast = bitcast i8** %vtable to i32 (%struct.A*)**
; CHECK: call i32 @_ZN1A3fooEv(
%2 = load i32 (%struct.A*)*, i32 (%struct.A*)** %vtable1.cast, align 8
%call2 = tail call i32 %2(%struct.A* %0)
ret i32 0
}
; This tests checks const propatation with fcmp instruction.
; CHECK-LABEL: define float @_Z1gf(float %p)
define float @_Z1gf(float %p) {
entry:
%p.addr = alloca float, align 4
%f = alloca float, align 4
store float %p, float* %p.addr, align 4
store float 3.000000e+00, float* %f, align 4
%0 = load float, float* %p.addr, align 4
%1 = load float, float* %f, align 4
%cmp = fcmp oeq float %1, %0 ; note const on lhs
call void @llvm.assume(i1 %cmp)
; CHECK: ret float 3.000000e+00
ret float %0
}
; CHECK-LABEL: define float @_Z1hf(float %p)
define float @_Z1hf(float %p) {
entry:
%p.addr = alloca float, align 4
store float %p, float* %p.addr, align 4
%0 = load float, float* %p.addr, align 4
%cmp = fcmp nnan ueq float %0, 3.000000e+00
call void @llvm.assume(i1 %cmp)
; CHECK: ret float 3.000000e+00
ret float %0
}
; CHECK-LABEL: define float @_Z1if(float %p)
define float @_Z1if(float %p) {
entry:
%p.addr = alloca float, align 4
store float %p, float* %p.addr, align 4
%0 = load float, float* %p.addr, align 4
%cmp = fcmp ueq float %0, 3.000000e+00 ; no nnan flag - can't propagate
call void @llvm.assume(i1 %cmp)
; CHECK-NOT: ret float 3.000000e+00
ret float %0
}
; This test checks if constant propagation works for multiple node edges
; CHECK-LABEL: define i32 @_Z1ii(i32 %p)
define i32 @_Z1ii(i32 %p) {
entry:
%cmp = icmp eq i32 %p, 42
call void @llvm.assume(i1 %cmp)
; CHECK: br i1 true, label %bb2, label %bb2
br i1 %cmp, label %bb2, label %bb2
bb2:
call void @llvm.assume(i1 true)
; CHECK: br i1 true, label %bb2, label %bb2
br i1 %cmp, label %bb2, label %bb2
; CHECK: ret i32 42
ret i32 %p
}
; CHECK-LABEL: define i32 @_Z1ij(i32 %p)
define i32 @_Z1ij(i32 %p) {
entry:
%cmp = icmp eq i32 %p, 42
call void @llvm.assume(i1 %cmp)
; CHECK: br i1 true, label %bb2, label %bb2
br i1 %cmp, label %bb2, label %bb2
bb2:
; CHECK-NOT: %cmp2 =
%cmp2 = icmp eq i32 %p, 42
; CHECK-NOT: call void @llvm.assume(
call void @llvm.assume(i1 %cmp2)
; CHECK: br i1 true, label %bb2, label %bb2
br i1 %cmp, label %bb2, label %bb2
; CHECK: ret i32 42
ret i32 %p
}
; CHECK-LABEL: define i32 @_Z1ik(i32 %p)
define i32 @_Z1ik(i32 %p) {
entry:
%cmp = icmp eq i32 %p, 42
call void @llvm.assume(i1 %cmp)
; CHECK: br i1 true, label %bb2, label %bb3
br i1 %cmp, label %bb2, label %bb3
bb2:
; CHECK-NOT: %cmp3 =
%cmp3 = icmp eq i32 %p, 43
; CHECK: store i8 undef, i8* null
call void @llvm.assume(i1 %cmp3)
ret i32 15
bb3:
ret i32 17
}
; This test checks if GVN can do the constant propagation correctly
; when there are multiple uses of the same assume value in the
; basic block that has a loop back-edge pointing to itself.
;
; CHECK-LABEL: define i32 @_Z1il(i32 %val, i1 %k)
define i32 @_Z1il(i32 %val, i1 %k) {
br label %next
next:
; CHECK: tail call void @llvm.assume(i1 %k)
; CHECK-NEXT: %cmp = icmp eq i32 %val, 50
tail call void @llvm.assume(i1 %k)
tail call void @llvm.assume(i1 %k)
%cmp = icmp eq i32 %val, 50
br i1 %cmp, label %next, label %meh
meh:
ret i32 0
}
; This test checks if GVN can prevent the constant propagation correctly
; in the successor blocks that are not dominated by the basic block
; with the assume instruction.
;
; CHECK-LABEL: define i1 @_z1im(i32 %val, i1 %k, i1 %j)
define i1 @_z1im(i32 %val, i1 %k, i1 %j) {
br i1 %j, label %next, label %meh
next:
; CHECK: tail call void @llvm.assume(i1 %k)
; CHECK-NEXT: br label %meh
tail call void @llvm.assume(i1 %k)
tail call void @llvm.assume(i1 %k)
br label %meh
meh:
; CHECK: ret i1 %k
ret i1 %k
}
declare noalias i8* @_Znwm(i64)
declare void @_ZN1AC1Ev(%struct.A*)
declare void @llvm.assume(i1)
declare i32 @_ZN1A3fooEv(%struct.A*)
declare i32 @_ZN1A3barEv(%struct.A*)
!0 = !{!"struct A"}
Reference in New Issue View Git Blame Copy Permalink