[ArgumentPromotion] Support opaque pointers

[cuviper]

Summary

Use the types from byval/load/gep instead of the pointer element type.

[cuviper]

Note: I added RUNs for enough tests that I felt confident I had good coverage, but I didn't do all of them. I'm not really sure that the way I handled typed/opaque CHECK results is a good strategy.

[aeubanks]

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

728–730

we're slightly powering down this transform under opaque pointers right? since previously we'd treat different pointer types as different and not bail out in the recursive check as often.
it'd be nice to have a test for this change

[cuviper]

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

728–730

I think it goes both ways -- yes, opaque pointers will look equal and be deemed recursive in cases that weren't before. On the other hand, the former code considered it recursive if the type had a self pointer at all, even if that's not used in the promotion. I'll see if I can craft test examples for both.

[aeubanks]

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

728–730

if we're going to support opaque pointers here, we should emulate what would happen with opaque pointers and bail out if we recursively see any pointer type. that way when we do the opaque pointer switch, this pass doesn't suddenly power down. I'd rather power it down beforehand and see if anybody complains

[cuviper]

Make the recursion check the same for typed or opaque pointers

The pointer type is no longer considered at all when checking for
recursive loads in arg promotion, so we have parity with or without
opaque pointers. The new test ArgumentPromotion/opaque-recursion.ll
shows what otherwise could have worked fine with typed pointers.

[cuviper]

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

728–730

I think this is addressed in the new update.

[nikic]

This looks good to me. Regarding the tests, I'd prefer to not modify them in this way and have a separate test with opaque pointers instead, otherwise update_test_checks doesn't work, and that's always a PITA when making changes.

Also worth noting that ArgPromotion uses areFunctionArgsABICompatible(), which currently accesses pointer element types and will need a signature change.

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

957

Don't think you need the hasByValAttr() call here, getParamByValType() should already return nullptr.

[nikic]

I looked into this a bit more closely, and unfortunately ArgPromotion will require significant additional work (close to a full rewrite) to support opaque pointers. The core problem is that ArgPromotion is currently based around GEP index structure. With opaque pointers, GEP index structure can be arbitrary. The transform will need to be changed to an offset-based implementation.

[cuviper]

Ok, I see that you've gone ahead with that rewrite in D118685, so I'll abandon this change.

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

if (ByValArgsToTransform.count(&*I)) {
           // Take any load, we will use it only to update Alias Analysis
           OrigLoad = cast<LoadInst>(UI->user_back());
         OriginalLoads[std::make_pair(&*I, Indices)] = OrigLoad;
       }
 
       // Add a parameter to the function for each element passed in.
       for (const auto &ArgIndex : ArgIndices) {
         // not allowed to dereference ->begin() if size() is 0
-        Params.push_back(GetElementPtrInst::getIndexedType(
-            cast<PointerType>(I->getType())->getElementType(),
-            ArgIndex.second));
+        Params.push_back(
+            GetElementPtrInst::getIndexedType(ArgIndex.first, ArgIndex.second));
         ArgAttrVec.push_back(AttributeSet());
         assert(Params.back());
       }
 
       if (ArgIndices.size() == 1 && ArgIndices.begin()->second.empty())
         ++NumArgumentsPromoted;
       else
         ++NumAggregatesPromoted;
for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
             for (auto II : ArgIndex.second) {
               // Use i32 to index structs, and i64 for others (pointers/arrays).
               // This satisfies GEP constraints.
               Type *IdxTy =
                   (ElTy->isStructTy() ? Type::getInt32Ty(F->getContext())
                                       : Type::getInt64Ty(F->getContext()));
               Ops.push_back(ConstantInt::get(IdxTy, II));
               // Keep track of the type we're currently indexing.
-              if (auto *ElPTy = dyn_cast<PointerType>(ElTy))
-                ElTy = ElPTy->getElementType();
+              if (isa<PointerType>(ElTy))
+                ElTy = ArgIndex.first;
               else
                 ElTy = GetElementPtrInst::getTypeAtIndex(ElTy, II);
             }
             // And create a GEP to extract those indices.
             V = IRB.CreateGEP(ArgIndex.first, V, Ops, V->getName() + ".idx");
             Ops.clear();
           }
           // Since we're replacing a load make sure we take the alignment
static void markIndicesSafe(const IndicesVector &ToMark,
   }
 }
 
 /// isSafeToPromoteArgument - As you might guess from the name of this method,
 /// it checks to see if it is both safe and useful to promote the argument.
 /// This method limits promotion of aggregates to only promote up to three
 /// elements of the aggregate in order to avoid exploding the number of
 /// arguments passed in.
-static bool isSafeToPromoteArgument(Argument *Arg, Type *ByValTy, AAResults &AAR,
-                                    unsigned MaxElements) {
+static bool isSafeToPromoteArgument(Argument *Arg, Type *ByValTy,
+                                    AAResults &AAR, unsigned MaxElements,
+                                    bool isSelfRecursive) {
   using GEPIndicesSet = std::set<IndicesVector>;
 
   // Quick exit for unused arguments
   if (Arg->use_empty())
     return true;
 
   // We can only promote this argument if all of the uses are loads, or are GEP
   // instructions (with constant indices) that are subsequently loaded.
if (ToPromote.find(Operands) == ToPromote.end()) {
       }
       ToPromote.insert(std::move(Operands));
     }
   }
 
   if (Loads.empty())
     return true; // No users, this is a dead argument.
 
+  // If we're in a recursive function, and the argument is a recursive type
+  // where we load another pointer, we could end up infinitely peeling the
+  // function argument. With opaque pointers, we can't actually tell if that
+  // load is the exact same argument type, so this is a bit pessimistic.
+  if (isSelfRecursive) {
+    for (LoadInst *Load : Loads) {
+      if (Load->getType()->isPointerTy()) {
+        return false;
+      }
+    }
+  }
+
   // Okay, now we know that the argument is only used by load instructions and
   // it is safe to unconditionally perform all of them. Use alias analysis to
   // check to see if the pointer is guaranteed to not be modified from entry of
   // the function to each of the load instructions.
 
   // Because there could be several/many load instructions, remember which
   // blocks we know to be transparent to the load.
   df_iterator_default_set<BasicBlock *, 16> TranspBlocks;
