Let llvm.invariant.group.barrier accepts pointer to any address space

[yaxunl]

Summary

llvm.invariant.group.barrier may accept pointers to arbitrary address space.

This patch let it accept pointers to i8 in any address space and returns
pointer to i8 in the same address space.

Corresponding clang change: https://reviews.llvm.org/D40062

[rampitec]

lib/Analysis/CaptureTracking.cpp

247 ↗

(On Diff #122705)

Can we mark it as "NoCapture<0>" instead?

[yaxunl]

lib/Analysis/CaptureTracking.cpp

247 ↗

(On Diff #122705)

line 243 also checks I->getType()->isVoidTy(), but this intrinsic returns a pointer. So even if we make it NoCapture, it still does not work.

[rampitec]

lib/Analysis/CaptureTracking.cpp

247 ↗

(On Diff #122705)

Checking for a specific intrinsic seems error-prone. What if the pointer returned by the call is further used in the caller?

[rampitec]

lib/Analysis/CaptureTracking.cpp

247 ↗

(On Diff #122705)

Maybe it is possible to add a check for VoidTy with the condition, that value is unused if returned from non-void?

[yaxunl]

lib/Analysis/CaptureTracking.cpp

247 ↗

(On Diff #122705)

Good idea. Will do.

[yaxunl]

Revised by Stas' comments.

[rampitec]

LGTM

[arsenm]

lib/Analysis/CaptureTracking.cpp

244 ↗

(On Diff #122731)

I don't understand the I->use_empty() check, or how this is related to the address space change

[arsenm]

test/CodeGen/AMDGPU/promote-alloca-invariant-markers.ll

2 ↗

(On Diff #122731)

Why is it necessary to add this? The datalayout is implied by the explicit triple

[yaxunl]

lib/Analysis/CaptureTracking.cpp

244 ↗

(On Diff #122731)

llvm.invariant.group.barrier only accepts pointer in default addr space. As such, the alloca has to be addrspacecasted then passed to llvm.invariant.group.barrier. In AMDGPUPromoteAlloca pass, addrspacecast is checked through CaptureTracking. The addrspacecast inst is passed to llvm.invariant.group.barrier, CaptureTracking thinks the intrinsic captures the addrspacecast inst because the intrinsic does not have void return type, which is incorrect. If the intrinsic only reads mem, does not throw, even if it returns a pointer, but if the returned pointer is not used, it still does not capture the pointer. So after this is fixed, CaptureTracking will identify the addrspacecast as not captured, then AMDGPUPromoteAlloca will identify the alloca as not captured, and then it can be promoted. Otherwise the alloca will not be promoted.

test/CodeGen/AMDGPU/promote-alloca-invariant-markers.ll

2 ↗

(On Diff #122731)

Removing this will cause error:

llc: <stdin>:13:31: error: address space must match datalayout

%tmp = alloca i32, align 4, addrspace(5)

[arsenm]

This is a workaround for invariant.group.barrier not having a mangled type. That should probably be fixed instead. The others already do, so it doesn't make sense that group.barrier does not

test/CodeGen/AMDGPU/promote-alloca-invariant-markers.ll

2 ↗

(On Diff #122731)

This sounds like a bug. This should be coming from the datalayout

[Prazek]

Firstly, are you sure that the invariant.group.barrier is the problem here? I didn't hear that it is used anywhere besides devirtualization, that is not turned on by default.
Here is my old path that was never reviewed:
https://reviews.llvm.org/D32673

As you can see, in order to check if the pointer passed to the barrier is captured, we need to check if all uses of the pointer returned by the barrier is not captured.

[yaxunl]

In D39973#924419, @Prazek wrote:

Firstly, are you sure that the invariant.group.barrier is the problem here? I didn't hear that it is used anywhere besides devirtualization, that is not turned on by default.
Here is my old path that was never reviewed:
https://reviews.llvm.org/D32673

As you can see, in order to check if the pointer passed to the barrier is captured, we need to check if all uses of the pointer returned by the barrier is not captured.

In D39973#924419, @Prazek wrote:

Firstly, are you sure that the invariant.group.barrier is the problem here? I didn't hear that it is used anywhere besides devirtualization, that is not turned on by default.
Here is my old path that was never reviewed:
https://reviews.llvm.org/D32673

As you can see, in order to check if the pointer passed to the barrier is captured, we need to check if all uses of the pointer returned by the barrier is not captured.

I am trying to fix a lit test failure related to invariant.group.barrier. There are two issues:

1. as Matt pointed out, invariant.group.barrier should accept pointer to any address space as parameter, since alloca address space may not be 0, e.g. for amdgcn---amdgiz triple, the pointer argument of invariant.group.barrier is in addr space 5.

2. CaptureTracking does not handle invariant.group.barrier correctly, which is what your patch and this patch tries to fix. Since you already have a patch for that, I would drop my fix and focus on the first issue. However as Stas suggested, it may be better to make the fix more generic instead of do special handling for invariant.group.barrier, e.g. is it OK to make it a generic checking for all functions?

if the func does not read mem
if the func does not throw
if the func returns nothing, or the returned pointer is not captured

then pointer argument is not captured

[yaxunl]

test/CodeGen/AMDGPU/promote-alloca-invariant-markers.ll

2 ↗

(On Diff #122731)

The error msg comes from LLParser::ParseAlloc.

llc load and parse IR before setting target triple and datalayout for the module.

When llc parses IR, it has to use the datalayout defined by the IR itself. If the IR does not define datalayout, the default layout created from empty string is used.

Currently LLParser does not allow overriding the datalayout of the IR by a given datalayout.

If we want to change this, we need to add an API to LLParser to allow datalayout to be set before parsing IR, and change llc to set datalayout before parsing IR. I think this is better left for another patch.

[yaxunl]

Make llvm.invariant.group.barrier mangled by Matt's comments.

[Prazek]

LGTM

llvm/trunk/docs/LangRef.rst

 
 This intrinsic indicates that the memory is mutable again.
 
 '``llvm.invariant.group.barrier``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
+This is an overloaded intrinsic. The memory object can belong to any address
+space. The returned pointer must belong to the same address space as the
+argument.
 
 ::
 
-      declare i8* @llvm.invariant.group.barrier(i8* <ptr>)
+      declare i8* @llvm.invariant.group.barrier.p0i8(i8* <ptr>)
 
 Overview:
 """""""""
 
 The '``llvm.invariant.group.barrier``' intrinsic can be used when an invariant
 established by invariant.group metadata no longer holds, to obtain a new pointer
 value that does not carry the invariant information.
 

llvm/trunk/include/llvm/IR/IRBuilder.h

Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") {
     Value *Difference = CreateSub(LHS_int, RHS_int);
     return CreateExactSDiv(Difference,
                            ConstantExpr::getSizeOf(ArgType->getElementType()),
                            Name);
   }
 
   /// \brief Create an invariant.group.barrier intrinsic call, that stops
   /// optimizer to propagate equality using invariant.group metadata.
-  /// If Ptr type is different from i8*, it's casted to i8* before call
-  /// and casted back to Ptr type after call.
+  /// If Ptr type is different from pointer to i8, it's casted to pointer to i8
+  /// in the same address space before call and casted back to Ptr type after
+  /// call.
   Value *CreateInvariantGroupBarrier(Value *Ptr) {
+    assert(isa<PointerType>(Ptr->getType()) &&
+           "invariant.group.barrier only applies to pointers.");
+    auto *PtrType = Ptr->getType();
+    auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
+    if (PtrType != Int8PtrTy)
+      Ptr = CreateBitCast(Ptr, Int8PtrTy);
     Module *M = BB->getParent()->getParent();
-    Function *FnInvariantGroupBarrier = Intrinsic::getDeclaration(M,
-            Intrinsic::invariant_group_barrier);
+    Function *FnInvariantGroupBarrier = Intrinsic::getDeclaration(
+        M, Intrinsic::invariant_group_barrier, {Int8PtrTy});
 
-    Type *ArgumentAndReturnType = FnInvariantGroupBarrier->getReturnType();
-    assert(ArgumentAndReturnType ==
-        FnInvariantGroupBarrier->getFunctionType()->getParamType(0) &&
+    assert(FnInvariantGroupBarrier->getReturnType() == Int8PtrTy &&
+           FnInvariantGroupBarrier->getFunctionType()->getParamType(0) ==
+               Int8PtrTy &&
            "InvariantGroupBarrier should take and return the same type");
-    Type *PtrType = Ptr->getType();
-
-    bool PtrTypeConversionNeeded = PtrType != ArgumentAndReturnType;
-    if (PtrTypeConversionNeeded)
-      Ptr = CreateBitCast(Ptr, ArgumentAndReturnType);
 
     CallInst *Fn = CreateCall(FnInvariantGroupBarrier, {Ptr});
 
-    if (PtrTypeConversionNeeded)
+    if (PtrType != Int8PtrTy)
       return CreateBitCast(Fn, PtrType);
     return Fn;
   }
 
   /// \brief Return a vector value that contains \arg V broadcasted to \p
   /// NumElts elements.
   Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "") {
     assert(NumElts > 0 && "Cannot splat to an empty vector!");

llvm/trunk/include/llvm/IR/Intrinsics.td

 
 // invariant.group.barrier can't be marked with 'readnone' (IntrNoMem),
 // because it would cause CSE of two barriers with the same argument.
 // Readonly and argmemonly says that barrier only reads its argument and
 // it can be CSE only if memory didn't change between 2 barriers call,
 // which is valid.
 // The argument also can't be marked with 'returned' attribute, because
 // it would remove barrier.
-def int_invariant_group_barrier : Intrinsic<[llvm_ptr_ty],
-                                            [llvm_ptr_ty],
+def int_invariant_group_barrier : Intrinsic<[llvm_anyptr_ty],
+                                            [LLVMMatchType<0>],
                                             [IntrReadMem, IntrArgMemOnly]>;
 
 //===------------------------ Stackmap Intrinsics -------------------------===//
 //
 def int_experimental_stackmap : Intrinsic<[],
                                   [llvm_i64_ty, llvm_i32_ty, llvm_vararg_ty],
                                   [Throws]>;
 def int_experimental_patchpoint_void : Intrinsic<[],

llvm/trunk/test/Analysis/MemorySSA/invariant-groups.ll

; CHECK-NEXT: store i32 0
   store i32 0, i32* %a, align 4, !invariant.group !0
 
 ; CHECK: 2 = MemoryDef(1)
 ; CHECK-NEXT: store i32 1
   store i32 1, i32* @g, align 4
 
   %1 = bitcast i32* %a to i8*
 ; CHECK: MemoryUse(2)
-; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
-  %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
+; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
+  %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
   %a32 = bitcast i8* %a8 to i32*
 
 ; This have to be MemoryUse(2), because we can't skip the barrier based on
 ; invariant.group.
 ; CHECK: MemoryUse(2)
 ; CHECK-NEXT: %2 = load i32
   %2 = load i32, i32* %a32, align 4, !invariant.group !0
   ret i32 %2
 }
 
 define i32 @skipBarrier(i32* %a) {
 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT: store i32 0
   store i32 0, i32* %a, align 4, !invariant.group !0
 
   %1 = bitcast i32* %a to i8*
 ; CHECK: MemoryUse(1)
-; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
-  %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
+; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
+  %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
   %a32 = bitcast i8* %a8 to i32*
 
 ; We can skip the barrier only if the "skip" is not based on !invariant.group.
 ; CHECK: MemoryUse(1)
 ; CHECK-NEXT: %2 = load i32
   %2 = load i32, i32* %a32, align 4, !invariant.group !0
   ret i32 %2
 }
 
 define i32 @skipBarrier2(i32* %a) {
 
 ; CHECK: MemoryUse(liveOnEntry)
 ; CHECK-NEXT: %v = load i32
   %v = load i32, i32* %a, align 4, !invariant.group !0
 
   %1 = bitcast i32* %a to i8*
 ; CHECK: MemoryUse(liveOnEntry)
-; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
-  %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
+; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
+  %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
   %a32 = bitcast i8* %a8 to i32*
 
 ; We can skip the barrier only if the "skip" is not based on !invariant.group.
 ; CHECK: MemoryUse(liveOnEntry)
 ; CHECK-NEXT: %v2 = load i32
   %v2 = load i32, i32* %a32, align 4, !invariant.group !0
 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT: store i32 1

 ; CHECK-NEXT: store i32 0
   store i32 0, i32* %a, align 4, !invariant.group !0
 
 ; CHECK: 2 = MemoryDef(1)
 ; CHECK-NEXT: store i32 1
   store i32 1, i32* @g, align 4
   %1 = bitcast i32* %a to i8*
 ; CHECK: MemoryUse(2)
-; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
-  %a8 = call i8* @llvm.invariant.group.barrier(i8* %1)
+; CHECK-NEXT: %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
+  %a8 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %1)
   %a32 = bitcast i8* %a8 to i32*
 
 ; CHECK: MemoryUse(2)
 ; CHECK-NEXT: %2 = load i32
   %2 = load i32, i32* %a32, align 4, !invariant.group !0
 
 ; CHECK: 3 = MemoryDef(2)
 ; CHECK-NEXT: store i32 2

 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT: store i8
   store i8 4, i8* %p, !invariant.group !0
 ; CHECK: 2 = MemoryDef(1)
 ; CHECK-NEXT: call void @clobber
   call void @clobber8(i8* %p)
 
 ; CHECK: MemoryUse(2)
-; CHECK-NEXT: %after = call i8* @llvm.invariant.group.barrier(i8* %p)
-  %after = call i8* @llvm.invariant.group.barrier(i8* %p)
+; CHECK-NEXT: %after = call i8* @llvm.invariant.group.barrier.p0i8(i8* %p)
+  %after = call i8* @llvm.invariant.group.barrier.p0i8(i8* %p)
   br i1 undef, label %Loop.Body, label %Loop.End
 
 Loop.Body:
 ; 4 = MemoryPhi({entry,2},{Loop.Body,3},{Loop.End,5})
 ; CHECK: MemoryUse(4)
 ; CHECK-NEXT: %0 = load i8
   %0 = load i8, i8* %after, !invariant.group !0
 

 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT: store i8
   store i8 4, i8* %p, !invariant.group !0
 ; CHECK: 2 = MemoryDef(1)
 ; CHECK-NEXT: call void @clobber
   call void @clobber8(i8* %p)
 
 ; CHECK: MemoryUse(2)
-; CHECK-NEXT: %after = call i8* @llvm.invariant.group.barrier(i8* %p)
-  %after = call i8* @llvm.invariant.group.barrier(i8* %p)
+; CHECK-NEXT: %after = call i8* @llvm.invariant.group.barrier.p0i8(i8* %p)
+  %after = call i8* @llvm.invariant.group.barrier.p0i8(i8* %p)
   br i1 undef, label %Loop.Body, label %Loop.End
 
 Loop.Body:
 ; CHECK: 6 = MemoryPhi({entry,2},{Loop.Body,3},{Loop.next,4},{Loop.End,5})
 ; CHECK: MemoryUse(6)
 ; CHECK-NEXT: %0 = load i8
   %0 = load i8, i8* %after, !invariant.group !0
 

 entry:
 ; CHECK: 1 = MemoryDef(liveOnEntry)
 ; CHECK-NEXT: store i8
   store i8 4, i8* %p, !invariant.group !0
 ; CHECK: 2 = MemoryDef(1)
 ; CHECK-NEXT: call void @clobber
   call void @clobber8(i8* %p)
 ; CHECK: MemoryUse(2)
-; CHECK-NEXT: %after = call i8* @llvm.invariant.group.barrier(i8* %p)
-  %after = call i8* @llvm.invariant.group.barrier(i8* %p)
+; CHECK-NEXT: %after = call i8* @llvm.invariant.group.barrier.p0i8(i8* %p)
+  %after = call i8* @llvm.invariant.group.barrier.p0i8(i8* %p)
   br i1 undef, label %Loop.Pre, label %Loop.End
 
 Loop.Pre:
 ; CHECK: MemoryUse(2)
 ; CHECK-NEXT: %0 = load i8
   %0 = load i8, i8* %after, !invariant.group !0
   br label %Loop.Body
 Loop.Body:

 ; CHECK-NEXT: %4 = load
   %4 = load i8, i8* %p, align 4, !invariant.group !0
   br i1 undef, label %Ret, label %Loop.Body
 
 Ret:
   ret i8 %3
 }
 
-declare i8* @llvm.invariant.group.barrier(i8*)
+declare i8* @llvm.invariant.group.barrier.p0i8(i8*)
 declare void @clobber(i32*)
 declare void @clobber8(i8*)
 
 
 !0 = !{!"group1"}

llvm/trunk/test/CodeGen/AMDGPU/promote-alloca-invariant-markers.ll

-; RUN:  llc -amdgpu-scalarize-global-loads=false  -march=amdgcn -mattr=+promote-alloca -verify-machineinstrs < %s | FileCheck -check-prefix=GCN %s
+; RUN:  llc -amdgpu-scalarize-global-loads=false  -march=amdgcn -mtriple=amdgcn---amdgiz -mattr=+promote-alloca -verify-machineinstrs < %s | FileCheck -check-prefix=GCN %s
+target datalayout = "A5"
 
-declare {}* @llvm.invariant.start.p0i8(i64, i8* nocapture) #0
-declare void @llvm.invariant.end.p0i8({}*, i64, i8* nocapture) #0
-declare i8* @llvm.invariant.group.barrier(i8*) #1
+declare {}* @llvm.invariant.start.p5i8(i64, i8 addrspace(5)* nocapture) #0
+declare void @llvm.invariant.end.p5i8({}*, i64, i8 addrspace(5)* nocapture) #0
+declare i8 addrspace(5)* @llvm.invariant.group.barrier.p5i8(i8 addrspace(5)*) #1
 
 ; GCN-LABEL: {{^}}use_invariant_promotable_lds:
 ; GCN: buffer_load_dword
 ; GCN: ds_write_b32
 define amdgpu_kernel void @use_invariant_promotable_lds(i32 addrspace(1)* %arg) #2 {
 bb:
-  %tmp = alloca i32, align 4
-  %tmp1 = bitcast i32* %tmp to i8*
+  %tmp = alloca i32, align 4, addrspace(5)
+  %tmp1 = bitcast i32 addrspace(5)* %tmp to i8 addrspace(5)*
   %tmp2 = getelementptr inbounds i32, i32 addrspace(1)* %arg, i64 1
   %tmp3 = load i32, i32 addrspace(1)* %tmp2
-  store i32 %tmp3, i32* %tmp
-  %tmp4 = call {}* @llvm.invariant.start.p0i8(i64 4, i8* %tmp1) #0
-  call void @llvm.invariant.end.p0i8({}* %tmp4, i64 4, i8* %tmp1) #0
-  %tmp5 = call i8* @llvm.invariant.group.barrier(i8* %tmp1) #1
+  store i32 %tmp3, i32 addrspace(5)* %tmp
+  %tmp4 = call {}* @llvm.invariant.start.p5i8(i64 4, i8 addrspace(5)* %tmp1) #0
+  call void @llvm.invariant.end.p5i8({}* %tmp4, i64 4, i8 addrspace(5)* %tmp1) #0
+  %tmp5 = call i8 addrspace(5)* @llvm.invariant.group.barrier.p5i8(i8 addrspace(5)* %tmp1) #1
   ret void
 }
 
 attributes #0 = { argmemonly nounwind }
 attributes #1 = { nounwind readnone }
 attributes #2 = { nounwind }

llvm/trunk/test/Other/invariant.group.barrier.ll

 ; RUN: opt -S -early-cse < %s | FileCheck %s
 ; RUN: opt -S -gvn < %s | FileCheck %s
 ; RUN: opt -S -newgvn < %s | FileCheck %s
 ; RUN: opt -S -O3 < %s | FileCheck %s
 
 ; These tests checks if passes with CSE functionality can do CSE on
 ; invariant.group.barrier, that is prohibited if there is a memory clobber
 ; between barriers call.
 
 ; CHECK-LABEL: define i8 @optimizable()
 define i8 @optimizable() {
 entry:
     %ptr = alloca i8
     store i8 42, i8* %ptr, !invariant.group !0
-; CHECK: call i8* @llvm.invariant.group.barrier
-    %ptr2 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
-; CHECK-NOT: call i8* @llvm.invariant.group.barrier
-    %ptr3 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
+; CHECK: call i8* @llvm.invariant.group.barrier.p0i8
+    %ptr2 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr)
+; CHECK-NOT: call i8* @llvm.invariant.group.barrier.p0i8
+    %ptr3 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr)
 ; CHECK: call void @clobber(i8* {{.*}}%ptr)
     call void @clobber(i8* %ptr)
 
 ; CHECK: call void @use(i8* {{.*}}%ptr2)
     call void @use(i8* %ptr2)
 ; CHECK: call void @use(i8* {{.*}}%ptr2)
     call void @use(i8* %ptr3)
 ; CHECK: load i8, i8* %ptr2, {{.*}}!invariant.group
     %v = load i8, i8* %ptr3, !invariant.group !0
 
     ret i8 %v
 }
 
 ; CHECK-LABEL: define i8 @unoptimizable()
 define i8 @unoptimizable() {
 entry:
     %ptr = alloca i8
     store i8 42, i8* %ptr, !invariant.group !0
-; CHECK: call i8* @llvm.invariant.group.barrier
-    %ptr2 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
+; CHECK: call i8* @llvm.invariant.group.barrier.p0i8
+    %ptr2 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr)
     call void @clobber(i8* %ptr)
-; CHECK: call i8* @llvm.invariant.group.barrier
-    %ptr3 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
+; CHECK: call i8* @llvm.invariant.group.barrier.p0i8
+    %ptr3 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr)
 ; CHECK: call void @clobber(i8* {{.*}}%ptr)
     call void @clobber(i8* %ptr)
 ; CHECK: call void @use(i8* {{.*}}%ptr2)
     call void @use(i8* %ptr2)
 ; CHECK: call void @use(i8* {{.*}}%ptr3)
     call void @use(i8* %ptr3)
 ; CHECK: load i8, i8* %ptr3, {{.*}}!invariant.group
     %v = load i8, i8* %ptr3, !invariant.group !0
 
     ret i8 %v
 }
 
 declare void @use(i8* readonly)
 
 declare void @clobber(i8*)
 ; CHECK: Function Attrs: argmemonly nounwind readonly
-; CHECK-NEXT: declare i8* @llvm.invariant.group.barrier(i8*)
-declare i8* @llvm.invariant.group.barrier(i8*)
+; CHECK-NEXT: declare i8* @llvm.invariant.group.barrier.p0i8(i8*)
+declare i8* @llvm.invariant.group.barrier.p0i8(i8*)
 
 !0 = !{}
 

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.invariant.group.barrier(
+  ; CHECK-NOT: @llvm.invariant.group.barrier.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.invariant.group.barrier(i8* @tmp)
+  %ptr = call i8* @llvm.invariant.group.barrier.p0i8(i8* @tmp)
   
   ; CHECK: store i8 42, i8* @tmp
   store i8 42, i8* %ptr, !invariant.group !0
   
   ret void
 }
 ; CHECK-LABEL: }
 
-declare i8* @llvm.invariant.group.barrier(i8*)
+declare i8* @llvm.invariant.group.barrier.p0i8(i8*)
 
 !0 = !{!"something"}
 !1 = !{!"x", !0}

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

; CHECK: ret i8 42
     ret i8 %a
 }
 
 ; CHECK-LABEL: define i8 @optimizable1() {
 define i8 @optimizable1() {
 entry:
     %ptr = alloca i8
     store i8 42, i8* %ptr, !invariant.group !0
-    %ptr2 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
+    %ptr2 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr)
     %a = load i8, i8* %ptr, !invariant.group !0
     
     call void @foo(i8* %ptr2); call to use %ptr2
 ; CHECK: ret i8 42
     ret i8 %a
 }
 
 ; CHECK-LABEL: define i8 @optimizable2() {
; CHECK: ret i8 %a
     ret i8 %a
 }
 
 ; CHECK-LABEL: define i8 @optimizable4() {
 define i8 @optimizable4() {
 entry:
     %ptr = alloca i8
     store i8 42, i8* %ptr, !invariant.group !0
-    %ptr2 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
+    %ptr2 = call i8* @llvm.invariant.group.barrier.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() {

 ; 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
     store i8 %unknownValue, i8* %ptr, !invariant.group !0 
 
-    %newPtr2 = call i8* @llvm.invariant.group.barrier(i8* %ptr)
+    %newPtr2 = call i8* @llvm.invariant.group.barrier.p0i8(i8* %ptr)
 ; CHECK-NOT: load
     %d = load i8, i8* %newPtr2, !invariant.group !0
 ; CHECK: ret i8 %unknownValue
     ret i8 %d
 }
 
 ; This test checks if invariant.group understands gep with zeros
 ; CHECK-LABEL: define void @testGEP0() {

 declare void @foo(i8*)
 declare void @foo2(i8*, i8)
 declare void @bar(i8)
 declare i8* @getPointer(i8*)
 declare void @_ZN1A3fooEv(%struct.A*)
 declare void @_ZN1AC1Ev(%struct.A*)
 declare void @fooBit(i1*, i1)
 
-declare i8* @llvm.invariant.group.barrier(i8*)
+declare i8* @llvm.invariant.group.barrier.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"}