mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-27 13:30:05 +00:00
8a5ad05c13
This change is mostly motivated by exposing information about the original query instruction to the actual scanning work in getPointerDependencyFrom when used by GVN PRE. In a follow up change, I will use this to be more precise with regards to the semantics of volatile instructions encountered in the scan of a basic block. Worth noting, is that this change (despite appearing quite simple) is not semantically preserving. By providing more information to the helper routine, we allow some optimizations to kick in that weren't previously able to (when called from this code path.) In particular, we see that treatment of !invariant.load becomes more precise. In theory, we might see a difference with an ordered/atomic instruction as well, but I'm having a hard time actually finding a test case which shows that. Test wise, I've included new tests for !invariant.load which illustrate this difference. I've also included some updated TBAA tests which highlight that this change isn't needed for that optimization to kick in - it's handled inside alias analysis itself. Eventually, it would be nice to factor the !invariant.load handling inside alias analysis as well. Differential Revision: http://reviews.llvm.org/D6895 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@227110 91177308-0d34-0410-b5e6-96231b3b80d8
129 lines
3.2 KiB
LLVM
129 lines
3.2 KiB
LLVM
; RUN: opt -tbaa -basicaa -gvn -S < %s | FileCheck %s
|
|
|
|
define i32 @test1(i8* %p, i8* %q) {
|
|
; CHECK: @test1(i8* %p, i8* %q)
|
|
; CHECK: call i32 @foo(i8* %p)
|
|
; CHECK-NOT: tbaa
|
|
; CHECK: %c = add i32 %a, %a
|
|
%a = call i32 @foo(i8* %p), !tbaa !0
|
|
%b = call i32 @foo(i8* %p)
|
|
%c = add i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
define i32 @test2(i8* %p, i8* %q) {
|
|
; CHECK: @test2(i8* %p, i8* %q)
|
|
; CHECK: call i32 @foo(i8* %p), !tbaa [[TAGC:!.*]]
|
|
; CHECK: %c = add i32 %a, %a
|
|
%a = call i32 @foo(i8* %p), !tbaa !0
|
|
%b = call i32 @foo(i8* %p), !tbaa !0
|
|
%c = add i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
define i32 @test3(i8* %p, i8* %q) {
|
|
; CHECK: @test3(i8* %p, i8* %q)
|
|
; CHECK: call i32 @foo(i8* %p), !tbaa [[TAGB:!.*]]
|
|
; CHECK: %c = add i32 %a, %a
|
|
%a = call i32 @foo(i8* %p), !tbaa !3
|
|
%b = call i32 @foo(i8* %p), !tbaa !3
|
|
%c = add i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
define i32 @test4(i8* %p, i8* %q) {
|
|
; CHECK: @test4(i8* %p, i8* %q)
|
|
; CHECK: call i32 @foo(i8* %p), !tbaa [[TAGA:!.*]]
|
|
; CHECK: %c = add i32 %a, %a
|
|
%a = call i32 @foo(i8* %p), !tbaa !1
|
|
%b = call i32 @foo(i8* %p), !tbaa !0
|
|
%c = add i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
define i32 @test5(i8* %p, i8* %q) {
|
|
; CHECK: @test5(i8* %p, i8* %q)
|
|
; CHECK: call i32 @foo(i8* %p), !tbaa [[TAGA:!.*]]
|
|
; CHECK: %c = add i32 %a, %a
|
|
%a = call i32 @foo(i8* %p), !tbaa !0
|
|
%b = call i32 @foo(i8* %p), !tbaa !1
|
|
%c = add i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
define i32 @test6(i8* %p, i8* %q) {
|
|
; CHECK: @test6(i8* %p, i8* %q)
|
|
; CHECK: call i32 @foo(i8* %p), !tbaa [[TAGA:!.*]]
|
|
; CHECK: %c = add i32 %a, %a
|
|
%a = call i32 @foo(i8* %p), !tbaa !0
|
|
%b = call i32 @foo(i8* %p), !tbaa !3
|
|
%c = add i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
define i32 @test7(i8* %p, i8* %q) {
|
|
; CHECK: @test7(i8* %p, i8* %q)
|
|
; CHECK: call i32 @foo(i8* %p)
|
|
; CHECK-NOT: tbaa
|
|
; CHECK: %c = add i32 %a, %a
|
|
%a = call i32 @foo(i8* %p), !tbaa !4
|
|
%b = call i32 @foo(i8* %p), !tbaa !3
|
|
%c = add i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
|
|
|
|
define i32 @test8(i32* %p, i32* %q) {
|
|
; CHECK-LABEL: test8
|
|
; CHECK-NEXT: store i32 15, i32* %p
|
|
; CHECK-NEXT: ret i32 0
|
|
; Since we know the location is invariant, we can forward the
|
|
; load across the potentially aliasing store.
|
|
|
|
%a = load i32* %q, !tbaa !10
|
|
store i32 15, i32* %p
|
|
%b = load i32* %q, !tbaa !10
|
|
%c = sub i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
define i32 @test9(i32* %p, i32* %q) {
|
|
; CHECK-LABEL: test9
|
|
; CHECK-NEXT: call void @clobber()
|
|
; CHECK-NEXT: ret i32 0
|
|
; Since we know the location is invariant, we can forward the
|
|
; load across the potentially aliasing store (within the call).
|
|
|
|
%a = load i32* %q, !tbaa !10
|
|
call void @clobber()
|
|
%b = load i32* %q, !tbaa !10
|
|
%c = sub i32 %a, %b
|
|
ret i32 %c
|
|
}
|
|
|
|
|
|
declare void @clobber()
|
|
declare i32 @foo(i8*) readonly
|
|
|
|
; CHECK: [[TAGC]] = !{[[TYPEC:!.*]], [[TYPEC]], i64 0}
|
|
; CHECK: [[TYPEC]] = !{!"C", [[TYPEA:!.*]]}
|
|
; CHECK: [[TYPEA]] = !{!"A", !{{.*}}}
|
|
; CHECK: [[TAGB]] = !{[[TYPEB:!.*]], [[TYPEB]], i64 0}
|
|
; CHECK: [[TYPEB]] = !{!"B", [[TYPEA]]}
|
|
; CHECK: [[TAGA]] = !{[[TYPEA]], [[TYPEA]], i64 0}
|
|
!0 = !{!5, !5, i64 0}
|
|
!1 = !{!6, !6, i64 0}
|
|
!2 = !{!"tbaa root", null}
|
|
!3 = !{!7, !7, i64 0}
|
|
!4 = !{!8, !8, i64 0}
|
|
!5 = !{!"C", !6}
|
|
!6 = !{!"A", !2}
|
|
!7 = !{!"B", !6}
|
|
!8 = !{!"another root", null}
|
|
|
|
|
|
;; A TBAA structure who's only point is to have a constant location
|
|
!9 = !{!"yet another root"}
|
|
!10 = !{!"node", !9, i64 1}
|
|
|