Dissallow non-empty metadata for invariant.group

[Prazek]

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).

[amharc]

Looks good to me.

[xbolva00]

LG

llvm/trunk/docs/LangRef.rst

.. code-block:: llvm
     !0 = !{"loop_header_weight", i64 100}
 
 Irreducible loop header weights are typically based on profile data.
 
 '``invariant.group``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 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 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
 when two pointers are considered the same). Pointers returned by bitcast or
 getelementptr with only zero indices are considered the same.
 
 Examples:
 
 .. code-block:: llvm
 
    @unknownPtr = external global i8
    ...
    %ptr = alloca i8
    store i8 42, i8* %ptr, !invariant.group !0
    call void @foo(i8* %ptr)
 
    %a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
    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)
    %c = load i8, i8* %newPtr, !invariant.group !0 ; Can't assume anything, because we only have information about %ptr
 
    %unknownValue = load i8, i8* @unknownPtr
    store i8 %unknownValue, i8* %ptr, !invariant.group !0 ; Can assume that %unknownValue == 42
 
    call void @foo(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
 
    ...
    declare void @foo(i8*)
    declare i8* @getPointer(i8*)
    declare i8* @llvm.launder.invariant.group(i8*)
 
-   !0 = !{!"magic ptr"}
-   !1 = !{!"other ptr"}
+   !0 = !{}
 
 The invariant.group metadata must be dropped when replacing one pointer by
 another based on aliasing information. This is because invariant.group is tied
 to the SSA value of the pointer operand.
 
 .. code-block:: llvm
 
   %v = load i8, i8* %x, !invariant.group !0

 The optional ``!invariant.load`` metadata must reference a single
 metadata name ``<index>`` corresponding to a metadata node with no
 entries. If a load instruction tagged with the ``!invariant.load``
 metadata is executed, the optimizer may assume the memory location
 referenced by the load contains the same value at all points in the
 program where the memory location is known to be dereferenceable.
 
 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
 metadata name ``<index>`` corresponding to a metadata node with no
 entries. The existence of the ``!nonnull`` metadata on the
 instruction tells the optimizer that the value loaded is known to
 never be null. This is analogous to the ``nonnull`` attribute
 on parameters and return values. This metadata can only be applied
 to loads of a pointer type.

llvm/trunk/docs/ReleaseNotes.rst

 ----------------------
 
 * 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
   parameter attributes.
 
 * 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
 --------------------------
 
  During this release ...
 
 
 Changes to the MIPS Target
 --------------------------

llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp

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

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

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

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

entry:
   %0 = bitcast %struct.A** %a to i8*
   
   %call = call i8* @getPointer(i8* null) 
   %1 = bitcast i8* %call to %struct.A*
   call void @_ZN1AC1Ev(%struct.A* %1)
   %2 = bitcast %struct.A* %1 to i8***
   
 ; 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)
   call void @llvm.assume(i1 %cmp.vtables)
   
   store %struct.A* %1, %struct.A** %a, align 8
   %3 = load %struct.A*, %struct.A** %a, align 8
   %4 = bitcast %struct.A* %3 to void (%struct.A*)***
 
 ; 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
   %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
   call void %5(%struct.A* %3)
   %6 = load %struct.A*, %struct.A** %a, align 8
   %7 = bitcast %struct.A* %6 to void (%struct.A*)***
 
 ; 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
   %8 = load void (%struct.A*)*, void (%struct.A*)** %vfn3, align 8
   
   call void %8(%struct.A* %6)
   %9 = load %struct.A*, %struct.A** %a, align 8
   %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
   %11 = load void (%struct.A*)*, void (%struct.A*)** %vfn5, align 8
 ; CHECK: call void @_ZN1A3fooEv(
   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
   %12 = bitcast i8** %vfn6 to void (%struct.A*)**
   %13 = load void (%struct.A*)*, void (%struct.A*)** %12, align 8
 ; CHECK: call void @_ZN1A3fooEv(
   call void %13(%struct.A* %9)
   
   ret void
 }
 
 ; CHECK-LABEL: define void @combiningBitCastWithLoad() {
 define void @combiningBitCastWithLoad() {
 entry:
   %a = alloca %struct.A*, align 8
   %0 = bitcast %struct.A** %a to i8*
   
   %call = call i8* @getPointer(i8* null) 
   %1 = bitcast i8* %call to %struct.A*
   call void @_ZN1AC1Ev(%struct.A* %1)
   %2 = bitcast %struct.A* %1 to i8***
   
 ; 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)
   
   store %struct.A* %1, %struct.A** %a, align 8
 ; CHECK-NOT: !invariant.group
   %3 = load %struct.A*, %struct.A** %a, align 8
   %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
   %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
   call void %5(%struct.A* %3)
 
   ret void
 }
 
 ; CHECK-LABEL:define void @loadCombine() {
 define void @loadCombine() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
 ; CHECK: %[[A:.*]] = load i8, i8* %ptr, !invariant.group
   %a = load i8, i8* %ptr, !invariant.group !0
 ; 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]])
   call void @bar(i8 %a)
 ; CHECK: call void @bar(i8 %[[A]])
   call void @bar(i8 %b)
   ret void
 }
 
 ; CHECK-LABEL: define void @loadCombine1() {
 define void @loadCombine1() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
 ; CHECK: %[[D:.*]] = load i8, i8* %ptr, !invariant.group
   %c = load i8, i8* %ptr
 ; 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]])
   call void @bar(i8 %c)
 ; CHECK: call void @bar(i8 %[[D]])
   call void @bar(i8 %d)
   ret void
 }
 
 ; CHECK-LABEL: define void @loadCombine2() {    
 define void @loadCombine2() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
 ; 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
   %f = load i8, i8* %ptr
 ; CHECK: call void @bar(i8 %[[E]])
   call void @bar(i8 %e)
 ; CHECK: call void @bar(i8 %[[E]])
   call void @bar(i8 %f)
   ret void
 }
 
 ; CHECK-LABEL: define void @loadCombine3() {
 define void @loadCombine3() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
-; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group ![[OneMD:[0-9]]]
-  %e = load i8, i8* %ptr, !invariant.group !1
+; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group
+  %e = load i8, i8* %ptr, !invariant.group !0
 ; 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]])
   call void @bar(i8 %e)
 ; CHECK: call void @bar(i8 %[[E]])
   call void @bar(i8 %f)
   ret void
 }
 
 ; CHECK-LABEL: define i8 @unoptimizable2() {

 entry:
     %ptr = alloca i8
     store i8 42, i8* %ptr, !invariant.group !0
     call void @foo(i8* %ptr)
 
     %a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
 ; CHECK: call void @bar(i8 42)
     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) 
     %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)
     call void @bar(i8 %c)
     
     %unknownValue = load i8, i8* @unknownPtr
 ; FIXME: Can assume that %unknownValue == 42
 ; CHECK: store i8 %unknownValue, i8* %ptr, !invariant.group !0

 
 declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 
 ; Function Attrs: nounwind
 declare void @llvm.assume(i1 %cmp.vtables) #0
 
 
 attributes #0 = { nounwind }
