This is an archive of the discontinued LLVM Phabricator instance.

Differential D45419

Dissallow non-empty metadata for invariant.group
ClosedPublic

Authored by Prazek on Apr 8 2018, 1:09 PM.

Details

Reviewers
rsmith
sanjoy
amharc
kuhar
hfinkel
xbolva00
Commits
rGce358262eb7d: Dissallow non-empty metadata for invariant.group
rL332787: Dissallow non-empty metadata for invariant.group
Summary

This feature is not needed, but it might be usefull in the future
to use metadata to mark what which function should support it
(and strip it when not).

Diff Detail

Event Timeline

Prazek created this revision.Apr 8 2018, 1:09 PM
Herald added a subscriber: hiraditya. · View Herald TranscriptApr 8 2018, 1:09 PM
Harbormaster completed remote builds in B16867: Diff 141565.Apr 8 2018, 1:10 PM
amharc accepted this revision.May 3 2018, 4:32 AM

Looks good to me.

This revision is now accepted and ready to land.May 3 2018, 4:32 AM
Prazek added reviewers: hfinkel, xbolva00.May 16 2018, 12:50 PM
xbolva00 accepted this revision.May 16 2018, 1:18 PM

LG

Closed by commit rL332787: Dissallow non-empty metadata for invariant.group (authored by Prazek). · Explain WhyMay 18 2018, 4:57 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
docs/
11 lines
2 lines
lib/
Analysis/
6 lines
test/
Transforms/
CodeGenPrepare/
4 lines
GVN/
38 lines
GlobalOpt/
2 lines
NewGVN/
39 lines

Diff 141565

llvm/docs/LangRef.rst

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,308 Lines • ▼ Show 20 Lines.. code-block:: llvm
!0 = !{"loop_header_weight", i64 100} !0 = !{"loop_header_weight", i64 100}
Irreducible loop header weights are typically based on profile data. Irreducible loop header weights are typically based on profile data.
'``invariant.group``' Metadata '``invariant.group``' Metadata
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The experimental ``invariant.group`` metadata may be attached to The experimental ``invariant.group`` metadata may be attached to
``load``/``store`` instructions. ``load``/``store`` instructions referencing a single metadata with no entries.
The existence of the ``invariant.group`` metadata on the instruction tells The existence of the ``invariant.group`` metadata on the instruction tells
the optimizer that every ``load`` and ``store`` to the same pointer operand the optimizer that every ``load`` and ``store`` to the same pointer operand
within the same invariant group can be assumed to load or store the same can be assumed to load or store the same
value (but see the ``llvm.launder.invariant.group`` intrinsic which affects value (but see the ``llvm.launder.invariant.group`` intrinsic which affects
when two pointers are considered the same). Pointers returned by bitcast or when two pointers are considered the same). Pointers returned by bitcast or
getelementptr with only zero indices are considered the same. getelementptr with only zero indices are considered the same.
Examples: Examples:
.. code-block:: llvm .. code-block:: llvm
@unknownPtr = external global i8 @unknownPtr = external global i8
... ...
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr, !invariant.group !0 store i8 42, i8* %ptr, !invariant.group !0
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
%a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change %a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
%b = load i8, i8* %ptr, !invariant.group !1 ; Can't assume anything, because group changed
%newPtr = call i8* @getPointer(i8* %ptr) %newPtr = call i8* @getPointer(i8* %ptr)
%c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr %c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr
%unknownValue = load i8, i8* @unknownPtr %unknownValue = load i8, i8* @unknownPtr
store i8 %unknownValue, i8* %ptr, !invariant.group !0 ; Can assume that %unknownValue == 42 store i8 %unknownValue, i8* %ptr, !invariant.group !0 ; Can assume that %unknownValue == 42
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
%newPtr2 = call i8* @llvm.launder.invariant.group(i8* %ptr) %newPtr2 = call i8* @llvm.launder.invariant.group(i8* %ptr)
%d = load i8, i8* %newPtr2, !invariant.group !0 ; Can't step through launder.invariant.group to get value of %ptr %d = load i8, i8* %newPtr2, !invariant.group !0 ; Can't step through launder.invariant.group to get value of %ptr
... ...
declare void @foo(i8*) declare void @foo(i8*)
declare i8* @getPointer(i8*) declare i8* @getPointer(i8*)
declare i8* @llvm.launder.invariant.group(i8*) declare i8* @llvm.launder.invariant.group(i8*)
!0 = !{!"magic ptr"} !0 = !{}
!1 = !{!"other ptr"}
The invariant.group metadata must be dropped when replacing one pointer by The invariant.group metadata must be dropped when replacing one pointer by
another based on aliasing information. This is because invariant.group is tied another based on aliasing information. This is because invariant.group is tied
to the SSA value of the pointer operand. to the SSA value of the pointer operand.
.. code-block:: llvm .. code-block:: llvm
%v = load i8, i8* %x, !invariant.group !0 %v = load i8, i8* %x, !invariant.group !0
▲ Show 20 Lines • Show All 2,268 Lines • ▼ Show 20 Lines
The optional ``!invariant.load`` metadata must reference a single The optional ``!invariant.load`` metadata must reference a single
metadata name ``<index>`` corresponding to a metadata node with no metadata name ``<index>`` corresponding to a metadata node with no
entries. If a load instruction tagged with the ``!invariant.load`` entries. If a load instruction tagged with the ``!invariant.load``
metadata is executed, the optimizer may assume the memory location metadata is executed, the optimizer may assume the memory location
referenced by the load contains the same value at all points in the referenced by the load contains the same value at all points in the
program where the memory location is known to be dereferenceable. program where the memory location is known to be dereferenceable.
The optional ``!invariant.group`` metadata must reference a single metadata name The optional ``!invariant.group`` metadata must reference a single metadata name
``<index>`` corresponding to a metadata node. See ``invariant.group`` metadata. ``<index>`` corresponding to a metadata node with no entries.
See ``invariant.group`` metadata.
The optional ``!nonnull`` metadata must reference a single The optional ``!nonnull`` metadata must reference a single
metadata name ``<index>`` corresponding to a metadata node with no metadata name ``<index>`` corresponding to a metadata node with no
entries. The existence of the ``!nonnull`` metadata on the entries. The existence of the ``!nonnull`` metadata on the
instruction tells the optimizer that the value loaded is known to instruction tells the optimizer that the value loaded is known to
never be null. This is analogous to the ``nonnull`` attribute never be null. This is analogous to the ``nonnull`` attribute
on parameters and return values. This metadata can only be applied on parameters and return values. This metadata can only be applied
to loads of a pointer type. to loads of a pointer type.
▲ Show 20 Lines • Show All 6,989 Lines • Show Last 20 Lines

