mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-24 03:33:20 +01:00
a0e8011216
Summary:
This change adds some verification in the IR verifier around struct path
TBAA metadata.
Other than some basic sanity checks (e.g. we get constant integers where
we expect constant integers), this checks:
- That by the time an struct access tuple `(base-type, offset)` is
"reduced" to a scalar base type, the offset is `0`. For instance, in
C++ you can't start from, say `("struct-a", 16)`, and end up with
`("int", 4)` -- by the time the base type is `"int"`, the offset
better be zero. In particular, a variant of this invariant is needed
for `llvm::getMostGenericTBAA` to be correct.
- That there are no cycles in a struct path.
- That struct type nodes have their offsets listed in an ascending
order.
- That when generating the struct access path, you eventually reach the
access type listed in the tbaa tag node.
Reviewers: dexonsmith, chandlerc, reames, mehdi_amini, manmanren
Subscribers: mcrosier, llvm-commits
Differential Revision: https://reviews.llvm.org/D26438
llvm-svn: 289402
130 lines
3.2 KiB
LLVM
130 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, i32* %q, !tbaa !10
|
|
store i32 15, i32* %p
|
|
%b = load i32, 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, i32* %q, !tbaa !10
|
|
call void @clobber()
|
|
%b = load i32, 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"}
|
|
!3 = !{!7, !7, i64 0}
|
|
!4 = !{!11, !11, i64 0}
|
|
!5 = !{!"C", !6}
|
|
!6 = !{!"A", !2}
|
|
!7 = !{!"B", !6}
|
|
!8 = !{!"another root"}
|
|
!11 = !{!"scalar type", !8}
|
|
|
|
|
|
;; A TBAA structure who's only point is to have a constant location
|
|
!9 = !{!"yet another root"}
|
|
!10 = !{!"node", !9, i64 1}
|
|
|