-; CHECK: ![[OneMD]] = !{!"other ptr"}
-!0 = !{!"magic ptr"}
-!1 = !{!"other ptr"}
-!2 = !{!"vtable_of_a"}
+!0 = !{}

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

entry:
   %val2 = load i32, i32* @tmp3, !invariant.group !0
   ret void;
 }
 
 declare void @changeTmp3ValAndCallBarrierInside()
 
 declare i8* @llvm.launder.invariant.group(i8*)
 
-!0 = !{!"something"}
+!0 = !{}

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

entry:
   %0 = bitcast %struct.A** %a to i8*
   
   %call = call i8* @getPointer(i8* null) 
   %1 = bitcast i8* %call to %struct.A*
   call void @_ZN1AC1Ev(%struct.A* %1)
   %2 = bitcast %struct.A* %1 to i8***
   
 ; 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)
   call void @llvm.assume(i1 %cmp.vtables)
   
   store %struct.A* %1, %struct.A** %a, align 8
   %3 = load %struct.A*, %struct.A** %a, align 8
   %4 = bitcast %struct.A* %3 to void (%struct.A*)***
 
 ; 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
   %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
   call void %5(%struct.A* %3)
   %6 = load %struct.A*, %struct.A** %a, align 8
   %7 = bitcast %struct.A* %6 to void (%struct.A*)***
 
 ; 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
   %8 = load void (%struct.A*)*, void (%struct.A*)** %vfn3, align 8
   
   call void %8(%struct.A* %6)
   %9 = load %struct.A*, %struct.A** %a, align 8
   %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
   %11 = load void (%struct.A*)*, void (%struct.A*)** %vfn5, align 8
 ; CHECK: call void @_ZN1A3fooEv(
   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
   %12 = bitcast i8** %vfn6 to void (%struct.A*)**
   %13 = load void (%struct.A*)*, void (%struct.A*)** %12, align 8
 ; CHECK: call void @_ZN1A3fooEv(
   call void %13(%struct.A* %9)
   
   ret void
 }
 
 ; CHECK-LABEL: define void @combiningBitCastWithLoad() {
 define void @combiningBitCastWithLoad() {
 entry:
   %a = alloca %struct.A*, align 8
   %0 = bitcast %struct.A** %a to i8*
   
   %call = call i8* @getPointer(i8* null) 
   %1 = bitcast i8* %call to %struct.A*
   call void @_ZN1AC1Ev(%struct.A* %1)
   %2 = bitcast %struct.A* %1 to i8***
   
 ; 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)
   
   store %struct.A* %1, %struct.A** %a, align 8
 ; CHECK-NOT: !invariant.group
   %3 = load %struct.A*, %struct.A** %a, align 8
   %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
   %5 = load void (%struct.A*)*, void (%struct.A*)** %vfn, align 8
   call void %5(%struct.A* %3)
 
   ret void
 }
 
 ; CHECK-LABEL:define void @loadCombine() {
 define void @loadCombine() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
 ; CHECK: %[[A:.*]] = load i8, i8* %ptr, !invariant.group
   %a = load i8, i8* %ptr, !invariant.group !0
 ; 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]])
   call void @bar(i8 %a)
 ; CHECK: call void @bar(i8 %[[A]])
   call void @bar(i8 %b)
   ret void
 }
 
 ; CHECK-LABEL: define void @loadCombine1() {
 define void @loadCombine1() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
 ; CHECK: %[[D:.*]] = load i8, i8* %ptr, !invariant.group
   %c = load i8, i8* %ptr
 ; 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]])
   call void @bar(i8 %c)
 ; CHECK: call void @bar(i8 %[[D]])
   call void @bar(i8 %d)
   ret void
 }
 
 ; CHECK-LABEL: define void @loadCombine2() {    
 define void @loadCombine2() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
 ; 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
   %f = load i8, i8* %ptr
 ; CHECK: call void @bar(i8 %[[E]])
   call void @bar(i8 %e)
 ; CHECK: call void @bar(i8 %[[E]])
   call void @bar(i8 %f)
   ret void
 }
 
 ; CHECK-LABEL: define void @loadCombine3() {
 define void @loadCombine3() {
 enter:
   %ptr = alloca i8
   store i8 42, i8* %ptr
   call void @foo(i8* %ptr)
-; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group ![[OneMD:[0-9]]]
-  %e = load i8, i8* %ptr, !invariant.group !1
+; CHECK: %[[E:.*]] = load i8, i8* %ptr, !invariant.group
+  %e = load i8, i8* %ptr, !invariant.group !0
 ; 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]])
   call void @bar(i8 %e)
 ; CHECK: call void @bar(i8 %[[E]])
   call void @bar(i8 %f)
   ret void
 }
 
 ; CHECK-LABEL: define i8 @unoptimizable2() {

 }
 
 ; CHECK-LABEL: define i8 @optimizable4() {
 define i8 @optimizable4() {
 entry:
     %ptr = alloca i8
     store i8 42, i8* %ptr, !invariant.group !0
     %ptr2 = call i8* @llvm.launder.invariant.group.p0i8(i8* %ptr)
+; CHECK-NOT: load
     %a = load i8, i8* %ptr2, !invariant.group !0
     
 ; CHECK: ret i8 42
     ret i8 %a
 }
 
 ; CHECK-LABEL: define i8 @volatile1() {
 define i8 @volatile1() {

 entry:
     %ptr = alloca i8
     store i8 42, i8* %ptr, !invariant.group !0
     call void @foo(i8* %ptr)
 
     %a = load i8, i8* %ptr, !invariant.group !0 ; Can assume that value under %ptr didn't change
 ; CHECK: call void @bar(i8 42)
     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) 
     %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)
     call void @bar(i8 %c)
     
     %unknownValue = load i8, i8* @unknownPtr
 ; FIXME: Can assume that %unknownValue == 42
 ; CHECK: store i8 %unknownValue, i8* %ptr, !invariant.group !0

 
 declare i8* @llvm.launder.invariant.group.p0i8(i8*)
 
 ; Function Attrs: nounwind
 declare void @llvm.assume(i1 %cmp.vtables) #0
 
 
 attributes #0 = { nounwind }
-; CHECK: ![[OneMD]] = !{!"other ptr"}
-!0 = !{!"magic ptr"}
-!1 = !{!"other ptr"}
-!2 = !{!"vtable_of_a"}
+!0 = !{}