[InstSimplify] Restrict a GEP transform to avoid provenance changes

[nagisa]

Summary

This is a follow-up to D98588, and fixes the inline FIXME about a GEP-related simplification not
preserving the provenance.

https://alive2.llvm.org/ce/z/qbQoAY

Additional tests were added in rGf125f28afdb5: [InstSimplify] Add additional GEP transform tests & regenerate

Depends on D98672

[nagisa]

regenerate test cases

[nagisa]

revert the comments

[lebedev.ri]

Can you please split this into two patches: NFC refactoring, and the actual change?

[nagisa]

rebase onto D98672

[nagisa]

I split the NFCs out into a different diff. I also revised the approach slightly in an attempt to reduce code duplication. LMK if that (e.g. P's capture by reference) seems too magical, and I'm happy to revert to duplicating the checks.

[lebedev.ri]

Looks fine to me, and surprisingly doesn't have much impact
https://llvm-compile-time-tracker.com/compare.php?from=9575c48b8959dae3c3e39e0227435ae6ebd71443&to=100c8de5c743c99b50b5ac2ec33456b470ddc512&stat=instructions

Thanks.

llvm/lib/Analysis/InstructionSimplify.cpp

if (!IsScalableVec && Ty->isSized()) {
       // getelementptr P, N -> P if P points to a type of zero size.
       if (TyAllocSize == 0 && Ops[0]->getType() == GEPTy)
         return Ops[0];
 
       // The following transforms are only safe if the ptrtoint cast
       // doesn't truncate the pointers.
       if (Ops[1]->getType()->getScalarSizeInBits() ==
           Q.DL.getPointerSizeInBits(AS)) {
-        auto CanSimplify = [GEPTy, &P]() -> bool {
-          // FIXME: The following transforms are only legal if P and V have the
-          // same provenance (PR44403). Check whether getUnderlyingObject() is
-          // the same?
-          return P->getType() == GEPTy;
+        auto CanSimplify = [GEPTy, &P, V = Ops[0]]() -> bool {
+          return P->getType() == GEPTy &&
+                 getUnderlyingObject(P) == getUnderlyingObject(V);
         };
         // getelementptr V, (sub P, V) -> P if P points to a type of size 1.
         if (TyAllocSize == 1 &&
             match(Ops[1], m_Sub(m_PtrToInt(m_Value(P)),
                                 m_PtrToInt(m_Specific(Ops[0])))) &&
             CanSimplify())
           return P;
 

llvm/test/Transforms/InstSimplify/gep.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instsimplify < %s | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 %struct.A = type { [7 x i8] }
 
 define %struct.A* @test1(%struct.A* %b, %struct.A* %e) {
 ; CHECK-LABEL: @test1(
-; CHECK-NEXT:    ret %struct.A* [[E:%.*]]
+; CHECK-NEXT:    [[E_PTR:%.*]] = ptrtoint %struct.A* [[E:%.*]] to i64
+; CHECK-NEXT:    [[B_PTR:%.*]] = ptrtoint %struct.A* [[B:%.*]] to i64
+; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[E_PTR]], [[B_PTR]]
+; CHECK-NEXT:    [[SDIV:%.*]] = sdiv exact i64 [[SUB]], 7
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds [[STRUCT_A:%.*]], %struct.A* [[B]], i64 [[SDIV]]
+; CHECK-NEXT:    ret %struct.A* [[GEP]]
 ;
   %e_ptr = ptrtoint %struct.A* %e to i64
   %b_ptr = ptrtoint %struct.A* %b to i64
   %sub = sub i64 %e_ptr, %b_ptr
   %sdiv = sdiv exact i64 %sub, 7
   %gep = getelementptr inbounds %struct.A, %struct.A* %b, i64 %sdiv
   ret %struct.A* %gep
 }
 
 define i8* @test2(i8* %b, i8* %e) {
 ; CHECK-LABEL: @test2(
-; CHECK-NEXT:    ret i8* [[E:%.*]]
+; CHECK-NEXT:    [[E_PTR:%.*]] = ptrtoint i8* [[E:%.*]] to i64
+; CHECK-NEXT:    [[B_PTR:%.*]] = ptrtoint i8* [[B:%.*]] to i64
+; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[E_PTR]], [[B_PTR]]
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i8, i8* [[B]], i64 [[SUB]]
+; CHECK-NEXT:    ret i8* [[GEP]]
 ;
   %e_ptr = ptrtoint i8* %e to i64
   %b_ptr = ptrtoint i8* %b to i64
   %sub = sub i64 %e_ptr, %b_ptr
   %gep = getelementptr inbounds i8, i8* %b, i64 %sub
   ret i8* %gep
 }
 
 define i64* @test3(i64* %b, i64* %e) {
 ; CHECK-LABEL: @test3(
-; CHECK-NEXT:    ret i64* [[E:%.*]]
+; CHECK-NEXT:    [[E_PTR:%.*]] = ptrtoint i64* [[E:%.*]] to i64
+; CHECK-NEXT:    [[B_PTR:%.*]] = ptrtoint i64* [[B:%.*]] to i64
+; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[E_PTR]], [[B_PTR]]
+; CHECK-NEXT:    [[ASHR:%.*]] = ashr exact i64 [[SUB]], 3
+; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i64, i64* [[B]], i64 [[ASHR]]
+; CHECK-NEXT:    ret i64* [[GEP]]
 ;
   %e_ptr = ptrtoint i64* %e to i64
   %b_ptr = ptrtoint i64* %b to i64
   %sub = sub i64 %e_ptr, %b_ptr
   %ashr = ashr exact i64 %sub, 3
   %gep = getelementptr inbounds i64, i64* %b, i64 %ashr
   ret i64* %gep
 }