[InstCombine][NFC] Baseline tests for D137212 Simplify chain of GEP with constant indices

[huangjd]

Summary

Baseline tests showing current optimizer can't simplify GEP (GEP (GEP p C1) I1) C2 where C1 and C2 are constants

[spatel]

llvm/test/Transforms/InstCombine/gep-merge-constant-indices.ll

277

It's not clear to me that this test is providing coverage for the intended constraint in the other patch.

Should we add a simplify for any gep like %3?
https://alive2.llvm.org/ce/z/w89_Y5

[huangjd]

llvm/test/Transforms/InstCombine/gep-merge-constant-indices.ll

277

GEP with zero offset is simplified away by visitGEPOfGEP regardless what the preceding GEP is, so there is no way to keep it in the output

[spatel]

llvm/test/Transforms/InstCombine/gep-merge-constant-indices.ll

277

Then do we really need this test?

Even with typed pointers, we could do this transform of a single GEP:
https://alive2.llvm.org/ce/z/EKc-rM
...but that transform does not exist. Is there a reason it does not exist?

To be clear, I don't think it has to delay this patch or D137212. I'm just curious if we are missing a more basic transform.

llvm/test/Transforms/InstCombine/gep-merge-constant-indices.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -passes=instcombine -opaque-pointers -S | FileCheck %s
 
 ; Test merging GEP of GEP with constant indices.
 
 target datalayout = "i24:8:8"
 
 %struct.A = type { [123 x i8], i32 }
 %struct.B = type { i8, [3 x i16], %struct.A, float }
 %struct.C = type { i8, i32, i32 }
 
+declare void @use(ptr %p)
+
 ; result = (i32*) p + 3
 define ptr @mergeBasic(ptr %p) {
 ; CHECK-LABEL: @mergeBasic(
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i32, ptr [[P:%.*]], i64 3
 ; CHECK-NEXT:    ret ptr [[TMP1]]
 ;
   %1 = getelementptr inbounds i32, ptr %p, i64 1
   %2 = getelementptr inbounds i32, ptr %1, i64 2

 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], ptr [[P:%.*]], i64 [[A:%.*]], i32 2
 ; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 1
 ; CHECK-NEXT:    ret ptr [[TMP2]]
 ;
   %1 = getelementptr inbounds %struct.C, ptr %p, i64 %a, i32 2
   %2 = getelementptr inbounds i32, ptr %1, i64 1
   ret ptr %2
 }
+
+; If the first and last in a chain of GEP are constant indexed, they can be
+; merged, even if the first GEP has multiple uses.
+; result = (i8*) ((i32*) p + a + b) + 22
+define ptr @gepChain1(ptr %p, i64 %a, i64 %b) {
+; CHECK-LABEL: @gepChain1(
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i64, ptr [[P:%.*]], i64 2
+; CHECK-NEXT:    call void @use(ptr nonnull [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 [[A:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i32, ptr [[TMP2]], i64 [[B:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds i16, ptr [[TMP3]], i64 3
+; CHECK-NEXT:    ret ptr [[TMP4]]
+;
+  %1 = getelementptr inbounds i64, ptr %p, i64 2
+  call void @use(ptr %1)
+  %2 = getelementptr inbounds i32, ptr %1, i64 %a
+  %3 = getelementptr inbounds i32, ptr %2, i64 %b
+  %4 = getelementptr inbounds i16, ptr %3, i64 3
+  ret ptr %4
+}
+
+; Constant indexed GEP cancel out.
+; result = (i32*) p + a + b
+define ptr @gepChain2(ptr %p, i64 %a, i64 %b) {
+; CHECK-LABEL: @gepChain2(
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i64, ptr [[P:%.*]], i64 2
+; CHECK-NEXT:    call void @use(ptr nonnull [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 [[A:%.*]]
+; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i32, ptr [[TMP2]], i64 [[B:%.*]]
+; CHECK-NEXT:    [[TMP4:%.*]] = getelementptr inbounds i16, ptr [[TMP3]], i64 -8
+; CHECK-NEXT:    ret ptr [[TMP4]]
+;
+  %1 = getelementptr inbounds i64, ptr %p, i64 2
+  call void @use(ptr %1)
+  %2 = getelementptr inbounds i32, ptr %1, i64 %a
+  %3 = getelementptr inbounds i32, ptr %2, i64 %b
+  %4 = getelementptr inbounds i16, ptr %3, i64 -8
+  ret ptr %4
+}
+
+; Negative test. If the last GEP offset is zero, do not merge since it is a
+; bitcast with no cost.
+define ptr @gepChainZeroOffset(ptr %p, i64 %a) {
+; CHECK-LABEL: @gepChainZeroOffset(
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i64, ptr [[P:%.*]], i64 2
+; CHECK-NEXT:    call void @use(ptr nonnull [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 [[A:%.*]]
+; CHECK-NEXT:    ret ptr [[TMP2]]
+;
+  %1 = getelementptr inbounds i64, ptr %p, i64 2
+  call void @use(ptr %1)
+  %2 = getelementptr inbounds i32, ptr %1, i64 %a
+  %3 = getelementptr inbounds [4 x i16], ptr %2, i64 1, i64 -4
+  ret ptr %3
+}
+
+; Negative test. Do not merge if a GEP in the middle has multiple use, such that
+; the transform is invalid.
+define ptr @gepChainMultipleUse(ptr %p, i64 %a) {
+; CHECK-LABEL: @gepChainMultipleUse(
+; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr inbounds i64, ptr [[P:%.*]], i64 2
+; CHECK-NEXT:    call void @use(ptr nonnull [[TMP1]])
+; CHECK-NEXT:    [[TMP2:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 [[A:%.*]]
+; CHECK-NEXT:    call void @use(ptr nonnull [[TMP2]])
+; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i32, ptr [[TMP2]], i64 3
+; CHECK-NEXT:    ret ptr [[TMP3]]
+;
+  %1 = getelementptr inbounds i64, ptr %p, i64 2
+  call void @use(ptr %1)
+  %2 = getelementptr inbounds i32, ptr %1, i64 %a
+  call void @use(ptr %2)
+  %3 = getelementptr inbounds i32, ptr %2, i64 3
+  ret ptr %3
+}