Fix scalarized GEP index for reinterpreted vectors in LowerGEPForPrivMem

The old scalarization advanced the GEP scalarized index by the number of
smaller vector elements when a GEP indexed through a reinterpreted
vector whose lane size differed from the promoted lane. This
over-advanced the index (e.g. using 8 for <8 x i32> over double lanes
instead of 4), producing incorrect accesses.

The fix:
- Track the promoted lane byte size (m_promotedLaneBytes) in
TransposeHelper and set it in TransposeHelperPromote's constructor.
- In TransposeHelper::getArrSizeAndEltType, when a vector is a
reinterpret of the promoted storage, compute the increment as
vector_byte_size / m_promotedLaneBytes instead of
vector_byte_size / small_element_size.

Author: michalpaszkowski

IGC/Compiler/CISACodeGen/LowerGEPForPrivMem.cpp

@@ -762,7 +762,15 @@ class TransposeHelperPromote : public TransposeHelper {
   AllocaInst *pVecAlloca;
   // location of lifetime starts
   llvm::SmallPtrSet<Instruction *, 4> pStartPoints;
-  TransposeHelperPromote(AllocaInst *pAI, const DataLayout &DL) : TransposeHelper(DL, false) { pVecAlloca = pAI; }
+  TransposeHelperPromote(AllocaInst *pAI, const DataLayout &DL) : TransposeHelper(DL, false) {
+    pVecAlloca = pAI;
+    // Determine promoted lane scalar type and record its size in bytes so that
+    // GEP indexing through reinterpreted vectors can advance the scalarized
+    // index in units of promoted lanes rather than the smaller vector elements.
+    llvm::Type *AllocTy = pAI->getAllocatedType();
+    llvm::Type *LaneTy = AllocTy->isVectorTy() ? cast<IGCLLVM::FixedVectorType>(AllocTy)->getElementType() : AllocTy;
+    m_promotedLaneBytes = (uint32_t)DL.getTypeAllocSize(LaneTy);
+  }
 };
 
 void LowerGEPForPrivMem::handleAllocaInst(llvm::AllocaInst *pAlloca) {
@@ -821,7 +829,15 @@ std::pair<unsigned int, Type *> TransposeHelper::getArrSizeAndEltType(Type *T) {
       auto *vTy = cast<IGCLLVM::FixedVectorType>(T);
       unsigned int vector_size_in_bytes = int_cast<unsigned int>(m_DL.getTypeAllocSize(T));
       unsigned int elt_size_in_bytes = int_cast<unsigned int>(m_DL.getTypeAllocSize(vTy->getElementType()));
-      arr_sz = vector_size_in_bytes / elt_size_in_bytes;
+      // If the vector is a reinterpret of the promoted storage (its element size
+      // differs from the promoted lane size), advance the scalarized index in
+      // units of promoted lanes, not in units of the smaller vector elements.
+      if (m_promotedLaneBytes != 0 && m_promotedLaneBytes != elt_size_in_bytes &&
+          (vector_size_in_bytes % m_promotedLaneBytes) == 0) {
+        arr_sz = vector_size_in_bytes / m_promotedLaneBytes;
+      } else {
+        arr_sz = vector_size_in_bytes / elt_size_in_bytes;
+      }
     }
     retTy = cast<VectorType>(T)->getElementType();
   } else {

IGC/Compiler/CISACodeGen/LowerGEPForPrivMem.hpp

@@ -137,7 +137,8 @@ class SOALayoutChecker : public llvm::InstVisitor<SOALayoutChecker, bool> {
 
 class TransposeHelper {
 public:
-  TransposeHelper(const llvm::DataLayout &DL, bool vectorIndex) : m_vectorIndex(vectorIndex), m_DL(DL) {}
+  TransposeHelper(const llvm::DataLayout &DL, bool vectorIndex)
+      : m_vectorIndex(vectorIndex), m_DL(DL), m_promotedLaneBytes(0) {}
   void HandleAllocaSources(llvm::Instruction *v, llvm::Value *idx);
   void handleGEPInst(llvm::GetElementPtrInst *pGEP, llvm::Value *idx);
   // Temporary, this is to replace HandleGEPInst
@@ -152,6 +153,10 @@ class TransposeHelper {
 protected:
   const llvm::DataLayout &m_DL;
   std::vector<llvm::Instruction *> m_toBeRemovedGEP;
+  // Size in bytes of one promoted lane element (base scalar chosen for the promoted alloca).
+  // Used to correctly scale indices when a use reinterprets memory as a vector
+  // of smaller element size (e.g. <8 x i32> over double lanes).
+  uint32_t m_promotedLaneBytes;
 
 private:
   bool m_vectorIndex;

IGC/Compiler/tests/LowerGEPForPrivMem/gep-reinterpret-index.ll

@@ -0,0 +1,56 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; RUN: igc_opt --opaque-pointers -igc-priv-mem-to-reg -S < %s 2>&1 | FileCheck %s
+
+; Verify correct scalarized GEP index advancement for reinterpreted vectors.
+; Before the fix, when storing a <8 x i32> vector into a promoted private alloca
+; whose base lane type is double (8 bytes), the legacy scalarization advanced
+; the linear index by 8 (number of i32 elements) instead of 4 (bytesCovered / promotedLaneBytes),
+; creating gaps (0..3, 8..11, ...) and skipping indices 4..7.
+; After the fix, the second vector store must populate lanes 4..7.
+
+; CHECK-LABEL: @test(
+; CHECK: alloca <16 x double>
+; First vector packet populates lanes 0..3
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 0
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 1
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 2
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 3
+; CHECK: store <16 x double>
+; Second vector packet must immediately fill lanes 4..7 (no gap / no i32 8 yet)
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 4
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 5
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 6
+; CHECK: insertelement <16 x double> {{.*}}, double {{.*}}, i32 7
+
+define spir_kernel void @test(ptr addrspace(1) %src) {
+entry:
+  ; Private array to be promoted: 16 doubles (128 bytes). Each <8 x i32> (32 bytes) spans 4 double lanes.
+  %priv = alloca [16 x double], align 8
+
+  ; Base pointer to first double.
+  %base = getelementptr inbounds [16 x double], ptr %priv, i32 0, i32 0
+
+  ; Load first packet and store.
+  %src.vec0 = load <8 x i32>, ptr addrspace(1) %src, align 32
+  store <8 x i32> %src.vec0, ptr %base, align 32
+
+  ; Second packet (should map immediately after first: lanes 4..7 post-promotion).
+  %src.vec1.ptr = getelementptr <8 x i32>, ptr addrspace(1) %src, i32 1
+  %src.vec1 = load <8 x i32>, ptr addrspace(1) %src.vec1.ptr, align 32
+  %vec.cast.1 = getelementptr <8 x i32>, ptr %base, i32 1
+  store <8 x i32> %src.vec1, ptr %vec.cast.1, align 32
+
+  ret void
+}
+
+!igc.functions = !{!1}
+!1 = !{ptr @test, !2}
+!2 = !{!3}
+!3 = !{!"function_type", i32 0}

IGC/Compiler/tests/LowerGEPForPrivMem/skip_i8_gep_non_constant_offset.ll

@@ -29,7 +29,7 @@ entry:
   %dst = alloca [64 x i32], align 4
   br label %for.body
 
-for.body:                                        ; preds = %entry, %for.body
+for.body:
   %idx = phi i64 [ 0, %entry ], [ %idx.next, %for.body ]
   %src.gep = getelementptr i8, ptr %src, i64 %idx
   %dst.gep = getelementptr i8, ptr %dst, i64 %idx