llvm/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
---------------------- ----------------------
* The signatures for the builtins @llvm.memcpy, @llvm.memmove, and @llvm.memset * The signatures for the builtins @llvm.memcpy, @llvm.memmove, and @llvm.memset
have changed. Alignment is no longer an argument, and are instead conveyed as have changed. Alignment is no longer an argument, and are instead conveyed as
parameter attributes. parameter attributes.
* invariant.group.barrier has been renamed to launder.invariant.group. * invariant.group.barrier has been renamed to launder.invariant.group.
* invariant.group metadata can now refer only empty metadata nodes.
Changes to the ARM Backend Changes to the ARM Backend
-------------------------- --------------------------
During this release ... During this release ...
Changes to the MIPS Target Changes to the MIPS Target
-------------------------- --------------------------
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/lib/Analysis/MemoryDependenceAnalysis.cpp

Show First 20 Lines • Show All 349 Lines • ▼ Show 20 LinesMemDepResult MemoryDependenceResults::getPointerDependencyFrom(
assert(InvariantGroupDependency.isUnknown() && assert(InvariantGroupDependency.isUnknown() &&
"InvariantGroupDependency should be only unknown at this point"); "InvariantGroupDependency should be only unknown at this point");
return SimpleDep; return SimpleDep;
} }
MemDepResult MemDepResult
MemoryDependenceResults::getInvariantGroupPointerDependency(LoadInst *LI, MemoryDependenceResults::getInvariantGroupPointerDependency(LoadInst *LI,
BasicBlock *BB) { BasicBlock *BB) {
auto *InvariantGroupMD = LI->getMetadata(LLVMContext::MD_invariant_group);
if (!InvariantGroupMD) if (!LI->getMetadata(LLVMContext::MD_invariant_group))
return MemDepResult::getUnknown(); return MemDepResult::getUnknown();
// Take the ptr operand after all casts and geps 0. This way we can search // Take the ptr operand after all casts and geps 0. This way we can search
// cast graph down only. // cast graph down only.
Value *LoadOperand = LI->getPointerOperand()->stripPointerCasts(); Value *LoadOperand = LI->getPointerOperand()->stripPointerCasts();
// It's is not safe to walk the use list of global value, because function // It's is not safe to walk the use list of global value, because function
// passes aren't allowed to look outside their functions. // passes aren't allowed to look outside their functions.
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines for (const Use &Us : Ptr->uses()) {
LoadOperandsQueue.push_back(U); LoadOperandsQueue.push_back(U);
continue; continue;
} }
// If we hit load/store with the same invariant.group metadata (and the // If we hit load/store with the same invariant.group metadata (and the
// same pointer operand) we can assume that value pointed by pointer // same pointer operand) we can assume that value pointed by pointer
// operand didn't change. // operand didn't change.
if ((isa<LoadInst>(U) || isa<StoreInst>(U)) && if ((isa<LoadInst>(U) || isa<StoreInst>(U)) &&
U->getMetadata(LLVMContext::MD_invariant_group) == InvariantGroupMD) U->getMetadata(LLVMContext::MD_invariant_group) != nullptr)
ClosestDependency = GetClosestDependency(ClosestDependency, U); ClosestDependency = GetClosestDependency(ClosestDependency, U);
} }
} }
if (!ClosestDependency) if (!ClosestDependency)
return MemDepResult::getUnknown(); return MemDepResult::getUnknown();
if (ClosestDependency->getParent() == BB) if (ClosestDependency->getParent() == BB)
return MemDepResult::getDef(ClosestDependency); return MemDepResult::getDef(ClosestDependency);
▲ Show 20 Lines • Show All 1,357 Lines • Show Last 20 Lines

