Preserve inbounds information of GEP during Argument Promotion Pass across callee and its callers.

[pravinjagtap]

Summary

Presently inbounds information is lost between callee and its callers when Argument is promoted.
This change respects the inbounds of GEP emitted by front-end for callee and emits GEP with preserved
inbounds information in callers instead taking conservative approach of emitting GEP without inbounds
by default.

Note that Argument is only promoted when its *only* loaded (i.e. no store) in Argument Promotion Pass.

Motivation for this change is that the AMDGPUPromoteKernelArgumentsPass (https://reviews.llvm.org/D111464)
can infer the address-spaces and promote FLAT memory operation to GLOBAL based on this change.

[nikic]

It looks like you need to update a number of existing tests.

You should also test the case where the GEP inbounds is conditional -- I think it might still be okay based on a dereferenceabiliy argument, but it's not entirely obvious to me.

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

277–280

I think using inbounds here is okay, but the justification is not correct. You probably want to argue about byval-implied dereferenceability here.

[pravinjagtap]

In D119127#3300894, @nikic wrote:

It looks like you need to update a number of existing tests.

You should also test the case where the GEP inbounds is conditional -- I think it might still be okay based on a dereferenceabiliy argument, but it's not entirely obvious to me.

Thank you for your inputs. I am not sure whether I fully understood what do you mean by GEP inbounds is conditional. I am assuming that test should include: GEP with inbound and without inbound in callee so that other conditional branch will be exercised.

[pravinjagtap]

Addressed the comments by nikic and fixed the unit tests

[nikic]

In D119127#3304281, @pravinjagtap wrote:

In D119127#3300894, @nikic wrote:

It looks like you need to update a number of existing tests.

You should also test the case where the GEP inbounds is conditional -- I think it might still be okay based on a dereferenceabiliy argument, but it's not entirely obvious to me.

Thank you for your inputs. I am not sure whether I fully understood what do you mean by GEP inbounds is conditional. I am assuming that test should include: GEP with inbound and without inbound in callee so that other conditional branch will be exercised.

Sorry for the confusion: What I meant is a case where the GEP + load is not guaranteed to execute on entry to the function, but is behind a conditional branch.

[pravinjagtap]

Applied git-clang-format on change. Sorry for inconvenience.

[pravinjagtap]

Added test which exercises the conditional GEP inbound

[pravinjagtap]

In D119127#3304281, @pravinjagtap wrote:

In D119127#3300894, @nikic wrote:

It looks like you need to update a number of existing tests.

You should also test the case where the GEP inbounds is conditional -- I think it might still be okay based on a dereferenceabiliy argument, but it's not entirely obvious to me.

Thank you for your inputs. I am not sure whether I fully understood what do you mean by GEP inbounds is conditional. I am assuming that test should include: GEP with inbound and without inbound in callee so that other conditional branch will be exercised.

Added test /llvm/test/Transforms/ArgumentPromotion/conditional-gep-and-load.ll which exercises the conditional inbounds @nikic.

[vpykhtin]

Using IsArgGepInBound map just to hold a boolean seems expensive to me, can you just add a field to OriginalLoads value?

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

199

UI isn't expected to be null here, dyn_cast should be enough.

[pravinjagtap]

Addressed vpykhtin's commnets

[vpykhtin]

I would replace pair of pair with ordinary struct, much easier to read the code

llvm/lib/Transforms/IPO/ArgumentPromotion.cpp

doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote,
   // Arguments that are directly loaded will have a zero element value here, to
   // handle cases where there are both a direct load and GEP accesses.
   std::map<Argument *, ScalarizeTable> ScalarizedElements;
 
   // OriginalLoads - Keep track of a representative load instruction from the
   // original function so that we can tell the alias analysis implementation
   // what the new GEP/Load instructions we are inserting look like.
   // We need to keep the original loads for each argument and the elements
-  // of the argument that are accessed.
-  std::map<std::pair<Argument *, IndicesVector>, LoadInst *> OriginalLoads;
+  // of the argument that are accessed. Given map also keep track of inbounds
+  // information of GEP instruction used to load promoted arguments present in
+  // callee function. This is used to preserve inbound information in callers.
+  std::map<std::pair<Argument *, IndicesVector>, std::pair<LoadInst *, bool>>
+      OriginalLoads;
 
   // Attribute - Keep track of the parameter attributes for the arguments
   // that we are *not* promoting. For the ones that we do promote, the parameter
   // attributes are lost
   SmallVector<AttributeSet, 8> ArgAttrVec;
   AttributeList PAL = F->getAttributes();
 
   // First, determine the new argument list
if (ByValArgsToTransform.count(&*I)) {
           Indices.clear();
         ArgIndices.insert(std::make_pair(SrcTy, Indices));
         LoadInst *OrigLoad;
         if (LoadInst *L = dyn_cast<LoadInst>(UI))
           OrigLoad = L;
         else
           // 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;
+        bool IsGepInbounds = false;
+        if (GEPOperator *GEPOp = dyn_cast<GEPOperator>(UI))
+          IsGepInbounds = GEPOp->isInBounds();
+        OriginalLoads[std::make_pair(&*I, Indices)] =
+            std::make_pair(OrigLoad, IsGepInbounds);
       }
 
       // 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(
             I->getType()->getPointerElementType(), ArgIndex.second));
         ArgAttrVec.push_back(AttributeSet());
