[ConstantFold] Fold non-zero index GEP_GV vs GV comparison

[StephenFan]

Summary

When comparing non-zero index GEP_GV and GV, if GEP's offset less than
the size of GEP's GV and is non-negative, we can try to fold this comparison.

Fixes https://github.com/llvm/llvm-project/issues/48778

[lebedev.ri]

This review may be stuck/dead, consider abandoning if no longer relevant.
Removing myself as reviewer in attempt to clean dashboard.

llvm/lib/IR/ConstantFold.cpp

case Instruction::GetElementPtr: {
           if (!GV->hasExternalWeakLinkage() && CE1GEP->isInBounds())
             return ICmpInst::ICMP_UGT;
         }
       } else if (const GlobalValue *GV2 = dyn_cast<GlobalValue>(V2)) {
         if (const GlobalValue *GV = dyn_cast<GlobalValue>(CE1Op0)) {
           if (GV != GV2) {
             if (CE1GEP->hasAllZeroIndices())
               return areGlobalsPotentiallyEqual(GV, GV2);
+
+            const DataLayout &DL = GV->getParent()->getDataLayout();
+            TypeSize ValueSize =
+                GV->getParent()->getDataLayout().getTypeAllocSize(
+                    GV->getValueType());
+            APInt Offset(DL.getIndexTypeSizeInBits(CE1GEP->getType()), 0);
+            if (CE1GEP->accumulateConstantOffset(DL, Offset) &&
+                Offset.isNonNegative() && Offset.ult(ValueSize))
+              return areGlobalsPotentiallyEqual(GV, GV2);
+
             return ICmpInst::BAD_ICMP_PREDICATE;
           }
         }
       } else if (const auto *CE2GEP = dyn_cast<GEPOperator>(V2)) {
         // By far the most common case to handle is when the base pointers are
         // obviously to the same global.
         const Constant *CE2Op0 = cast<Constant>(CE2GEP->getPointerOperand());
         if (isa<GlobalValue>(CE1Op0) && isa<GlobalValue>(CE2Op0)) {

llvm/test/Other/constant-fold-gep.ll

; OPT: same_addrspace
   %p = getelementptr inbounds i8, i8* bitcast ([4 x i8] * @p0 to i8*), i32 2
   ret i8* %p
 ; OPT: ret i8* getelementptr inbounds ([4 x i8], [4 x i8]* @p0, i64 0, i64 2)
 }
 
 @gv1 = internal global i32 1
 @gv2 = internal global [1 x i32] [ i32 2 ]
 @gv3 = internal global [1 x i32] [ i32 2 ]
+@gv4 = internal global [2 x i32] [ i32 2, i32 2 ]
 
 ; Handled by TI-independent constant folder
 define i1 @gv_gep_vs_gv() {
   ret i1 icmp eq (i32* getelementptr inbounds ([1 x i32], [1 x i32]* @gv2, i32 0, i32 0), i32* @gv1)
 }
 ; PLAIN: gv_gep_vs_gv
 ; PLAIN: ret i1 false
 
+define i1 @gv_gep_vs_gv_non_zero() {
+  ret i1 icmp eq (i32* getelementptr inbounds ([2 x i32], [2 x i32]* @gv4, i32 0, i32 1), i32* @gv1)
+}
+; PLAIN: gv_gep_vs_gv_non_zero
+; PLAIN: ret i1 false
+
 define i1 @gv_gep_vs_gv_gep() {
   ret i1 icmp eq (i32* getelementptr inbounds ([1 x i32], [1 x i32]* @gv2, i32 0, i32 0), i32* getelementptr inbounds ([1 x i32], [1 x i32]* @gv3, i32 0, i32 0))
 }
 ; PLAIN: gv_gep_vs_gv_gep
 ; PLAIN: ret i1 false
 
 ; CHECK: attributes #0 = { nounwind }

llvm/test/Transforms/InstCombine/hoist-xor-by-constant-from-xor-by-value.ll

 @global_constant3 = external global [6 x [1 x i64]], align 1
 @global_constant4 = external global i64, align 1
 @global_constant5 = external global i16*, align 1
 
 define i16 @constantexpr2() {
 ; CHECK-LABEL: @constantexpr2(
 ; CHECK-NEXT:    [[I2:%.*]] = load i16*, i16** @global_constant5, align 1
 ; CHECK-NEXT:    [[I3:%.*]] = load i16, i16* [[I2]], align 1
-; CHECK-NEXT:    [[I5:%.*]] = xor i16 [[I3]], xor (i16 zext (i1 icmp ne (i64* getelementptr inbounds ([6 x [1 x i64]], [6 x [1 x i64]]* @global_constant3, i64 0, i64 5, i64 0), i64* @global_constant4) to i16), i16 -1)
+; CHECK-NEXT:    [[I5:%.*]] = xor i16 [[I3]], -2
 ; CHECK-NEXT:    ret i16 [[I5]]
 ;
   %i0 = icmp ne i64* getelementptr inbounds ([6 x [1 x i64]], [6 x [1 x i64]]* @global_constant3, i16 0, i16 5, i16 0), @global_constant4
   %i1 = zext i1 %i0 to i16
   %i2 = load i16*, i16** @global_constant5, align 1
   %i3 = load i16, i16* %i2, align 1
   %i4 = xor i16 %i3, %i1
   %i5 = xor i16 %i4, -1
   ret i16 %i5
 }