llvm/test/Transforms/CodeGenPrepare/invariant.group.ll

; RUN: opt -codegenprepare -S < %s | FileCheck %s ; RUN: opt -codegenprepare -S < %s | FileCheck %s
@tmp = global i8 0 @tmp = global i8 0
; CHECK-LABEL: define void @foo() { ; CHECK-LABEL: define void @foo() {
define void @foo() { define void @foo() {
enter: enter:
; CHECK-NOT: !invariant.group ; CHECK-NOT: !invariant.group
; CHECK-NOT: @llvm.launder.invariant.group.p0i8( ; CHECK-NOT: @llvm.launder.invariant.group.p0i8(
; CHECK: %val = load i8, i8* @tmp, !tbaa ; CHECK: %val = load i8, i8* @tmp, !tbaa
%val = load i8, i8* @tmp, !invariant.group !0, !tbaa !{!1, !1, i64 0} %val = load i8, i8* @tmp, !invariant.group !0, !tbaa !{!1, !1, i64 0}
%ptr = call i8* @llvm.launder.invariant.group.p0i8(i8* @tmp) %ptr = call i8* @llvm.launder.invariant.group.p0i8(i8* @tmp)
; CHECK: store i8 42, i8* @tmp ; CHECK: store i8 42, i8* @tmp{{$}}
store i8 42, i8* %ptr, !invariant.group !0 store i8 42, i8* %ptr, !invariant.group !0
ret void ret void
} }
; CHECK-LABEL: } ; CHECK-LABEL: }
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)
!0 = !{!"something"} !0 = !{}
!1 = !{!"x", !0} !1 = !{!"x", !0}

llvm/test/Transforms/GVN/invariant.group.ll

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linesentry:
%0 = bitcast %struct.A** %a to i8* %0 = bitcast %struct.A** %a to i8*
%call = call i8* @getPointer(i8* null) %call = call i8* @getPointer(i8* null)
%1 = bitcast i8* %call to %struct.A* %1 = bitcast i8* %call to %struct.A*
call void @_ZN1AC1Ev(%struct.A* %1) call void @_ZN1AC1Ev(%struct.A* %1)
%2 = bitcast %struct.A* %1 to i8*** %2 = bitcast %struct.A* %1 to i8***
; CHECK: %vtable = load {{.*}} !invariant.group ; CHECK: %vtable = load {{.*}} !invariant.group
%vtable = load i8**, i8*** %2, align 8, !invariant.group !2 %vtable = load i8**, i8*** %2, align 8, !invariant.group !0
%cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2) %cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2)
call void @llvm.assume(i1 %cmp.vtables) call void @llvm.assume(i1 %cmp.vtables)
store %struct.A* %1, %struct.A** %a, align 8 store %struct.A* %1, %struct.A** %a, align 8
%3 = load %struct.A*, %struct.A** %a, align 8 %3 = load %struct.A*, %struct.A** %a, align 8
%4 = bitcast %struct.A* %3 to void (%struct.A*)*** %4 = bitcast %struct.A* %3 to void (%struct.A*)***
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
%vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !2 %vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !0
%vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0 %vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0
%5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8 %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
call void %5(%struct.A* %3) call void %5(%struct.A* %3)
%6 = load %struct.A*, %struct.A** %a, align 8 %6 = load %struct.A*, %struct.A** %a, align 8
%7 = bitcast %struct.A* %6 to void (%struct.A*)*** %7 = bitcast %struct.A* %6 to void (%struct.A*)***
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
%vtable2 = load void (%struct.A*)**, void (%struct.A*)*** %7, align 8, !invariant.group !2 %vtable2 = load void (%struct.A*)**, void (%struct.A*)*** %7, align 8, !invariant.group !0
%vfn3 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable2, i64 0 %vfn3 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable2, i64 0
%8 = load void (%struct.A*)*, void (%struct.A*)** %vfn3, align 8 %8 = load void (%struct.A*)*, void (%struct.A*)** %vfn3, align 8
call void %8(%struct.A* %6) call void %8(%struct.A* %6)
%9 = load %struct.A*, %struct.A** %a, align 8 %9 = load %struct.A*, %struct.A** %a, align 8
%10 = bitcast %struct.A* %9 to void (%struct.A*)*** %10 = bitcast %struct.A* %9 to void (%struct.A*)***
%vtable4 = load void (%struct.A*)**, void (%struct.A*)*** %10, align 8, !invariant.group !2 %vtable4 = load void (%struct.A*)**, void (%struct.A*)*** %10, align 8, !invariant.group !0
%vfn5 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable4, i64 0 %vfn5 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable4, i64 0
%11 = load void (%struct.A*)*, void (%struct.A*)** %vfn5, align 8 %11 = load void (%struct.A*)*, void (%struct.A*)** %vfn5, align 8
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
call void %11(%struct.A* %9) call void %11(%struct.A* %9)
%vtable5 = load i8**, i8*** %2, align 8, !invariant.group !2 %vtable5 = load i8**, i8*** %2, align 8, !invariant.group !0
%vfn6 = getelementptr inbounds i8*, i8** %vtable5, i64 0 %vfn6 = getelementptr inbounds i8*, i8** %vtable5, i64 0
%12 = bitcast i8** %vfn6 to void (%struct.A*)** %12 = bitcast i8** %vfn6 to void (%struct.A*)**
%13 = load void (%struct.A*)*, void (%struct.A*)** %12, align 8 %13 = load void (%struct.A*)*, void (%struct.A*)** %12, align 8
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
call void %13(%struct.A* %9) call void %13(%struct.A* %9)
ret void ret void
} }
; CHECK-LABEL: define void @combiningBitCastWithLoad() { ; CHECK-LABEL: define void @combiningBitCastWithLoad() {
define void @combiningBitCastWithLoad() { define void @combiningBitCastWithLoad() {
entry: entry:
%a = alloca %struct.A*, align 8 %a = alloca %struct.A*, align 8
%0 = bitcast %struct.A** %a to i8* %0 = bitcast %struct.A** %a to i8*
%call = call i8* @getPointer(i8* null) %call = call i8* @getPointer(i8* null)
%1 = bitcast i8* %call to %struct.A* %1 = bitcast i8* %call to %struct.A*
call void @_ZN1AC1Ev(%struct.A* %1) call void @_ZN1AC1Ev(%struct.A* %1)
%2 = bitcast %struct.A* %1 to i8*** %2 = bitcast %struct.A* %1 to i8***
; CHECK: %vtable = load {{.*}} !invariant.group ; CHECK: %vtable = load {{.*}} !invariant.group
%vtable = load i8**, i8*** %2, align 8, !invariant.group !2 %vtable = load i8**, i8*** %2, align 8, !invariant.group !0
%cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2) %cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2)
store %struct.A* %1, %struct.A** %a, align 8 store %struct.A* %1, %struct.A** %a, align 8
; CHECK-NOT: !invariant.group ; CHECK-NOT: !invariant.group
%3 = load %struct.A*, %struct.A** %a, align 8 %3 = load %struct.A*, %struct.A** %a, align 8
%4 = bitcast %struct.A* %3 to void (%struct.A*)*** %4 = bitcast %struct.A* %3 to void (%struct.A*)***
%vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !2 %vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !0
%vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0 %vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0
%5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8 %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
call void %5(%struct.A* %3) call void %5(%struct.A* %3)
ret void ret void
} }
; CHECK-LABEL:define void @loadCombine() { ; CHECK-LABEL:define void @loadCombine() {
define void @loadCombine() { define void @loadCombine() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[A:.*]] = load i8, i8* %ptr, !invariant.group ; CHECK: %[[A:.*]] = load i8, i8* %ptr, !invariant.group
%a = load i8, i8* %ptr, !invariant.group !0 %a = load i8, i8* %ptr, !invariant.group !0
; CHECK-NOT: load ; CHECK-NOT: load
%b = load i8, i8* %ptr, !invariant.group !1 %b = load i8, i8* %ptr, !invariant.group !0
; CHECK: call void @bar(i8 %[[A]]) ; CHECK: call void @bar(i8 %[[A]])
call void @bar(i8 %a) call void @bar(i8 %a)
; CHECK: call void @bar(i8 %[[A]]) ; CHECK: call void @bar(i8 %[[A]])
call void @bar(i8 %b) call void @bar(i8 %b)
ret void ret void
} }
; CHECK-LABEL: define void @loadCombine1() { ; CHECK-LABEL: define void @loadCombine1() {
define void @loadCombine1() { define void @loadCombine1() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[D:.*]] = load i8, i8* %ptr, !invariant.group ; CHECK: %[[D:.*]] = load i8, i8* %ptr, !invariant.group
%c = load i8, i8* %ptr %c = load i8, i8* %ptr
; CHECK-NOT: load ; CHECK-NOT: load
%d = load i8, i8* %ptr, !invariant.group !1 %d = load i8, i8* %ptr, !invariant.group !0
; CHECK: call void @bar(i8 %[[D]]) ; CHECK: call void @bar(i8 %[[D]])
call void @bar(i8 %c) call void @bar(i8 %c)
; CHECK: call void @bar(i8 %[[D]]) ; CHECK: call void @bar(i8 %[[D]])
call void @bar(i8 %d) call void @bar(i8 %d)
ret void ret void
} }
; CHECK-LABEL: define void @loadCombine2() { ; CHECK-LABEL: define void @loadCombine2() {
define void @loadCombine2() { define void @loadCombine2() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group ; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group
%e = load i8, i8* %ptr, !invariant.group !1 %e = load i8, i8* %ptr, !invariant.group !0
; CHECK-NOT: load ; CHECK-NOT: load
%f = load i8, i8* %ptr %f = load i8, i8* %ptr
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %e) call void @bar(i8 %e)
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %f) call void @bar(i8 %f)
ret void ret void
} }
; CHECK-LABEL: define void @loadCombine3() { ; CHECK-LABEL: define void @loadCombine3() {
define void @loadCombine3() { define void @loadCombine3() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group ![[OneMD:[0-9]]] ; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group
%e = load i8, i8* %ptr, !invariant.group !1 %e = load i8, i8* %ptr, !invariant.group !0
; CHECK-NOT: load ; CHECK-NOT: load
%f = load i8, i8* %ptr, !invariant.group !1 %f = load i8, i8* %ptr, !invariant.group !0
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %e) call void @bar(i8 %e)
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %f) call void @bar(i8 %f)
ret void ret void
} }
; CHECK-LABEL: define i8 @unoptimizable2() { ; CHECK-LABEL: define i8 @unoptimizable2() {
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
entry: entry:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr, !invariant.group !0 store i8 42, i8* %ptr, !invariant.group !0
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
%a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change %a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
; CHECK: call void @bar(i8 42) ; CHECK: call void @bar(i8 42)
call void @bar(i8 %a) call void @bar(i8 %a)
call void @foo(i8* %ptr)
%b = load i8, i8* %ptr, !invariant.group !1 ; Can't assume anything, because group changed
; CHECK: call void @bar(i8 %b)
call void @bar(i8 %b)
%newPtr = call i8* @getPointer(i8* %ptr) %newPtr = call i8* @getPointer(i8* %ptr)
%c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr %c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr
; CHECK: call void @bar(i8 %c) ; CHECK: call void @bar(i8 %c)
call void @bar(i8 %c) call void @bar(i8 %c)
%unknownValue = load i8, i8* @unknownPtr %unknownValue = load i8, i8* @unknownPtr
; FIXME: Can assume that %unknownValue == 42 ; FIXME: Can assume that %unknownValue == 42
; CHECK: store i8 %unknownValue, i8* %ptr, !invariant.group !0 ; CHECK: store i8 %unknownValue, i8* %ptr, !invariant.group !0
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.assume(i1 %cmp.vtables) #0 declare void @llvm.assume(i1 %cmp.vtables) #0
attributes #0 = { nounwind } attributes #0 = { nounwind }
; CHECK: ![[OneMD]] = !{!"other ptr"} !0 = !{}
!0 = !{!"magic ptr"} No newline at end of file
!1 = !{!"other ptr"}
!2 = !{!"vtable_of_a"}

llvm/test/Transforms/GlobalOpt/invariant.group.barrier.ll

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Linesentry:
%val2 = load i32, i32* @tmp3, !invariant.group !0 %val2 = load i32, i32* @tmp3, !invariant.group !0
ret void; ret void;
} }
declare void @changeTmp3ValAndCallBarrierInside() declare void @changeTmp3ValAndCallBarrierInside()
declare i8* @llvm.launder.invariant.group(i8*) declare i8* @llvm.launder.invariant.group(i8*)
!0 = !{!"something"} !0 = !{}

