01859da84b
The pointsToConstantMemory() method returns true only if the memory pointed to by the memory location is globally invariant. However, the LLVM memory model also has the semantic notion of *locally-invariant*: memory that is known to be invariant for the life of the SSA value representing that pointer. The most common example of this is a pointer argument that is marked readonly noalias, which the Rust compiler frequently emits. It'd be desirable for LLVM to treat locally-invariant memory the same way as globally-invariant memory when it's safe to do so. This patch implements that, by introducing the concept of a *ModRefInfo mask*. A ModRefInfo mask is a bound on the Mod/Ref behavior of an instruction that writes to a memory location, based on the knowledge that the memory is globally-constant memory (in which case the mask is NoModRef) or locally-constant memory (in which case the mask is Ref). ModRefInfo values for an instruction can be combined with the ModRefInfo mask by simply using the & operator. Where appropriate, this patch has modified uses of pointsToConstantMemory() to instead examine the mask. The most notable optimization change I noticed with this patch is that now redundant loads from readonly noalias pointers can be eliminated across calls, even when the pointer is captured. Internally, before this patch, AliasAnalysis was assigning Ref to reads from constant memory; now AA can assign NoModRef, which is a tighter bound. Differential Revision: https://reviews.llvm.org/D136659
96 lines
2.4 KiB
LLVM
96 lines
2.4 KiB
LLVM
; RUN: opt < %s -passes=aa-eval -print-all-alias-modref-info 2>&1 | FileCheck %s
|
|
|
|
@c = constant [8 x i32] zeroinitializer
|
|
|
|
declare void @dummy()
|
|
|
|
declare void @foo(ptr)
|
|
|
|
; CHECK-LABEL: Function: basic
|
|
; CHECK: NoModRef: Ptr: i32* @c <-> call void @dummy()
|
|
define void @basic(ptr %p) {
|
|
call void @dummy()
|
|
load i32, ptr @c
|
|
ret void
|
|
}
|
|
|
|
; CHECK-LABEL: Function: recphi
|
|
; CHECK: NoModRef: Ptr: i32* %p <-> call void @dummy()
|
|
define void @recphi() {
|
|
entry:
|
|
br label %loop
|
|
|
|
loop:
|
|
%p = phi ptr [ @c, %entry ], [ %p.next, %loop ]
|
|
call void @dummy()
|
|
load i32, ptr %p
|
|
%p.next = getelementptr i32, ptr %p, i64 1
|
|
%c = icmp ne ptr %p.next, getelementptr (i32, ptr @c, i64 8)
|
|
br i1 %c, label %loop, label %exit
|
|
|
|
exit:
|
|
ret void
|
|
}
|
|
|
|
; Tests that readonly noalias implies !Mod.
|
|
;
|
|
; CHECK-LABEL: Function: readonly_noalias
|
|
; CHECK: Just Ref: Ptr: i32* %p <-> call void @foo(ptr %p)
|
|
define void @readonly_noalias(ptr readonly noalias %p) {
|
|
call void @foo(ptr %p)
|
|
load i32, ptr %p
|
|
ret void
|
|
}
|
|
|
|
; Tests that readnone noalias implies !Mod.
|
|
;
|
|
; CHECK-LABEL: Function: readnone_noalias
|
|
; CHECK: Just Ref: Ptr: i32* %p <-> call void @foo(ptr %p)
|
|
define void @readnone_noalias(ptr readnone noalias %p) {
|
|
call void @foo(ptr %p)
|
|
load i32, ptr %p
|
|
ret void
|
|
}
|
|
|
|
; Tests that writeonly noalias doesn't imply !Ref (since it's still possible
|
|
; to read from the object through other pointers if the pointer wasn't
|
|
; written).
|
|
;
|
|
; CHECK-LABEL: Function: writeonly_noalias
|
|
; CHECK: Both ModRef: Ptr: i32* %p <-> call void @foo(ptr %p)
|
|
define void @writeonly_noalias(ptr writeonly noalias %p) {
|
|
call void @foo(ptr %p)
|
|
load i32, ptr %p
|
|
ret void
|
|
}
|
|
|
|
; Tests that readonly doesn't imply !Mod without noalias.
|
|
;
|
|
; CHECK-LABEL: Function: just_readonly
|
|
; CHECK: Both ModRef: Ptr: i32* %p <-> call void @foo(ptr %p)
|
|
define void @just_readonly(ptr readonly %p) {
|
|
call void @foo(ptr %p)
|
|
load i32, ptr %p
|
|
ret void
|
|
}
|
|
|
|
; Tests that readnone doesn't imply !Mod without noalias.
|
|
;
|
|
; CHECK-LABEL: Function: just_readnone
|
|
; CHECK: Both ModRef: Ptr: i32* %p <-> call void @foo(ptr %p)
|
|
define void @just_readnone(ptr readnone %p) {
|
|
call void @foo(ptr %p)
|
|
load i32, ptr %p
|
|
ret void
|
|
}
|
|
|
|
; Tests that writeonly doesn't imply !Ref.
|
|
;
|
|
; CHECK-LABEL: Function: just_writeonly
|
|
; CHECK: Both ModRef: Ptr: i32* %p <-> call void @foo(ptr %p)
|
|
define void @just_writeonly(ptr writeonly %p) {
|
|
call void @foo(ptr %p)
|
|
load i32, ptr %p
|
|
ret void
|
|
}
|