for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
         Type *AgTy = I->getParamByValType();
         StructType *STy = cast<StructType>(AgTy);
         Value *Idxs[2] = {
             ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr};
         const StructLayout *SL = DL.getStructLayout(STy);
         Align StructAlign = *I->getParamAlign();
         for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
           Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
-          auto *Idx =
-              IRB.CreateGEP(STy, *AI, Idxs, (*AI)->getName() + "." + Twine(i));
+          // It is safe to create inbounds GEP for byval argument since it is
+          // dereferenceable.
+          auto *Idx = IRB.CreateInBoundsGEP(STy, *AI, Idxs,
+                                            (*AI)->getName() + "." + Twine(i));
           // TODO: Tell AA about the new values?
           Align Alignment =
               commonAlignment(StructAlign, SL->getElementOffset(i));
           Args.push_back(IRB.CreateAlignedLoad(
               STy->getElementType(i), Idx, Alignment, Idx->getName() + ".val"));
           ArgAttrVec.push_back(AttributeSet());
         }
       } else if (!I->use_empty()) {
         // Non-dead argument: insert GEPs and loads as appropriate.
         ScalarizeTable &ArgIndices = ScalarizedElements[&*I];
         // Store the Value* version of the indices in here, but declare it now
         // for reuse.
         std::vector<Value *> Ops;
         for (const auto &ArgIndex : ArgIndices) {
           Value *V = *AI;
           LoadInst *OrigLoad =
-              OriginalLoads[std::make_pair(&*I, ArgIndex.second)];
+              OriginalLoads[std::make_pair(&*I, ArgIndex.second)].first;
           if (!ArgIndex.second.empty()) {
             Ops.reserve(ArgIndex.second.size());
             Type *ElTy = V->getType();
             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->getPointerElementType();
               else
                 ElTy = GetElementPtrInst::getTypeAtIndex(ElTy, II);
             }
             // And create a GEP to extract those indices.
+            bool IsCalleeArgGepInBound =
+                OriginalLoads[std::make_pair(&*I, ArgIndex.second)].second;
+            if (IsCalleeArgGepInBound) {
+              // Using preserved inbounds information of GEP in callee while
+              // creating GEP in caller.
+              V = IRB.CreateInBoundsGEP(ArgIndex.first, V, Ops,
+                                        V->getName() + ".idx");
+            } else {
               V = IRB.CreateGEP(ArgIndex.first, V, Ops, V->getName() + ".idx");
+            }
             Ops.clear();
           }
           // Since we're replacing a load make sure we take the alignment
           // of the previous load.
           LoadInst *newLoad =
               IRB.CreateLoad(OrigLoad->getType(), V, V->getName() + ".val");
           newLoad->setAlignment(OrigLoad->getAlign());
           // Transfer the AA info too.

llvm/test/Transforms/ArgumentPromotion/attrs.ll

 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32* [[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:%.*]] = getelementptr inbounds [[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:%.*]] = getelementptr inbounds [[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:    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/byval-2.ll

 ; CHECK-LABEL: define {{[^@]+}}@test
 ; CHECK-SAME: (i32* [[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:%.*]] = getelementptr inbounds [[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:%.*]] = getelementptr inbounds [[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:    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

 ; 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:%.*]] = getelementptr inbounds [[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:%.*]] = getelementptr inbounds [[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]])
-; CHECK-NEXT:    [[S_01:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
+; CHECK-NEXT:    [[S_01:%.*]] = getelementptr inbounds [[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:%.*]] = getelementptr inbounds [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
 ; CHECK-NEXT:    [[S_12_VAL:%.*]] = load i64, i64* [[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:    ret i32 0
 ;
 entry:
   %S = alloca %struct.ss, align 32
   %tmp1 = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0

llvm/test/Transforms/ArgumentPromotion/conditional-gep-and-load.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
+
+%struct.ss = type { i32, i64 }
+
+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:[0-9]+]] {
+; 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:    [[TMP1:%.*]] = icmp eq %struct.ss* [[B]], null
+; CHECK-NEXT:    br i1 [[TMP1]], label [[TMP2:%.*]], label [[TMP3:%.*]]
+; CHECK:       2:
+; CHECK-NEXT:    [[TMP:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[B]], i32 0, i32 0
+; CHECK-NEXT:    [[A:%.*]] = load i32, i32* [[TMP]], align 4
+; CHECK-NEXT:    [[C:%.*]] = add i32 [[A]], 1
+; CHECK-NEXT:    store i32 [[C]], i32* [[TMP]], align 4
+; CHECK-NEXT:    ret void
+; CHECK:       3:
+; CHECK-NEXT:    ret void
+;
+%1 = icmp eq %struct.ss* %b, null
+br i1 %1, label %2, label %3
+
+2:
+  %tmp = getelementptr %struct.ss, %struct.ss* %b, i32 0, i32 0
+  %a = load i32, i32* %tmp, align 4
+  %c = add i32 %a, 1
+  store i32 %c, i32* %tmp, align 4
+  ret void
+
+3:
+  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:    [[P:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 0
+; CHECK-NEXT:    store i32 1, i32* [[P]], align 8
+; CHECK-NEXT:    [[Q:%.*]] = getelementptr [[STRUCT_SS]], %struct.ss* [[S]], i32 0, i32 1
+; CHECK-NEXT:    store i64 2, i64* [[Q]], align 4
+; CHECK-NEXT:    [[S_0:%.*]] = getelementptr inbounds [[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 inbounds [[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]])
+; CHECK-NEXT:    ret i32 0
+;
+entry:
+  %S = alloca %struct.ss, align 32
+  %p = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 0
+  store i32 1, i32* %p, align 8
+  %q = getelementptr %struct.ss, %struct.ss* %S, i32 0, i32 1
+  store i64 2, i64* %q, align 4
+  call void @f(%struct.ss* byval(%struct.ss) align 4 %S) nounwind
+  ret i32 0
+}

llvm/test/Transforms/ArgumentPromotion/dbg.ll

 }
 
 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-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:%.*]] = getelementptr inbounds [[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:%.*]] = getelementptr inbounds [[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:    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/fp80.ll

 
 %struct.Foo = type { i32, i64 }
 @a = internal global %struct.Foo { i32 1, i64 2 }, align 8
 
 define void @run() {
 ; CHECK-LABEL: define {{[^@]+}}@run() {
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = tail call i8 @UseLongDoubleUnsafely(%union.u* byval([[UNION_U:%.*]]) align 16 bitcast (%struct.s* @b to %union.u*))
-; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr [[UNION_U]], %union.u* bitcast (%struct.s* @b to %union.u*), i32 0, i32 0
+; CHECK-NEXT:    [[DOT0:%.*]] = getelementptr inbounds [[UNION_U]], %union.u* bitcast (%struct.s* @b to %union.u*), i32 0, i32 0
 ; CHECK-NEXT:    [[DOT0_VAL:%.*]] = load x86_fp80, x86_fp80* [[DOT0]], align 16
 ; CHECK-NEXT:    [[TMP1:%.*]] = tail call x86_fp80 @UseLongDoubleSafely(x86_fp80 [[DOT0_VAL]])
 ; CHECK-NEXT:    [[TMP2:%.*]] = call i64 @AccessPaddingOfStruct(%struct.Foo* byval([[STRUCT_FOO:%.*]]) @a)
 ; CHECK-NEXT:    [[TMP3:%.*]] = call i64 @CaptureAStruct(%struct.Foo* byval([[STRUCT_FOO]]) @a)
 ; CHECK-NEXT:    ret void
 ;
 entry:
   tail call i8 @UseLongDoubleUnsafely(%union.u* byval(%union.u) align 16 bitcast (%struct.s* @b to %union.u*))

llvm/test/Transforms/ArgumentPromotion/pr32917.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --scrub-attributes
 ; RUN: opt < %s -argpromotion -S | FileCheck %s
 ; PR 32917
 
 @b = common local_unnamed_addr global i32 0, align 4
 @a = common local_unnamed_addr global i32 0, align 4
 
 define i32 @fn2() local_unnamed_addr {
 ; CHECK-LABEL: define {{[^@]+}}@fn2() local_unnamed_addr
 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 ; CHECK-NEXT:    [[TMP2:%.*]] = sext i32 [[TMP1]] to i64
 ; CHECK-NEXT:    [[TMP3:%.*]] = inttoptr i64 [[TMP2]] to i32*
-; CHECK-NEXT:    [[DOTIDX:%.*]] = getelementptr i32, i32* [[TMP3]], i64 -1
+; CHECK-NEXT:    [[DOTIDX:%.*]] = getelementptr inbounds i32, i32* [[TMP3]], i64 -1
 ; CHECK-NEXT:    [[DOTIDX_VAL:%.*]] = load i32, i32* [[DOTIDX]], align 4
 ; CHECK-NEXT:    call fastcc void @fn1(i32 [[DOTIDX_VAL]])
 ; CHECK-NEXT:    ret i32 undef
 ;
   %1 = load i32, i32* @b, align 4
   %2 = sext i32 %1 to i64
   %3 = inttoptr i64 %2 to i32*
   call fastcc void @fn1(i32* %3)

llvm/test/Transforms/ArgumentPromotion/preserve-inbounds-info-of-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
+
+%T = type { i32, i32, i32, i32 }
+@G = constant %T { i32 0, i32 0, i32 17, i32 25 }
+
+define internal i32 @f(%T* %p) {
+; CHECK-LABEL: define {{[^@]+}}@f
+; 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 inbounds %T, %T* %p, i64 0, i32 3
+  %b.gep = getelementptr inbounds %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 inbounds [[T:%.*]], %T* @G, i64 0, i32 2
+; CHECK-NEXT:    [[G_IDX_VAL:%.*]] = load i32, i32* [[G_IDX]]
+; CHECK-NEXT:    [[G_IDX1:%.*]] = getelementptr inbounds [[T]], %T* @G, i64 0, i32 3
+; CHECK-NEXT:    [[G_IDX1_VAL:%.*]] = load i32, i32* [[G_IDX1]]
+; CHECK-NEXT:    [[V:%.*]] = call i32 @f(i32 [[G_IDX_VAL]], i32 [[G_IDX1_VAL]])
+; CHECK-NEXT:    ret i32 [[V]]
+;
+entry:
+  %v = call i32 @f(%T* @G)
+  ret i32 %v
+}
+
+define internal i32 @g(%T* %p) {
+; CHECK-LABEL: define {{[^@]+}}@g
+; 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 inbounds %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 @caller2() {
+; CHECK-LABEL: define {{[^@]+}}@caller2()
+; 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 inbounds [[T]], %T* @G, i64 0, i32 3
+; CHECK-NEXT:    [[G_IDX1_VAL:%.*]] = load i32, i32* [[G_IDX1]]
+; CHECK-NEXT:    [[V:%.*]] = call i32 @g(i32 [[G_IDX_VAL]], i32 [[G_IDX1_VAL]])
+; CHECK-NEXT:    ret i32 [[V]]
+;
+entry:
+  %v = call i32 @g(%T* @G)
+  ret i32 %v
+}