llvm/test/Transforms/NewGVN/invariant.group.ll

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Linesentry:
%0 = bitcast %struct.A** %a to i8* %0 = bitcast %struct.A** %a to i8*
%call = call i8* @getPointer(i8* null) %call = call i8* @getPointer(i8* null)
%1 = bitcast i8* %call to %struct.A* %1 = bitcast i8* %call to %struct.A*
call void @_ZN1AC1Ev(%struct.A* %1) call void @_ZN1AC1Ev(%struct.A* %1)
%2 = bitcast %struct.A* %1 to i8*** %2 = bitcast %struct.A* %1 to i8***
; CHECK: %vtable = load {{.*}} !invariant.group ; CHECK: %vtable = load {{.*}} !invariant.group
%vtable = load i8**, i8*** %2, align 8, !invariant.group !2 %vtable = load i8**, i8*** %2, align 8, !invariant.group !0
%cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2) %cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2)
call void @llvm.assume(i1 %cmp.vtables) call void @llvm.assume(i1 %cmp.vtables)
store %struct.A* %1, %struct.A** %a, align 8 store %struct.A* %1, %struct.A** %a, align 8
%3 = load %struct.A*, %struct.A** %a, align 8 %3 = load %struct.A*, %struct.A** %a, align 8
%4 = bitcast %struct.A* %3 to void (%struct.A*)*** %4 = bitcast %struct.A* %3 to void (%struct.A*)***
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
%vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !2 %vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !0
%vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0 %vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0
%5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8 %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
call void %5(%struct.A* %3) call void %5(%struct.A* %3)
%6 = load %struct.A*, %struct.A** %a, align 8 %6 = load %struct.A*, %struct.A** %a, align 8
%7 = bitcast %struct.A* %6 to void (%struct.A*)*** %7 = bitcast %struct.A* %6 to void (%struct.A*)***
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
%vtable2 = load void (%struct.A*)**, void (%struct.A*)*** %7, align 8, !invariant.group !2 %vtable2 = load void (%struct.A*)**, void (%struct.A*)*** %7, align 8, !invariant.group !0
%vfn3 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable2, i64 0 %vfn3 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable2, i64 0
%8 = load void (%struct.A*)*, void (%struct.A*)** %vfn3, align 8 %8 = load void (%struct.A*)*, void (%struct.A*)** %vfn3, align 8
call void %8(%struct.A* %6) call void %8(%struct.A* %6)
%9 = load %struct.A*, %struct.A** %a, align 8 %9 = load %struct.A*, %struct.A** %a, align 8
%10 = bitcast %struct.A* %9 to void (%struct.A*)*** %10 = bitcast %struct.A* %9 to void (%struct.A*)***
%vtable4 = load void (%struct.A*)**, void (%struct.A*)*** %10, align 8, !invariant.group !2 %vtable4 = load void (%struct.A*)**, void (%struct.A*)*** %10, align 8, !invariant.group !0
%vfn5 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable4, i64 0 %vfn5 = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable4, i64 0
%11 = load void (%struct.A*)*, void (%struct.A*)** %vfn5, align 8 %11 = load void (%struct.A*)*, void (%struct.A*)** %vfn5, align 8
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
call void %11(%struct.A* %9) call void %11(%struct.A* %9)
%vtable5 = load i8**, i8*** %2, align 8, !invariant.group !2 %vtable5 = load i8**, i8*** %2, align 8, !invariant.group !0
%vfn6 = getelementptr inbounds i8*, i8** %vtable5, i64 0 %vfn6 = getelementptr inbounds i8*, i8** %vtable5, i64 0
%12 = bitcast i8** %vfn6 to void (%struct.A*)** %12 = bitcast i8** %vfn6 to void (%struct.A*)**
%13 = load void (%struct.A*)*, void (%struct.A*)** %12, align 8 %13 = load void (%struct.A*)*, void (%struct.A*)** %12, align 8
; CHECK: call void @_ZN1A3fooEv( ; CHECK: call void @_ZN1A3fooEv(
call void %13(%struct.A* %9) call void %13(%struct.A* %9)
ret void ret void
} }
; CHECK-LABEL: define void @combiningBitCastWithLoad() { ; CHECK-LABEL: define void @combiningBitCastWithLoad() {
define void @combiningBitCastWithLoad() { define void @combiningBitCastWithLoad() {
entry: entry:
%a = alloca %struct.A*, align 8 %a = alloca %struct.A*, align 8
%0 = bitcast %struct.A** %a to i8* %0 = bitcast %struct.A** %a to i8*
%call = call i8* @getPointer(i8* null) %call = call i8* @getPointer(i8* null)
%1 = bitcast i8* %call to %struct.A* %1 = bitcast i8* %call to %struct.A*
call void @_ZN1AC1Ev(%struct.A* %1) call void @_ZN1AC1Ev(%struct.A* %1)
%2 = bitcast %struct.A* %1 to i8*** %2 = bitcast %struct.A* %1 to i8***
; CHECK: %vtable = load {{.*}} !invariant.group ; CHECK: %vtable = load {{.*}} !invariant.group
%vtable = load i8**, i8*** %2, align 8, !invariant.group !2 %vtable = load i8**, i8*** %2, align 8, !invariant.group !0
%cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2) %cmp.vtables = icmp eq i8** %vtable, getelementptr inbounds ([3 x i8*], [3 x i8*]* @_ZTV1A, i64 0, i64 2)
store %struct.A* %1, %struct.A** %a, align 8 store %struct.A* %1, %struct.A** %a, align 8
; CHECK-NOT: !invariant.group ; CHECK-NOT: !invariant.group
%3 = load %struct.A*, %struct.A** %a, align 8 %3 = load %struct.A*, %struct.A** %a, align 8
%4 = bitcast %struct.A* %3 to void (%struct.A*)*** %4 = bitcast %struct.A* %3 to void (%struct.A*)***
%vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !2 %vtable1 = load void (%struct.A*)**, void (%struct.A*)*** %4, align 8, !invariant.group !0
%vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0 %vfn = getelementptr inbounds void (%struct.A*)*, void (%struct.A*)** %vtable1, i64 0
%5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8 %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
call void %5(%struct.A* %3) call void %5(%struct.A* %3)
ret void ret void
} }
; CHECK-LABEL:define void @loadCombine() { ; CHECK-LABEL:define void @loadCombine() {
define void @loadCombine() { define void @loadCombine() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[A:.*]] = load i8, i8* %ptr, !invariant.group ; CHECK: %[[A:.*]] = load i8, i8* %ptr, !invariant.group
%a = load i8, i8* %ptr, !invariant.group !0 %a = load i8, i8* %ptr, !invariant.group !0
; CHECK-NOT: load ; CHECK-NOT: load
%b = load i8, i8* %ptr, !invariant.group !1 %b = load i8, i8* %ptr, !invariant.group !0
; CHECK: call void @bar(i8 %[[A]]) ; CHECK: call void @bar(i8 %[[A]])
call void @bar(i8 %a) call void @bar(i8 %a)
; CHECK: call void @bar(i8 %[[A]]) ; CHECK: call void @bar(i8 %[[A]])
call void @bar(i8 %b) call void @bar(i8 %b)
ret void ret void
} }
; CHECK-LABEL: define void @loadCombine1() { ; CHECK-LABEL: define void @loadCombine1() {
define void @loadCombine1() { define void @loadCombine1() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[D:.*]] = load i8, i8* %ptr, !invariant.group ; CHECK: %[[D:.*]] = load i8, i8* %ptr, !invariant.group
%c = load i8, i8* %ptr %c = load i8, i8* %ptr
; CHECK-NOT: load ; CHECK-NOT: load
%d = load i8, i8* %ptr, !invariant.group !1 %d = load i8, i8* %ptr, !invariant.group !0
; CHECK: call void @bar(i8 %[[D]]) ; CHECK: call void @bar(i8 %[[D]])
call void @bar(i8 %c) call void @bar(i8 %c)
; CHECK: call void @bar(i8 %[[D]]) ; CHECK: call void @bar(i8 %[[D]])
call void @bar(i8 %d) call void @bar(i8 %d)
ret void ret void
} }
; CHECK-LABEL: define void @loadCombine2() { ; CHECK-LABEL: define void @loadCombine2() {
define void @loadCombine2() { define void @loadCombine2() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group ; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group
%e = load i8, i8* %ptr, !invariant.group !1 %e = load i8, i8* %ptr, !invariant.group !0
; CHECK-NOT: load ; CHECK-NOT: load
%f = load i8, i8* %ptr %f = load i8, i8* %ptr
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %e) call void @bar(i8 %e)
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %f) call void @bar(i8 %f)
ret void ret void
} }
; CHECK-LABEL: define void @loadCombine3() { ; CHECK-LABEL: define void @loadCombine3() {
define void @loadCombine3() { define void @loadCombine3() {
enter: enter:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr store i8 42, i8* %ptr
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group ![[OneMD:[0-9]]] ; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group
%e = load i8, i8* %ptr, !invariant.group !1 %e = load i8, i8* %ptr, !invariant.group !0
; CHECK-NOT: load ; CHECK-NOT: load
%f = load i8, i8* %ptr, !invariant.group !1 %f = load i8, i8* %ptr, !invariant.group !0
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %e) call void @bar(i8 %e)
; CHECK: call void @bar(i8 %[[E]]) ; CHECK: call void @bar(i8 %[[E]])
call void @bar(i8 %f) call void @bar(i8 %f)
ret void ret void
} }
; CHECK-LABEL: define i8 @unoptimizable2() { ; CHECK-LABEL: define i8 @unoptimizable2() {
Show All 23 Lines
} }
; CHECK-LABEL: define i8 @optimizable4() { ; CHECK-LABEL: define i8 @optimizable4() {
define i8 @optimizable4() { define i8 @optimizable4() {
entry: entry:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr, !invariant.group !0 store i8 42, i8* %ptr, !invariant.group !0
%ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr) %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
; CHECK-NOT: load
%a = load i8, i8* %ptr2, !invariant.group !0 %a = load i8, i8* %ptr2, !invariant.group !0
; CHECK: ret i8 42 ; CHECK: ret i8 42
ret i8 %a ret i8 %a
} }
; CHECK-LABEL: define i8 @volatile1() { ; CHECK-LABEL: define i8 @volatile1() {
define i8 @volatile1() { define i8 @volatile1() {
Show All 38 Lines
entry: entry:
%ptr = alloca i8 %ptr = alloca i8
store i8 42, i8* %ptr, !invariant.group !0 store i8 42, i8* %ptr, !invariant.group !0
call void @foo(i8* %ptr) call void @foo(i8* %ptr)
%a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change %a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
; CHECK: call void @bar(i8 42) ; CHECK: call void @bar(i8 42)
call void @bar(i8 %a) call void @bar(i8 %a)
call void @foo(i8* %ptr)
%b = load i8, i8* %ptr, !invariant.group !1 ; Can't assume anything, because group changed
; CHECK: call void @bar(i8 %b)
call void @bar(i8 %b)
%newPtr = call i8* @getPointer(i8* %ptr) %newPtr = call i8* @getPointer(i8* %ptr)
%c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr %c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr
; CHECK: call void @bar(i8 %c) ; CHECK: call void @bar(i8 %c)
call void @bar(i8 %c) call void @bar(i8 %c)
%unknownValue = load i8, i8* @unknownPtr %unknownValue = load i8, i8* @unknownPtr
; FIXME: Can assume that %unknownValue == 42 ; FIXME: Can assume that %unknownValue == 42
; CHECK: store i8 %unknownValue, i8* %ptr, !invariant.group !0 ; CHECK: store i8 %unknownValue, i8* %ptr, !invariant.group !0
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.assume(i1 %cmp.vtables) #0 declare void @llvm.assume(i1 %cmp.vtables) #0
attributes #0 = { nounwind } attributes #0 = { nounwind }
; CHECK: ![[OneMD]] = !{!"other ptr"} !0 = !{}
!0 = !{!"magic ptr"} No newline at end of file
!1 = !{!"other ptr"}
!2 = !{!"vtable_of_a"}