Handle single-index GEPs into flat aggregates in SimplifyConstant

In opaque pointer mode, GEPs that index into globals often have a
different shape. SimplifyConstant pass assumed two-index GEPs (0, index)
and directly used the second operand as an element index. However, it is
possible to address flat aggregates using single-index GEPs.

See the two examples below from SYCL_CTS-math_builtin_float_double_1_ocl
run in typed and opaque pointer mode.

Two-index GEP example:
%130 = getelementptr inbounds [2 x i32], [2 x i32] addrspace(2)* @__stgamma_ep_nofp64__ones, i64 0, i64 %129
%131 = bitcast i32 addrspace(2)* %130 to float addrspace(2)*
%132 = load float, float addrspace(2)* %131, align 4, !tbaa !5163, !noalias !5409

Single-index GEP example:
%103 = getelementptr inbounds float, ptr addrspace(2) @__stgamma_ep_nofp64__ones, i64 %102
%104 = load float, ptr addrspace(2) %103, align 4, !tbaa !5163, !noalias !5409

This patch changes the pass to always use the last GEP index as the
element selector. This works because the pass only transforms top-level
arrays of scalars/vectors. In these cases, the element being loaded is
always designated by the final GEP index (whether there are earlier
indices selecting the actual aggregate or single index in opaque pointer
mode).

Author: michalpaszkowski

IGC/Compiler/CISACodeGen/SimplifyConstant.cpp

@@ -146,6 +146,14 @@ void ConstantLoader::analyze() {
   matchSplat(CDA) || matchOddEven(CDA) || matchLadder2(CDA);
 }
 
+// Returns the dynamic element index of a GEP addressing a flat (unnested) aggregate. This is the last GEP index operand
+// which addresses array elements. Earlier index operands (if present) select the indexed array itself. However, the
+// number of index operands is variable and depends on the type.
+static Value *getGEPElementIndex(GetElementPtrInst *GEP) {
+  IGC_ASSERT(GEP && GEP->getNumIndices() >= 1);
+  return GEP->getOperand(1 + (GEP->getNumIndices() - 1));
+}
+
 void ConstantLoader::simplify() {
   if (Kind == CK_Unknown)
     return;
@@ -174,8 +182,8 @@ void ConstantLoader::simplify() {
       LoadInst *LI = dyn_cast<LoadInst>(*I++);
       if (!LI)
         continue;
-      IGC_ASSERT(GEP->getNumIndices() == 2);
-      Value *Index = GEP->getOperand(2);
+
+      Value *Index = getGEPElementIndex(GEP);
       Value *Val = V0;
       IRBuilder<> Builder(LI);
       if (Kind == CK_Ladder2) {
@@ -500,10 +508,8 @@ static void promote(GlobalVariable *GV, IGCLLVM::FixedVectorType *AllocaType, bo
     // might be Constant user in llvm.used
     if (!GEP || GEP->getParent()->getParent() != F)
       continue;
-    IGC_ASSERT(GEP->getNumIndices() == 2);
-    // This is the index to address the array, and the first index is to address
-    // the global variable itself.
-    Value *Index = GEP->getOperand(2);
+
+    Value *Index = getGEPElementIndex(GEP);
     // Demote the index type to int32 to avoid 64 multiplications during vISA
     // emission, e.g. it is illegal to emit Q x W.
     if (Index->getType()->getPrimitiveSizeInBits() > 32) {
@@ -570,10 +576,7 @@ static bool rewriteAsCmpSel(GlobalVariable *GV, Function &F) {
     if (!GEP || GEP->getParent()->getParent() != &F)
       continue;
 
-    // This is the index to address the array, and the first index is to
-    // address the global variable itself.
-    IGC_ASSERT(GEP->getNumIndices() == 2);
-    Value *Index = GEP->getOperand(2);
+    Value *Index = getGEPElementIndex(GEP);
     if (Index->getType()->getPrimitiveSizeInBits() > 32) {
       IRBuilder<> Builder(GEP);
       Index = Builder.CreateTrunc(Index, Builder.getInt32Ty());

IGC/Compiler/tests/SimplifyConstant/gep-single-index-operand.ll

@@ -0,0 +1,27 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; REQUIRES: llvm-14-plus
+; RUN: igc_opt --opaque-pointers -SimplifyConstant -S < %s 2>&1 | FileCheck %s
+
+; This test ensures SimplifyConstant pass supports flat GEPs with a single index operand.
+
+@g = dso_local unnamed_addr addrspace(2) constant [2 x i32] [i32 1065353216, i32 -1082130432], align 4
+
+define spir_kernel void @test(i64 %index, ptr %output) {
+; CHECK-LABEL: @test(
+; CHECK:    [[TRUNC:%.*]] = trunc i64 [[INDEX:%.*]] to i1
+; CHECK:    [[SELECT_I32:%.*]] = select i1 [[TRUNC]], i32 -1082130432, i32 1065353216
+; CHECK:    [[BITCAST:%.*]] = bitcast i32 [[SELECT_I32]] to float
+; CHECK:    store float [[BITCAST]], ptr [[OUTPUT:%.*]], align 4
+; CHECK:    ret void
+  %a = getelementptr inbounds float, ptr addrspace(2) @g, i64 %index
+  %b = load float, ptr addrspace(2) %a, align 4
+  store float %b, ptr %output, align 4
+  ret void
+}