promoteArguments(Function *F, function_ref<AAResults &(Function &F)> AARGetter,
 
   AAResults &AAR = AARGetter(*F);
 
   // Check to see which arguments are promotable.  If an argument is promotable,
   // add it to ArgsToPromote.
   SmallPtrSet<Argument *, 8> ArgsToPromote;
   SmallPtrSet<Argument *, 8> ByValArgsToTransform;
   for (Argument *PtrArg : PointerArgs) {
-    Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();
-
     // Replace sret attribute with noalias. This reduces register pressure by
     // avoiding a register copy.
     if (PtrArg->hasStructRetAttr()) {
       unsigned ArgNo = PtrArg->getArgNo();
       F->removeParamAttr(ArgNo, Attribute::StructRet);
       F->addParamAttr(ArgNo, Attribute::NoAlias);
       for (Use &U : F->uses()) {
         CallBase &CB = cast<CallBase>(*U.getUser());
         CB.removeParamAttr(ArgNo, Attribute::StructRet);
         CB.addParamAttr(ArgNo, Attribute::NoAlias);
       }
     }
 
     // If this is a byval argument, and if the aggregate type is small, just
     // pass the elements, which is always safe, if the passed value is densely
     // packed or if we can prove the padding bytes are never accessed.
     //
     // Only handle arguments with specified alignment; if it's unspecified, the
     // actual alignment of the argument is target-specific.
-    bool isSafeToPromote = PtrArg->hasByValAttr() && PtrArg->getParamAlign() &&
-                           (ArgumentPromotionPass::isDenselyPacked(AgTy, DL) ||
-                            !canPaddingBeAccessed(PtrArg));
+    Type *ByValTy =
+        PtrArg->hasByValAttr() ? PtrArg->getParamByValType() : nullptr;
+    bool isSafeToPromote =
+        ByValTy && PtrArg->getParamAlign() &&
+        (ArgumentPromotionPass::isDenselyPacked(ByValTy, DL) ||
     if (isSafeToPromote) {
-      if (StructType *STy = dyn_cast<StructType>(AgTy)) {
+      if (StructType *STy = dyn_cast<StructType>(ByValTy)) {
         if (MaxElements > 0 && STy->getNumElements() > MaxElements) {
           LLVM_DEBUG(dbgs() << "argpromotion disable promoting argument '"
                             << PtrArg->getName()
                             << "' because it would require adding more"
                             << " than " << MaxElements
                             << " arguments to the function.\n");
           continue;
         }
if (isSafeToPromote) {
         // the new alloca we introduce.
         if (AllSimple) {
           ByValArgsToTransform.insert(PtrArg);
           continue;
         }
       }
     }
 
-    // If the argument is a recursive type and we're in a recursive
-    // function, we could end up infinitely peeling the function argument.
-    if (isSelfRecursive) {
-      if (StructType *STy = dyn_cast<StructType>(AgTy)) {
-        bool RecursiveType =
-            llvm::is_contained(STy->elements(), PtrArg->getType());
-        if (RecursiveType)
-          continue;
-      }
-    }
-
     // Otherwise, see if we can promote the pointer to its value.
-    Type *ByValTy =
-        PtrArg->hasByValAttr() ? PtrArg->getParamByValType() : nullptr;
-    if (isSafeToPromoteArgument(PtrArg, ByValTy, AAR, MaxElements))
+    if (isSafeToPromoteArgument(PtrArg, ByValTy, AAR, MaxElements,
+                                isSelfRecursive))
       ArgsToPromote.insert(PtrArg);
   }
 
   // No promotable pointer arguments.
   if (ArgsToPromote.empty() && ByValArgsToTransform.empty())
     return nullptr;
 
   if (!ArgumentPromotionPass::areFunctionArgsABICompatible(

llvm/test/Transforms/ArgumentPromotion/aggregate-promote-dead-gep.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
 
 %T = type { i32, i32, i32, i32 }
 @G = constant %T { i32 0, i32 0, i32 17, i32 25 }
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[T_P:.*]] }
+%pointers = type { i32*, %T* }
+@pointers = global %pointers zeroinitializer
+
 define internal i32 @test(%T* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32 [[P_0_3_VAL:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[V:%.*]] = add i32 [[P_0_3_VAL]], 10
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
   %a.gep = getelementptr %T, %T* %p, i64 0, i32 3
   %b.gep = getelementptr %T, %T* %p, i64 0, i32 2
   %a = load i32, i32* %a.gep
   %v = add i32 %a, 10
   ret i32 %v
 }
 
 define i32 @caller() {
 ; CHECK-LABEL: define {{[^@]+}}@caller() {
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[G_IDX:%.*]] = getelementptr [[T:%.*]], %T* @G, i64 0, i32 3
-; CHECK-NEXT:    [[G_IDX_VAL:%.*]] = load i32, i32* [[G_IDX]], align 4
+; CHECK-NEXT:    [[G_IDX:%.*]] = getelementptr [[T:%.*]], [[T_P]] @G, i64 0, i32 3
+; CHECK-NEXT:    [[G_IDX_VAL:%.*]] = load i32, [[I32_P]] [[G_IDX]], align 4
 ; CHECK-NEXT:    [[V:%.*]] = call i32 @test(i32 [[G_IDX_VAL]])
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
   %v = call i32 @test(%T* @G)
   ret i32 %v
 }

llvm/test/Transforms/ArgumentPromotion/aggregate-promote.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
 
 %T = type { i32, i32, i32, i32 }
 @G = constant %T { i32 0, i32 0, i32 17, i32 25 }
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[T_P:.*]] }
+%pointers = type { i32*, %T* }
+@pointers = global %pointers zeroinitializer
+
 define internal i32 @test(%T* %p) {
 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32 [[P_0_2_VAL:%.*]], i32 [[P_0_3_VAL:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[V:%.*]] = add i32 [[P_0_3_VAL]], [[P_0_2_VAL]]
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
   %a.gep = getelementptr %T, %T* %p, i64 0, i32 3
   %b.gep = getelementptr %T, %T* %p, i64 0, i32 2
   %a = load i32, i32* %a.gep
   %b = load i32, i32* %b.gep
   %v = add i32 %a, %b
   ret i32 %v
 }
 
 define i32 @caller() {
 ; CHECK-LABEL: define {{[^@]+}}@caller()
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[G_IDX:%.*]] = getelementptr [[T:%.*]], %T* @G, i64 0, i32 2
-; CHECK-NEXT:    [[G_IDX_VAL:%.*]] = load i32, i32* [[G_IDX]]
-; CHECK-NEXT:    [[G_IDX1:%.*]] = getelementptr [[T]], %T* @G, i64 0, i32 3
-; CHECK-NEXT:    [[G_IDX1_VAL:%.*]] = load i32, i32* [[G_IDX1]]
+; CHECK-NEXT:    [[G_IDX:%.*]] = getelementptr [[T:%.*]], [[T_P]] @G, i64 0, i32 2
+; CHECK-NEXT:    [[G_IDX_VAL:%.*]] = load i32, [[I32_P]] [[G_IDX]]
+; CHECK-NEXT:    [[G_IDX1:%.*]] = getelementptr [[T]], [[T_P]] @G, i64 0, i32 3
+; CHECK-NEXT:    [[G_IDX1_VAL:%.*]] = load i32, [[I32_P]] [[G_IDX1]]
 ; CHECK-NEXT:    [[V:%.*]] = call i32 @test(i32 [[G_IDX_VAL]], i32 [[G_IDX1_VAL]])
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
 entry:
   %v = call i32 @test(%T* @G)
   ret i32 %v
 }

llvm/test/Transforms/ArgumentPromotion/attrs.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
 
 %struct.ss = type { i32, i64 }
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[I64_P:.*]], [[STRUCT_SS_P:.*]] }
+%pointers = type { i32*, i64*, %struct.ss* }
+@pointers = global %pointers zeroinitializer
+
 ; Don't drop 'byval' on %X here.
 define internal void @f(%struct.ss* byval(%struct.ss) align 4 %b, i32* byval(i32) align 4 %X, i32 %i) nounwind {
 ; CHECK-LABEL: define {{[^@]+}}@f
-; CHECK-SAME: (i32 [[B_0:%.*]], i64 [[B_1:%.*]], i32* byval(i32) align 4 [[X:%.*]], i32 [[I:%.*]]) [[ATTR0:#.*]] {
+; CHECK-SAME: (i32 [[B_0:%.*]], i64 [[B_1:%.*]], [[I32_P]] byval(i32) align 4 [[X:%.*]], i32 [[I:%.*]]) [[ATTR0:#.*]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[B:%.*]] = alloca [[STRUCT_SS:%.*]], align 4
-; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    store i32 [[B_0]], i32* [[DOT0]], align 4
-; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 1
-; CHECK-NEXT:    store i64 [[B_1]], i64* [[DOT1]], align 4
-; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP]], align 4
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    store i32 [[B_0]], [[I32_P]] [[DOT0]], align 4
+; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 1
+; CHECK-NEXT:    store i64 [[B_1]], [[I64_P]] [[DOT1]], align 4
+; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, [[I32_P]] [[TMP]], align 4
 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[TMP1]], 1
-; CHECK-NEXT:    store i32 [[TMP2]], i32* [[TMP]], align 4
-; CHECK-NEXT:    store i32 0, i32* [[X]], align 4
+; CHECK-NEXT:    store i32 [[TMP2]], [[I32_P]] [[TMP]], align 4
+; CHECK-NEXT:    store i32 0, [[I32_P]] [[X]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
 
   %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0
   %tmp1 = load i32, i32* %tmp, align 4
   %tmp2 = add i32 %tmp1, 1
   store i32 %tmp2, i32* %tmp, align 4
 
   store i32 0, i32* %X
   ret void
 }
 
 ; Also make sure we don't drop the call zeroext attribute.
 define i32 @test(i32* %X) {
 ; CHECK-LABEL: define {{[^@]+}}@test
-; CHECK-SAME: (i32* [[X:%.*]]) {
+; CHECK-SAME: ([[I32_P]] [[X:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
-; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
-; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 8
-; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
-; CHECK-NEXT:    store i64 2, i64* [[TMP4]], align 4
-; CHECK-NEXT:    [[S_0:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
-; CHECK-NEXT:    [[S_0_VAL:%.*]] = load i32, i32* [[S_0]], align 4
-; CHECK-NEXT:    [[S_1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
-; CHECK-NEXT:    [[S_1_VAL:%.*]] = load i64, i64* [[S_1]], align 4
-; CHECK-NEXT:    call void @f(i32 [[S_0_VAL]], i64 [[S_1_VAL]], i32* byval(i32) align 4 [[X]], i32 zeroext 0)
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 0
+; CHECK-NEXT:    store i32 1, [[I32_P]] [[TMP1]], align 8
+; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 1
+; CHECK-NEXT:    store i64 2, [[I64_P]] [[TMP4]], align 4
+; CHECK-NEXT:    [[S_0:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 0
+; CHECK-NEXT:    [[S_0_VAL:%.*]] = load i32, [[I32_P]] [[S_0]], align 4
+; CHECK-NEXT:    [[S_1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 1
+; CHECK-NEXT:    [[S_1_VAL:%.*]] = load i64, [[I64_P]] [[S_1]], align 4
+; CHECK-NEXT:    call void @f(i32 [[S_0_VAL]], i64 [[S_1_VAL]], [[I32_P]] byval(i32) align 4 [[X]], i32 zeroext 0)
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
   %S = alloca %struct.ss
   %tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0
   store i32 1, i32* %tmp1, align 8
   %tmp4 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1
   store i64 2, i64* %tmp4, align 4
 
   call void @f( %struct.ss* byval(%struct.ss) align 4 %S, i32* byval(i32) align 4 %X, i32 zeroext 0)
 
   ret i32 0
 }

llvm/test/Transforms/ArgumentPromotion/basictest.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -basic-aa -argpromotion -mem2reg -S | FileCheck %s
+; RUN: opt < %s -basic-aa -argpromotion -mem2reg -opaque-pointers -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 define internal i32 @test(i32* %X, i32* %Y) {
 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32 [[X_VAL:%.*]], i32 [[Y_VAL:%.*]])
 ; CHECK-NEXT:    [[C:%.*]] = add i32 [[X_VAL]], [[Y_VAL]]
 ; CHECK-NEXT:    ret i32 [[C]]
 ;

llvm/test/Transforms/ArgumentPromotion/byval-2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
 
 ; Arg promotion eliminates the struct argument.
 ; FIXME: We should eliminate the i32* argument.
 
 %struct.ss = type { i32, i64 }
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[I64_P:.*]], [[STRUCT_SS_P:.*]] }
+%pointers = type { i32*, i64*, %struct.ss* }
+@pointers = global %pointers zeroinitializer
+
 define internal void @f(%struct.ss* byval(%struct.ss) align 8 %b, i32* byval(i32) align 4 %X) nounwind  {
 ; CHECK-LABEL: define {{[^@]+}}@f
-; CHECK-SAME: (i32 [[B_0:%.*]], i64 [[B_1:%.*]], i32* byval(i32) align 4 [[X:%.*]]) [[ATTR0:#.*]] {
+; CHECK-SAME: (i32 [[B_0:%.*]], i64 [[B_1:%.*]], [[I32_P]] byval(i32) align 4 [[X:%.*]]) [[ATTR0:#.*]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[B:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
-; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    store i32 [[B_0]], i32* [[DOT0]], align 8
-; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 1
-; CHECK-NEXT:    store i64 [[B_1]], i64* [[DOT1]], align 4
-; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP]], align 4
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    store i32 [[B_0]], [[I32_P]] [[DOT0]], align 8
+; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 1
+; CHECK-NEXT:    store i64 [[B_1]], [[I64_P]] [[DOT1]], align 4
+; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, [[I32_P]] [[TMP]], align 4
 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[TMP1]], 1
-; CHECK-NEXT:    store i32 [[TMP2]], i32* [[TMP]], align 4
-; CHECK-NEXT:    store i32 0, i32* [[X]], align 4
+; CHECK-NEXT:    store i32 [[TMP2]], [[I32_P]] [[TMP]], align 4
+; CHECK-NEXT:    store i32 0, [[I32_P]] [[X]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0
   %tmp1 = load i32, i32* %tmp, align 4
   %tmp2 = add i32 %tmp1, 1
   store i32 %tmp2, i32* %tmp, align 4
 
   store i32 0, i32* %X
   ret void
 }
 
 define i32 @test(i32* %X) {
 ; CHECK-LABEL: define {{[^@]+}}@test
-; CHECK-SAME: (i32* [[X:%.*]]) {
+; CHECK-SAME: ([[I32_P]] [[X:%.*]]) {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 8
-; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
-; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 8
-; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
-; CHECK-NEXT:    store i64 2, i64* [[TMP4]], align 4
-; CHECK-NEXT:    [[S_0:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
-; CHECK-NEXT:    [[S_0_VAL:%.*]] = load i32, i32* [[S_0]], align 8
-; CHECK-NEXT:    [[S_1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
-; CHECK-NEXT:    [[S_1_VAL:%.*]] = load i64, i64* [[S_1]], align 4
-; CHECK-NEXT:    call void @f(i32 [[S_0_VAL]], i64 [[S_1_VAL]], i32* byval(i32) align 4 [[X]])
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 0
+; CHECK-NEXT:    store i32 1, [[I32_P]] [[TMP1]], align 8
+; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 1
+; CHECK-NEXT:    store i64 2, [[I64_P]] [[TMP4]], align 4
+; CHECK-NEXT:    [[S_0:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 0
+; CHECK-NEXT:    [[S_0_VAL:%.*]] = load i32, [[I32_P]] [[S_0]], align 8
+; CHECK-NEXT:    [[S_1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 1
+; CHECK-NEXT:    [[S_1_VAL:%.*]] = load i64, [[I64_P]] [[S_1]], align 4
+; CHECK-NEXT:    call void @f(i32 [[S_0_VAL]], i64 [[S_1_VAL]], [[I32_P]] byval(i32) align 4 [[X]])
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
   %S = alloca %struct.ss, align 8
   %tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0
   store i32 1, i32* %tmp1, align 8
   %tmp4 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1
   store i64 2, i64* %tmp4, align 4
   call void @f( %struct.ss* byval(%struct.ss) align 8 %S, i32* byval(i32) align 4 %X)
   ret i32 0
 }

llvm/test/Transforms/ArgumentPromotion/byval.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 %struct.ss = type { i32, i64 }
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[I64_P:.*]], [[STRUCT_SS_P:.*]] }
+%pointers = type { i32*, i64*, %struct.ss* }
+@pointers = global %pointers zeroinitializer
+
 define internal void @f(%struct.ss* byval(%struct.ss) align 4 %b) nounwind  {
 ; CHECK-LABEL: define {{[^@]+}}@f
 ; CHECK-SAME: (i32 [[B_0:%.*]], i64 [[B_1:%.*]]) [[ATTR0:#.*]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[B:%.*]] = alloca [[STRUCT_SS:%.*]], align 4
-; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    store i32 [[B_0]], i32* [[DOT0]], align 4
-; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 1
-; CHECK-NEXT:    store i64 [[B_1]], i64* [[DOT1]], align 4
-; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP]], align 4
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    store i32 [[B_0]], [[I32_P]] [[DOT0]], align 4
+; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 1
+; CHECK-NEXT:    store i64 [[B_1]], [[I64_P]] [[DOT1]], align 4
+; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, [[I32_P]] [[TMP]], align 4
 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[TMP1]], 1
-; CHECK-NEXT:    store i32 [[TMP2]], i32* [[TMP]], align 4
+; CHECK-NEXT:    store i32 [[TMP2]], [[I32_P]] [[TMP]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0
   %tmp1 = load i32, i32* %tmp, align 4
   %tmp2 = add i32 %tmp1, 1
   store i32 %tmp2, i32* %tmp, align 4
   ret void
 }
 
 
 define internal void @g(%struct.ss* byval(%struct.ss) align 32 %b) nounwind {
 ; CHECK-LABEL: define {{[^@]+}}@g
 ; CHECK-SAME: (i32 [[B_0:%.*]], i64 [[B_1:%.*]]) [[ATTR0]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[B:%.*]] = alloca [[STRUCT_SS:%.*]], align 32
-; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    store i32 [[B_0]], i32* [[DOT0]], align 32
-; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 1
-; CHECK-NEXT:    store i64 [[B_1]], i64* [[DOT1]], align 4
-; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
-; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* [[TMP]], align 4
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    store i32 [[B_0]], [[I32_P]] [[DOT0]], align 32
+; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 1
+; CHECK-NEXT:    store i64 [[B_1]], [[I64_P]] [[DOT1]], align 4
+; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[B]], i32 0, i32 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load i32, [[I32_P]] [[TMP]], align 4
 ; CHECK-NEXT:    [[TMP2:%.*]] = add i32 [[TMP1]], 1
-; CHECK-NEXT:    store i32 [[TMP2]], i32* [[TMP]], align 4
+; CHECK-NEXT:    store i32 [[TMP2]], [[I32_P]] [[TMP]], align 4
 ; CHECK-NEXT:    ret void
 ;
 entry:
   %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0
   %tmp1 = load i32, i32* %tmp, align 4
   %tmp2 = add i32 %tmp1, 1
   store i32 %tmp2, i32* %tmp, align 4
   ret void
 }
 
 ; Don't transform if alignment isn't specified; the actual alignment
 ; is target-specific, and not exposed anywhere.
 ;
 ; (If we ever change byval so a missing alignment isn't legal, we can
 ; just delete this test.)
 define internal void @h(%struct.ss* byval(%struct.ss) %b) nounwind {
 ; CHECK-LABEL: define {{[^@]+}}@h
-; CHECK-SAME: (%struct.ss* byval(%struct.ss) %b)
+; CHECK-SAME: ([[STRUCT_SS_P]] byval(%struct.ss) %b)
 ;
 entry:
   %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0
   %tmp1 = load i32, i32* %tmp, align 4
   %tmp2 = add i32 %tmp1, 1
   store i32 %tmp2, i32* %tmp, align 4
   ret void
 }
 
 define i32 @main() nounwind  {
 ; CHECK-LABEL: define {{[^@]+}}@main
 ; CHECK-SAME: () [[ATTR0]] {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[S:%.*]] = alloca [[STRUCT_SS:%.*]], align 32
-; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
-; CHECK-NEXT:    store i32 1, i32* [[TMP1]], align 8
-; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
-; CHECK-NEXT:    store i64 2, i64* [[TMP4]], align 4
-; CHECK-NEXT:    [[S_0:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
-; CHECK-NEXT:    [[S_0_VAL:%.*]] = load i32, i32* [[S_0]], align 4
-; CHECK-NEXT:    [[S_1:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
-; CHECK-NEXT:    [[S_1_VAL:%.*]] = load i64, i64* [[S_1]], align 4
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 0
+; CHECK-NEXT:    store i32 1, [[I32_P]] [[TMP1]], align 8
+; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 1
+; CHECK-NEXT:    store i64 2, [[I64_P]] [[TMP4]], align 4
+; CHECK-NEXT:    [[S_0:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 0
+; CHECK-NEXT:    [[S_0_VAL:%.*]] = load i32, [[I32_P]] [[S_0]], align 4
+; CHECK-NEXT:    [[S_1:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 1
+; CHECK-NEXT:    [[S_1_VAL:%.*]] = load i64, [[I64_P]] [[S_1]], align 4
 ; CHECK-NEXT:    call void @f(i32 [[S_0_VAL]], i64 [[S_1_VAL]])
-; CHECK-NEXT:    [[S_01:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
-; CHECK-NEXT:    [[S_01_VAL:%.*]] = load i32, i32* [[S_01]], align 32
-; CHECK-NEXT:    [[S_12:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
-; CHECK-NEXT:    [[S_12_VAL:%.*]] = load i64, i64* [[S_12]], align 4
+; CHECK-NEXT:    [[S_01:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 0
+; CHECK-NEXT:    [[S_01_VAL:%.*]] = load i32, [[I32_P]] [[S_01]], align 32
+; CHECK-NEXT:    [[S_12:%.*]] = getelementptr [[STRUCT_SS]], [[STRUCT_SS_P]] [[S]], i32 0, i32 1
+; CHECK-NEXT:    [[S_12_VAL:%.*]] = load i64, [[I64_P]] [[S_12]], align 4
 ; CHECK-NEXT:    call void @g(i32 [[S_01_VAL]], i64 [[S_12_VAL]])
-; CHECK-NEXT:    call void @h(%struct.ss* byval(%struct.ss) %S)
+; CHECK-NEXT:    call void @h([[STRUCT_SS_P]] byval(%struct.ss) %S)
 ; CHECK-NEXT:    ret i32 0
 ;
 entry:
   %S = alloca %struct.ss, align 32
   %tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0
   store i32 1, i32* %tmp1, align 8
   %tmp4 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1
   store i64 2, i64* %tmp4, align 4
   call void @f(%struct.ss* byval(%struct.ss) align 4 %S) nounwind
   call void @g(%struct.ss* byval(%struct.ss) align 32 %S) nounwind
   call void @h(%struct.ss* byval(%struct.ss) %S) nounwind
   ret i32 0
 }
 
 

llvm/test/Transforms/ArgumentPromotion/chained.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
 
 @G1 = constant i32 0
 @G2 = constant i32* @G1
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[I32_PP:.*]] }
+%pointers = type { i32*, i32** }
+@pointers = global %pointers zeroinitializer
+
 define internal i32 @test(i32** %x) {
 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32 [[X_VAL_VAL:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret i32 [[X_VAL_VAL]]
 ;
 entry:
   %y = load i32*, i32** %x
   %z = load i32, i32* %y
   ret i32 %z
 }
 
 define i32 @caller() {
 ; CHECK-LABEL: define {{[^@]+}}@caller()
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[G2_VAL:%.*]] = load i32*, i32** @G2
-; CHECK-NEXT:    [[G2_VAL_VAL:%.*]] = load i32, i32* [[G2_VAL]]
+; CHECK-NEXT:    [[G2_VAL:%.*]] = load [[I32_P]], [[I32_PP]] @G2
+; CHECK-NEXT:    [[G2_VAL_VAL:%.*]] = load i32, [[I32_P]] [[G2_VAL]]
 ; CHECK-NEXT:    [[X:%.*]] = call i32 @test(i32 [[G2_VAL_VAL]])
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
 entry:
   %x = call i32 @test(i32** @G2)
   ret i32 %x
 }
 

llvm/test/Transforms/ArgumentPromotion/control-flow.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
+
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]] }
+%pointers = type { i32* }
+@pointers = global %pointers zeroinitializer
 
 ; Don't promote around control flow.
 define internal i32 @callee(i1 %C, i32* %P) {
 ; CHECK-LABEL: define {{[^@]+}}@callee
-; CHECK-SAME: (i1 [[C:%.*]], i32* [[P:%.*]])
+; CHECK-SAME: (i1 [[C:%.*]], [[I32_P]] [[P:%.*]])
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       T:
 ; CHECK-NEXT:    ret i32 17
 ; CHECK:       F:
-; CHECK-NEXT:    [[X:%.*]] = load i32, i32* [[P]]
+; CHECK-NEXT:    [[X:%.*]] = load i32, [[I32_P]] [[P]]
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
 entry:
   br i1 %C, label %T, label %F
 
 T:
   ret i32 17
 
 F:
   %X = load i32, i32* %P
   ret i32 %X
 }
 
 define i32 @foo() {
 ; CHECK-LABEL: define {{[^@]+}}@foo()
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[X:%.*]] = call i32 @callee(i1 true, i32* null)
+; CHECK-NEXT:    [[X:%.*]] = call i32 @callee(i1 true, [[I32_P]] null)
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
 entry:
   %X = call i32 @callee(i1 true, i32* null)
   ret i32 %X
 }
 

llvm/test/Transforms/ArgumentPromotion/control-flow2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]] }
+%pointers = type { i32* }
+@pointers = global %pointers zeroinitializer
+
 define internal i32 @callee(i1 %C, i32* %P) {
 ; CHECK-LABEL: define {{[^@]+}}@callee
 ; CHECK-SAME: (i1 [[C:%.*]], i32 [[P_VAL:%.*]])
 ; CHECK-NEXT:    br i1 [[C]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       T:
 ; CHECK-NEXT:    ret i32 17
 ; CHECK:       F:
 ; CHECK-NEXT:    ret i32 [[P_VAL]]
 ;
   br i1 %C, label %T, label %F
 
 T:              ; preds = %0
   ret i32 17
 
 F:              ; preds = %0
   %X = load i32, i32* %P               ; <i32> [#uses=1]
   ret i32 %X
 }
 
 define i32 @foo() {
 ; CHECK-LABEL: define {{[^@]+}}@foo()
 ; CHECK-NEXT:    [[A:%.*]] = alloca i32
-; CHECK-NEXT:    store i32 17, i32* [[A]]
-; CHECK-NEXT:    [[A_VAL:%.*]] = load i32, i32* [[A]]
+; CHECK-NEXT:    store i32 17, [[I32_P]] [[A]]
+; CHECK-NEXT:    [[A_VAL:%.*]] = load i32, [[I32_P]] [[A]]
 ; CHECK-NEXT:    [[X:%.*]] = call i32 @callee(i1 false, i32 [[A_VAL]])
 ; CHECK-NEXT:    ret i32 [[X]]
 ;
   %A = alloca i32         ; <i32*> [#uses=2]
   store i32 17, i32* %A
   %X = call i32 @callee( i1 false, i32* %A )              ; <i32> [#uses=1]
   ret i32 %X
 }
 

llvm/test/Transforms/ArgumentPromotion/crash.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt -S < %s -inline -argpromotion | FileCheck %s --check-prefix=ARGPROMOTION
+; RUN: opt -S < %s -inline -argpromotion -opaque-pointers | FileCheck %s --check-prefix=ARGPROMOTION
 ; RUN: opt -S < %s -passes=inline,argpromotion | FileCheck %s --check-prefixes=ARGPROMOTION,ALL_NEWPM
+; RUN: opt -S < %s -passes=inline,argpromotion -opaque-pointers | FileCheck %s --check-prefixes=ARGPROMOTION,ALL_NEWPM
 
 %S = type { %S* }
 
+; Define variables for typed or opaque pointers
+; ARGPROMOTION-LABEL: %pointers = type
+; ARGPROMOTION-SAME: { [[I8_P:.*]], [[S_P:.*]], [[S_PP:.*]] }
+%pointers = type { i8*, %S*, %S** }
+@pointers = global %pointers zeroinitializer
+
 ; Inlining should nuke the invoke (and any inlined calls) here even with
 ; argument promotion running along with it.
 define void @zot() personality i32 (...)* @wibble {
-; ARGPROMOTION-LABEL: define {{[^@]+}}@zot() personality i32 (...)* @wibble
+; ARGPROMOTION-LABEL: define {{[^@]+}}@zot() personality {{.*}} @wibble
 ; ARGPROMOTION-NEXT:  bb:
 ; ARGPROMOTION-NEXT:    unreachable
 ; ARGPROMOTION:       hoge.exit:
 ; ARGPROMOTION-NEXT:    br label [[BB1:%.*]]
 ; ARGPROMOTION:       bb1:
 ; ARGPROMOTION-NEXT:    unreachable
 ; ARGPROMOTION:       bb2:
-; ARGPROMOTION-NEXT:    [[TMP:%.*]] = landingpad { i8*, i32 }
+; ARGPROMOTION-NEXT:    [[TMP:%.*]] = landingpad { [[I8_P]], i32 }
 ; ARGPROMOTION-NEXT:    cleanup
 ; ARGPROMOTION-NEXT:    unreachable
 ;
 bb:
   invoke void @hoge()
   to label %bb1 unwind label %bb2
 
 bb1:

 }
 
 define i32 @test_inf_promote_caller(i32 %arg) {
 ; ARGPROMOTION-LABEL: define {{[^@]+}}@test_inf_promote_caller
 ; ARGPROMOTION-SAME: (i32 [[ARG:%.*]])
 ; ARGPROMOTION-NEXT:  bb:
 ; ARGPROMOTION-NEXT:    [[TMP:%.*]] = alloca [[S:%.*]]
 ; ARGPROMOTION-NEXT:    [[TMP1:%.*]] = alloca [[S]]
-; ARGPROMOTION-NEXT:    [[TMP2:%.*]] = call i32 @test_inf_promote_callee(%S* [[TMP]], %S* [[TMP1]])
+; ARGPROMOTION-NEXT:    [[TMP2:%.*]] = call i32 @test_inf_promote_callee([[S_P]] [[TMP]], [[S_P]] [[TMP1]])
 ; ARGPROMOTION-NEXT:    ret i32 0
 ;
 bb:
   %tmp = alloca %S
   %tmp1 = alloca %S
   %tmp2 = call i32 @test_inf_promote_callee(%S* %tmp, %S* %tmp1)
 
   ret i32 0
 }
 
 define internal i32 @test_inf_promote_callee(%S* %arg, %S* %arg1) {
 ; ARGPROMOTION-LABEL: define {{[^@]+}}@test_inf_promote_callee
-; ARGPROMOTION-SAME: (%S* [[ARG:%.*]], %S* [[ARG1:%.*]])
+; ARGPROMOTION-SAME: ([[S_P]] [[ARG:%.*]],
+; ARGPROMOTION-SAME: [[S_P]] [[ARG1:%.*]])
 ; ARGPROMOTION-NEXT:  bb:
-; ARGPROMOTION-NEXT:    [[TMP:%.*]] = getelementptr [[S:%.*]], %S* [[ARG1]], i32 0, i32 0
-; ARGPROMOTION-NEXT:    [[TMP2:%.*]] = load %S*, %S** [[TMP]]
-; ARGPROMOTION-NEXT:    [[TMP3:%.*]] = getelementptr [[S]], %S* [[ARG]], i32 0, i32 0
-; ARGPROMOTION-NEXT:    [[TMP4:%.*]] = load %S*, %S** [[TMP3]]
-; ARGPROMOTION-NEXT:    [[TMP5:%.*]] = call i32 @test_inf_promote_callee(%S* [[TMP4]], %S* [[TMP2]])
+; ARGPROMOTION-NEXT:    [[TMP:%.*]] = getelementptr [[S:%.*]], [[S_P]] [[ARG1]], i32 0, i32 0
+; ARGPROMOTION-NEXT:    [[TMP2:%.*]] = load [[S_P]], [[S_PP]] [[TMP]]
+; ARGPROMOTION-NEXT:    [[TMP3:%.*]] = getelementptr [[S]], [[S_P]] [[ARG]], i32 0, i32 0
+; ARGPROMOTION-NEXT:    [[TMP4:%.*]] = load [[S_P]], [[S_PP]] [[TMP3]]
+; ARGPROMOTION-NEXT:    [[TMP5:%.*]] = call i32 @test_inf_promote_callee([[S_P]] [[TMP4]], [[S_P]] [[TMP2]])
 ; ARGPROMOTION-NEXT:    ret i32 0
 ;
 bb:
   %tmp = getelementptr %S, %S* %arg1, i32 0, i32 0
   %tmp2 = load %S*, %S** %tmp
   %tmp3 = getelementptr %S, %S* %arg, i32 0, i32 0
   %tmp4 = load %S*, %S** %tmp3
   %tmp5 = call i32 @test_inf_promote_callee(%S* %tmp4, %S* %tmp2)
 
   ret i32 0
 }
 
 declare i32 @wibble(...)

llvm/test/Transforms/ArgumentPromotion/dbg.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -opaque-pointers -S | FileCheck %s
+
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[I32_PP:.*]], [[STRUCT_PAIR_P:.*]] }
+%pointers = type { i32*, i32**, %struct.pair* }
+@pointers = global %pointers zeroinitializer
 
 declare void @sink(i32)
 
 define internal void @test(i32** %X) !dbg !2 {
 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32 [[X_VAL_VAL:%.*]]) [[DBG3:!dbg !.*]] {
 ; CHECK-NEXT:    call void @sink(i32 [[X_VAL_VAL]])
 ; CHECK-NEXT:    ret void
 ;
   %1 = load i32*, i32** %X, align 8
   %2 = load i32, i32* %1, align 8
   call void @sink(i32 %2)
   ret void
 }
 
 %struct.pair = type { i32, i32 }
 
 define internal void @test_byval(%struct.pair* byval(%struct.pair) align 4 %P) {
 ; CHECK-LABEL: define {{[^@]+}}@test_byval
 ; CHECK-SAME: (i32 [[P_0:%.*]], i32 [[P_1:%.*]]) {
 ; CHECK-NEXT:    [[P:%.*]] = alloca [[STRUCT_PAIR:%.*]], align 4
-; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_PAIR]], %struct.pair* [[P]], i32 0, i32 0
-; CHECK-NEXT:    store i32 [[P_0]], i32* [[DOT0]], align 4
-; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_PAIR]], %struct.pair* [[P]], i32 0, i32 1
-; CHECK-NEXT:    store i32 [[P_1]], i32* [[DOT1]], align 4
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[STRUCT_PAIR]], [[STRUCT_PAIR_P]] [[P]], i32 0, i32 0
+; CHECK-NEXT:    store i32 [[P_0]], [[I32_P]] [[DOT0]], align 4
+; CHECK-NEXT:    [[DOT1:%.*]] = getelementptr [[STRUCT_PAIR]], [[STRUCT_PAIR_P]] [[P]], i32 0, i32 1
+; CHECK-NEXT:    store i32 [[P_1]], [[I32_P]] [[DOT1]], align 4
 ; CHECK-NEXT:    ret void
 ;
   ret void
 }
 
 define void @caller(i32** %Y, %struct.pair* %P) {
 ; CHECK-LABEL: define {{[^@]+}}@caller
-; CHECK-SAME: (i32** [[Y:%.*]], %struct.pair* [[P:%.*]]) {
-; CHECK-NEXT:    [[Y_VAL:%.*]] = load i32*, i32** [[Y]], align 8, [[DBG4:!dbg !.*]]
-; CHECK-NEXT:    [[Y_VAL_VAL:%.*]] = load i32, i32* [[Y_VAL]], align 8, [[DBG4]]
+; CHECK-SAME: ([[I32_PP]] [[Y:%.*]], [[STRUCT_PAIR_P]] [[P:%.*]]) {
+; CHECK-NEXT:    [[Y_VAL:%.*]] = load [[I32_P]], [[I32_PP]] [[Y]], align 8, [[DBG4:!dbg !.*]]
+; CHECK-NEXT:    [[Y_VAL_VAL:%.*]] = load i32, [[I32_P]] [[Y_VAL]], align 8, [[DBG4]]
 ; CHECK-NEXT:    call void @test(i32 [[Y_VAL_VAL]]), [[DBG4]]
-; CHECK-NEXT:    [[P_0:%.*]] = getelementptr [[STRUCT_PAIR:%.*]], %struct.pair* [[P]], i32 0, i32 0, [[DBG5:!dbg !.*]]
-; CHECK-NEXT:    [[P_0_VAL:%.*]] = load i32, i32* [[P_0]], align 4, [[DBG5]]
-; CHECK-NEXT:    [[P_1:%.*]] = getelementptr [[STRUCT_PAIR]], %struct.pair* [[P]], i32 0, i32 1, [[DBG5]]
-; CHECK-NEXT:    [[P_1_VAL:%.*]] = load i32, i32* [[P_1]], align 4, [[DBG5]]
+; CHECK-NEXT:    [[P_0:%.*]] = getelementptr [[STRUCT_PAIR:%.*]], [[STRUCT_PAIR_P]] [[P]], i32 0, i32 0, [[DBG5:!dbg !.*]]
+; CHECK-NEXT:    [[P_0_VAL:%.*]] = load i32, [[I32_P]] [[P_0]], align 4, [[DBG5]]
+; CHECK-NEXT:    [[P_1:%.*]] = getelementptr [[STRUCT_PAIR]], [[STRUCT_PAIR_P]] [[P]], i32 0, i32 1, [[DBG5]]
+; CHECK-NEXT:    [[P_1_VAL:%.*]] = load i32, [[I32_P]] [[P_1]], align 4, [[DBG5]]
 ; CHECK-NEXT:    call void @test_byval(i32 [[P_0_VAL]], i32 [[P_1_VAL]]), [[DBG5]]
 ; CHECK-NEXT:    ret void
 ;
   call void @test(i32** %Y), !dbg !1
 
   call void @test_byval(%struct.pair* byval(%struct.pair) align 4 %P), !dbg !6
   ret void
 }

llvm/test/Transforms/ArgumentPromotion/dead-gep-no-promotion.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=argpromotion -S %s | FileCheck %s
+; RUN: opt -passes=argpromotion -opaque-pointers -S %s | FileCheck %s
 
 @glob = external global i32*
 
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I32_P:.*]], [[I32_PP:.*]] }
+%pointers = type { i32*, i32** }
+@pointers = global %pointers zeroinitializer
+
 ; No arguments in @callee can be promoted, but it contains a dead GEP. Make
 ; sure it is not removed, as we do not perform any promotion.
 define i32 @caller(i32* %ptr) {
 ; CHECK-LABEL: @caller(
-; CHECK-NEXT:    call void @callee(i32* [[PTR:%.*]], i32* [[PTR]], i32* [[PTR]])
+; CHECK-NEXT:    call void @callee([[I32_P]] [[PTR:%.*]], [[I32_P]] [[PTR]], [[I32_P]] [[PTR]])
 ; CHECK-NEXT:    ret i32 0
 ;
   call void @callee(i32* %ptr, i32* %ptr, i32* %ptr)
   ret i32 0
 }
 
 define internal void @callee(i32* %arg, i32* %arg1, i32* %arg2) {
 ; CHECK-LABEL: define internal void @callee(
-; CHECK-NEXT:    call void @external_fn(i32* [[ARG:%.*]], i32* [[ARG1:%.*]])
-; CHECK-NEXT:    [[DEAD_GEP:%.*]] = getelementptr inbounds i32, i32* [[ARG1]], i32 17
-; CHECK-NEXT:    store i32* [[ARG2:%.*]], i32** @glob, align 8
+; CHECK-NEXT:    call void @external_fn([[I32_P]] [[ARG:%.*]], [[I32_P]] [[ARG1:%.*]])
+; CHECK-NEXT:    [[DEAD_GEP:%.*]] = getelementptr inbounds i32, [[I32_P]] [[ARG1]], i32 17
+; CHECK-NEXT:    store [[I32_P]] [[ARG2:%.*]], [[I32_PP]] @glob, align 8
 ; CHECK-NEXT:    ret void
 ;
   call void @external_fn(i32* %arg, i32* %arg1)
   %dead.gep = getelementptr inbounds i32, i32* %arg1, i32 17
   store i32* %arg2, i32** @glob, align 8
   ret  void
 }
 
 declare void @external_fn(i32*, i32*)

llvm/test/Transforms/ArgumentPromotion/opaque-recursion.ll

+; RUN: opt -S < %s -inline -argpromotion | FileCheck %s
+; RUN: opt -S < %s -inline -argpromotion -opaque-pointers | FileCheck %s
+; RUN: opt -S < %s -passes=inline,argpromotion | FileCheck %s
+; RUN: opt -S < %s -passes=inline,argpromotion -opaque-pointers | FileCheck %s
+
+%S = type { %S* }
+%T = type { %S* }
+
+; Define variables for typed or opaque pointers
+; CHECK-LABEL: %pointers = type
+; CHECK-SAME: { [[I8_P:.*]], [[S_P:.*]], [[S_PP:.*]], [[T_P:.*]] }
+%pointers = type { i8*, %S*, %S**, %T* }
+@pointers = global %pointers zeroinitializer
+
+define i32 @caller(i32 %arg) {
+; CHECK-LABEL: define {{[^@]+}}@caller
+; CHECK-SAME: (i32 [[ARG:%.*]])
+; CHECK-NEXT:  bb:
+; CHECK-NEXT:    [[TMP:%.*]] = alloca [[T:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = call i32 @callee([[T_P]] [[TMP]])
+; CHECK-NEXT:    ret i32 0
+;
+bb:
+  %tmp = alloca %T
+  %tmp1 = call i32 @callee(%T* %tmp)
+
+  ret i32 0
+}
+
+; This function could be arg-promoted once, but with opaque pointers it looks
+; like a recursive type promotion that's blocked by our current heuristic,
+; because we can't tell the difference between %S* and %T* anymore.
+; (The heuristic is now the same with typed pointers for migration consistency.)
+define internal i32 @callee(%T* %arg) {
+; CHECK-LABEL: define {{[^@]+}}@callee
+; CHECK-SAME: ([[T_P]] [[ARG:%.*]])
+; CHECK-NEXT:  bb:
+; CHECK-NEXT:    [[NEW:%.*]] = alloca [[T:%.*]]
+; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[T:%.*]], [[T_P]] [[ARG]], i32 0, i32 0
+; CHECK-NEXT:    [[TMP1:%.*]] = load [[S_P]], [[S_PP]] [[TMP]]
+; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr [[T]], [[T_P]] [[NEW]], i32 0, i32 0
+; CHECK-NEXT:    store [[S_P]] [[TMP1]], [[S_PP]] [[TMP2]]
+; CHECK-NEXT:    [[TMP3:%.*]] = call i32 @callee([[T_P]] [[NEW]])
+; CHECK-NEXT:    ret i32 0
+;
+bb:
+  %new = alloca %T
+  %tmp = getelementptr %T, %T* %arg, i32 0, i32 0
+  %tmp1 = load %S*, %S** %tmp
+  %tmp2 = getelementptr %T, %T* %new, i32 0, i32 0
+  store %S* %tmp1, %S** %tmp2
+  %tmp3 = call i32 @callee(%T* %new)
+
+  ret i32 0
+}