[LLVM16][StatelessToStateful] DeterminePointerAlignment algorithm fix v4

bokrzesi · igcbot · commit e9587a3ca8cf · 2025-12-04T14:12:14.000+01:00
The DeterminePointerAlignment algorithm is analyzing alignment of load/store instructions. Before this fix, it was walking over all stores/loads and picking the highest alignment. The problem with this approach was that some loads/stores were used basing on control flow, which in practice meant that some loads/stores were never used. And we accidentally could use their alignment, which caused mismatch. Such case occured here, in the "__devicelib_memcpy", which utilized various memcpy strategies basing on sizes https://github.com/intel/llvm/blob/ee397f94cfc0034a24cb06221f90863a0203326f/libdevice/fallback-cstring.cpp#L47 ``` 22: ; preds = %19 %23 = getelementptr inbounds i8, ptr addrspace(4) %1, i64 %20 %24 = load i8, ptr addrspace(4) %23, align 1 here %25 = getelementptr inbounds i8, ptr addrspace(4) %0, i64 %20 store i8 %24, ptr addrspace(4) %25, align 1 here %26 = add nuw i64 %20, 1, !spirv.Decorations !15 br label %19 27: ; preds = %13 %28 = icmp eq i64 %16, 0 br i1 %28, label %29, label %58 29: ; preds = %27 %30 = and i64 %2, 3 %31 = lshr i64 %2, 2 br label %32 32: ; preds = %35, %29 %33 = phi i64 [ 0, %29 ], [ %41, %35 ] %34 = icmp ult i64 %33, %31 br i1 %34, label %35, label %42 35: ; preds = %32 %36 = bitcast ptr addrspace(4) %1 to ptr addrspace(4) %37 = getelementptr inbounds i32, ptr addrspace(4) %36, i64 %33 %38 = load i32, ptr addrspace(4) %37, align 4 here %39 = bitcast ptr addrspace(4) %0 to ptr addrspace(4) %40 = getelementptr inbounds i32, ptr addrspace(4) %39, i64 %33 store i32 %38, ptr addrspace(4) %40, align 4 here %41 = add nuw nsw i64 %33, 1, !spirv.Decorations !17 br label %32 ```
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.cpp b/IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.cpp
@@ -23,6 +23,7 @@ SPDX-License-Identifier: MIT
 #include "common/LLVMWarningsPop.hpp"
 #include <string>
 #include "Probe/Assertion.h"
+#include "PointersSettings.h"
 
 using namespace llvm;
 using namespace IGC;
@@ -520,23 +521,23 @@ bool StatelessToStateful::pointerIsFromKernelArgument(Value &ptr) {
   return false;
 }
 
-static alignment_t determinePointerAlignment(Value *Ptr, const DataLayout &DL, AssumptionCache *AC,
-                                             Instruction *InsertionPt) {
-  alignment_t BestAlign = 1;
+static Align determinePointerAlignmentTypedPointers(Value *ptr, const DataLayout &DL, AssumptionCache *AC,
+                                                    Instruction *insertionPt) {
+  Align BestAlign = Align(1);
 
   // 1) Examine uses: look for loads/stores (which may carry explicit
   //    alignment) or a GEP that reveals an ABI alignment from its element
   //    type.
-  for (User *U : Ptr->users()) {
+  for (User *U : ptr->users()) {
     if (auto *LI = dyn_cast<LoadInst>(U)) {
       // Load has an explicit alignment.
-      alignment_t LdAlign = LI->getAlign().value();
+      Align LdAlign = LI->getAlign();
       if (LdAlign > BestAlign)
         BestAlign = LdAlign;
     } else if (auto *SI = dyn_cast<StoreInst>(U)) {
       // Store sets alignment only if the pointer we store into is Ptr.
-      if (SI->getPointerOperand() == Ptr) {
-        alignment_t StAlign = SI->getAlign().value();
+      if (SI->getPointerOperand() == ptr) {
+        Align StAlign = SI->getAlign();
         if (StAlign > BestAlign)
           BestAlign = StAlign;
       }
@@ -545,7 +546,7 @@ static alignment_t determinePointerAlignment(Value *Ptr, const DataLayout &DL, A
       // alignment.
       Type *BaseTy = GEP->getSourceElementType();
       if (BaseTy && BaseTy->isSized()) {
-        alignment_t GEPAlign = DL.getABITypeAlign(BaseTy).value();
+        Align GEPAlign = DL.getABITypeAlign(BaseTy);
         if (GEPAlign > BestAlign)
           BestAlign = GEPAlign;
       }
@@ -554,10 +555,10 @@ static alignment_t determinePointerAlignment(Value *Ptr, const DataLayout &DL, A
 
   // 2) If this pointer is actually a function parameter, see if it has an
   //    alignment attribute.
-  if (auto *Arg = dyn_cast<Argument>(Ptr)) {
+  if (auto *Arg = dyn_cast<Argument>(ptr)) {
     if (Arg->hasAttribute(llvm::Attribute::Alignment)) {
       if (MaybeAlign ArgAlign = Arg->getParamAlign()) {
-        alignment_t ArgAlignOrOne = ArgAlign.valueOrOne().value();
+        Align ArgAlignOrOne = ArgAlign.valueOrOne();
         if (ArgAlignOrOne > BestAlign)
           BestAlign = ArgAlignOrOne;
       }
@@ -566,15 +567,43 @@ static alignment_t determinePointerAlignment(Value *Ptr, const DataLayout &DL, A
 
   // 3) Fallback: use LLVM's built-in assumption-based alignment analysis
   //    (based on a.o. llvm.assume intrinsics).
-  Align Known = getKnownAlignment(Ptr, DL, InsertionPt, AC);
+  Align Known = getKnownAlignment(ptr, DL, insertionPt, AC);
   if (Known > BestAlign)
-    BestAlign = Known.value();
+    BestAlign = Known;
 
   return BestAlign;
 }
 
-bool StatelessToStateful::pointerIsPositiveOffsetFromKernelArgument(Function *F, Value *V, Value *&offset,
-                                                                    unsigned int &argNumber, bool ignoreSyncBuffer) {
+static bool determinePointerAlignment(const KernelArg *arg, Value *base, const DataLayout &DL, Value *V,
+                                      AssumptionCache *AC, Instruction *insertionPt,
+                                      std::optional<llvm::Align> originalInstructionAlignment) {
+  if (arg->isImplicitArg())
+    return true;
+
+  auto desiredAlignmentLevel = 4;
+
+  // The intent of getKnownAlignment below is to check if any llvm.assume intrinsic provides
+  // a hint about the base pointer alignment
+  Align knownAlignment = getKnownAlignment(base, DL, insertionPt, AC);
+
+  if (knownAlignment >= desiredAlignmentLevel)
+    return true;
+
+  if (AreOpaquePointersEnabled()) {
+    if (originalInstructionAlignment.has_value() &&
+        IGC::isStatefulAddrSpace(base->getType()->getPointerAddressSpace())) {
+      knownAlignment = originalInstructionAlignment.value();
+    }
+  } else {
+    knownAlignment = determinePointerAlignmentTypedPointers(base, DL, AC, insertionPt);
+  }
+
+  return knownAlignment >= desiredAlignmentLevel;
+}
+
+bool StatelessToStateful::pointerIsPositiveOffsetFromKernelArgument(
+    Function *F, Value *V, Value *&offset, unsigned int &argNumber, bool ignoreSyncBuffer,
+    std::optional<llvm::Align> OriginalInstructionAlignment) {
   const DataLayout *DL = &F->getParent()->getDataLayout();
 
   AssumptionCache *AC = getAC(F);
@@ -626,9 +655,8 @@ bool StatelessToStateful::pointerIsPositiveOffsetFromKernelArgument(Function *F,
     // guarantted to be DW-aligned.)
     //
     // Note that implicit arg is always aligned.
-    bool isAlignedPointee = arg->isImplicitArg()
-                                ? true
-                                : determinePointerAlignment(base, *DL, AC, F->getEntryBlock().getFirstNonPHI()) >= 4;
+    auto insertionPt = F->getEntryBlock().getFirstNonPHI();
+    bool isAlignedPointee = determinePointerAlignment(arg, base, *DL, V, AC, insertionPt, OriginalInstructionAlignment);
 
     // If m_hasBufferOffsetArg is true, the offset argument is added to
     // the final offset to make it definitely positive. Thus skip checking
@@ -657,6 +685,7 @@ bool StatelessToStateful::pointerIsPositiveOffsetFromKernelArgument(Function *F,
         updateArgInfo(arg, gepProducesPositivePointer);
       }
     }
+
     if ((m_hasBufferOffsetArg || (gepProducesPositivePointer && isAlignedPointee)) &&
         getOffsetFromGEP(F, GEPs, argNumber, arg->isImplicitArg(), offset)) {
       return true;
@@ -922,12 +951,14 @@ void StatelessToStateful::promote() {
   resAllocMD->uavsNumType += m_promotionMap.size();
 }
 
-void StatelessToStateful::addToPromotionMap(Instruction &I, Value *Ptr) {
+void StatelessToStateful::addToPromotionMap(Instruction &I, Value *Ptr,
+                                            std::optional<llvm::Align> OriginalInstructionAlignment = std::nullopt) {
   Value *offset = nullptr;
   unsigned baseArgNumber = 0;
 
-  bool isPromotable = m_promotionMap.size() < maxPromotionCount &&
-                      pointerIsPositiveOffsetFromKernelArgument(m_F, Ptr, offset, baseArgNumber, true);
+  bool isPromotable =
+      m_promotionMap.size() < maxPromotionCount &&
+      pointerIsPositiveOffsetFromKernelArgument(m_F, Ptr, offset, baseArgNumber, true, OriginalInstructionAlignment);
 
   if (isPromotable) {
     InstructionInfo II(&I, Ptr, offset);
@@ -1026,7 +1057,7 @@ void StatelessToStateful::visitCallInst(CallInst &I) {
 
 void StatelessToStateful::visitLoadInst(LoadInst &I) {
   Value *ptr = I.getPointerOperand();
-  addToPromotionMap(I, ptr);
+  addToPromotionMap(I, ptr, I.getAlign());
 
   // check if there's non-kernel-arg load/store
   if (IGC_IS_FLAG_ENABLED(DumpHasNonKernelArgLdSt) && ptr != nullptr && !pointerIsFromKernelArgument(*ptr)) {
@@ -1038,7 +1069,7 @@ void StatelessToStateful::visitLoadInst(LoadInst &I) {
 
 void StatelessToStateful::visitStoreInst(StoreInst &I) {
   Value *ptr = I.getPointerOperand();
-  addToPromotionMap(I, ptr);
+  addToPromotionMap(I, ptr, I.getAlign());
 
   if (IGC_IS_FLAG_ENABLED(DumpHasNonKernelArgLdSt) && ptr != nullptr && !pointerIsFromKernelArgument(*ptr)) {
     ModuleMetaData *modMD = getAnalysis<MetaDataUtilsWrapper>().getModuleMetaData();
diff --git a/IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.hpp b/IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.hpp
@@ -82,7 +82,8 @@ class StatelessToStateful : public llvm::ModulePass, public llvm::InstVisitor<St
   bool getModuleUsesBindless();
 
   void findPromotableInstructions();
-  void addToPromotionMap(llvm::Instruction &I, llvm::Value *Ptr);
+  void addToPromotionMap(llvm::Instruction &I, llvm::Value *Ptr,
+                         std::optional<llvm::Align> OriginalInstructionAlignment);
 
   void promote();
   void promoteInstruction(InstructionInfo &InstInfo);
@@ -106,7 +107,8 @@ class StatelessToStateful : public llvm::ModulePass, public llvm::InstVisitor<St
   // ignoreSyncBuffer - when set to true, return false directly if V is from the implicit kernel
   // argument "sync buffer". sync buffer must be stateless access in ZEBinary path so cannot be promoted.
   bool pointerIsPositiveOffsetFromKernelArgument(llvm::Function *F, llvm::Value *V, llvm::Value *&offset,
-                                                 unsigned int &argNumber, bool ignoreSyncBuffer);
+                                                 unsigned int &argNumber, bool ignoreSyncBuffer,
+                                                 std::optional<llvm::Align> OriginalInstructionAlignment);
 
   // Check if the given pointer value can be traced back to any kernel argument.
   // return the kernel argument if found, otherwise return nullptr.
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/buffer_image-ro-buffer.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/buffer_image-ro-buffer.ll
@@ -25,7 +25,7 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3
 
 %spirv.Image._void_1_0_0_0_0_0_0 = type opaque
 
-define spir_kernel void @test(i32 addrspace(1)* %srcA, %spirv.Image._void_1_0_0_0_0_0_0 addrspace(1)* %img, i32 addrspace(1)* %dst) {
+define spir_kernel void @test(i32 addrspace(1)* align 4 %srcA, %spirv.Image._void_1_0_0_0_0_0_0 addrspace(1)* %img, i32 addrspace(1)* align 4 %dst) {
 entry:
   ; BTI for image has been assigned by OCLBIConverter
   %color = call <4 x i32> @llvm.genx.GenISA.ldptr.v4i32.p196608f32.p196608f32(i32 0, i32 0, i32 0, i32 0, float addrspace(196608)* undef, float addrspace(196608)* null, i32 0, i32 0, i32 0)
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/buffer_image-wo_buffer.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/buffer_image-wo_buffer.ll
@@ -20,7 +20,7 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f3
 
 %spirv.Image._void_1_0_0_0_0_0_1 = type opaque
 
-define spir_kernel void @test(i32 addrspace(1)* %srcA, %spirv.Image._void_1_0_0_0_0_0_1 addrspace(1)* %img, i32 addrspace(1)* %dst) {
+define spir_kernel void @test(i32 addrspace(1)* align 4 %srcA, %spirv.Image._void_1_0_0_0_0_0_1 addrspace(1)* %img, i32 addrspace(1)* align 4 %dst) {
 entry:
   ; BTI for image has been assigned by OCLBIConverter
   call void @llvm.genx.GenISA.typedwrite.p131072f32(float addrspace(131072)* null, i32 0, i32 0, i32 0, i32 0, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00)
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/buffer_scalar_buffer.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/buffer_scalar_buffer.ll
@@ -18,7 +18,7 @@
 ; CHECK: target datalayout = {{.*}}-p131072:32:32:32-p131073:32:32:32"
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-n8:16:32"
 
-define spir_kernel void @test(i32 addrspace(1)* %srcA, i32 %srcB, i32 addrspace(1)* %dst) {
+define spir_kernel void @test(i32 addrspace(1)* align 4 %srcA, i32 %srcB, i32 addrspace(1)* align 4 %dst) {
 entry:
   ; CHECK: %[[VAL_A:[0-9]+]] = load i32, i32 addrspace(131072)* %{{.*}}, align 4
   %ptrA = getelementptr inbounds i32, i32 addrspace(1)* %srcA, i64 1
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/has_non_kernel_arg_LdSt.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/has_non_kernel_arg_LdSt.ll
@@ -19,7 +19,7 @@
 ; CHECK: CheckModuleDebugify: PASS
 
 
-define spir_kernel void @func_b(i32 %n, i32 addrspace(1)* %r, <8 x i32> %r0, <8 x i32> %payloadHeader, i8* %privateBase, i8 addrspace(1)* %s2, i8 addrspace(1)* %s3, i32 %s4, i32 %s5, i32 %bufferOffset) #0 {
+define spir_kernel void @func_b(i32 %n, i32 addrspace(1)* align 4 %r, <8 x i32> %r0, <8 x i32> %payloadHeader, i8* %privateBase, i8 addrspace(1)* %s2, i8 addrspace(1)* %s3, i32 %s4, i32 %s5, i32 %bufferOffset) #0 {
 ; CHECK-LABEL: @func_b(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i32, i32 addrspace(1)* [[R:%.*]], i32 16, !dbg [[DBG104:![0-9]+]]
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/hoist_loads_typed_pointers.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/hoist_loads_typed_pointers.ll
@@ -9,7 +9,7 @@
 
 ; RUN: igc_opt --typed-pointers %s -S -o - -igc-stateless-to-stateful-resolution | FileCheck %s
 
-define spir_kernel void @func_with_phinode_1(i1 %n, i32 addrspace(1)* %r, <4 x i32> addrspace(1)* %otp, i64 %idx1, i64 %idx2, <8 x i32> %r0, <8 x i32> %payloadHeader, i8* %privateBase, i8 addrspace(1)* %s2, i8 addrspace(1)* %s3, i32 %s4, i32 %s5, i32 %bufferOffset) #0 {
+define spir_kernel void @func_with_phinode_1(i1 %n, i32 addrspace(1)* align 4 %r, <4 x i32> addrspace(1)* %otp, i64 %idx1, i64 %idx2, <8 x i32> %r0, <8 x i32> %payloadHeader, i8* %privateBase, i8 addrspace(1)* %s2, i8 addrspace(1)* %s3, i32 %s4, i32 %s5, i32 %bufferOffset) #0 {
 bb1:
   %add.ptr1 = getelementptr inbounds i32, i32 addrspace(1)* %r, i64 16
   %add.ptr2 = getelementptr inbounds i32, i32 addrspace(1)* %r, i64 128
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/simd_block_read.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/simd_block_read.ll
@@ -16,7 +16,7 @@
 ; CHECK: target datalayout = {{.*}}-p131072:32:32:32-p131073:32:32:32"
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-n8:16:32"
 
-define spir_kernel void @test(i32 addrspace(1)* %in, i32 addrspace(1)* %out) {
+define spir_kernel void @test(i32 addrspace(1)* align 4 %in, i32 addrspace(1)* align 4 %out) {
 entry:
   %ptrIn = getelementptr inbounds i32, i32 addrspace(1)* %in, i64 1
   ; CHECK: %[[V:[0-9]+]] = call i32 @llvm.genx.GenISA.simdBlockRead.i32.p131072i32(i32 addrspace(131072)* %{{.*}})
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/simd_block_write.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/simd_block_write.ll
@@ -16,7 +16,7 @@
 ; CHECK: target datalayout = {{.*}}-p131072:32:32:32-p131073:32:32:32"
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-n8:16:32"
 
-define spir_kernel void @test(i32 addrspace(1)* %in, i32 addrspace(1)* %out) {
+define spir_kernel void @test(i32 addrspace(1)* align 4 %in, i32 addrspace(1)* align 4 %out) {
 entry:
   %arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %out, i64 1
   %arrayidx1 = getelementptr inbounds i32, i32 addrspace(1)* %in, i64 1
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindful/unused_buffer_argument.ll b/IGC/Compiler/tests/StatelessToStateful/Bindful/unused_buffer_argument.ll
@@ -20,7 +20,7 @@
 ; CHECK: target datalayout = {{.*}}-p131072:32:32:32-p131073:32:32:32-p131074:32:32:32"
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-n8:16:32"
 
-define spir_kernel void @test(i32 addrspace(1)* %srcA, i32 addrspace(1)* %srcB, i32 addrspace(1)* %srcC, i32 addrspace(1)* %dst) {
+define spir_kernel void @test(i32 addrspace(1)* align 4 %srcA, i32 addrspace(1)* align 4 %srcB, i32 addrspace(1)* align 4 %srcC, i32 addrspace(1)* align 4 %dst) {
 entry:
   %ptrA = getelementptr inbounds i32, i32 addrspace(1)* %srcA, i64 1
   ; CHECK: %[[VAL_A:[0-9]+]] = load i32, i32 addrspace(131072)* %{{.*}}, align 4
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindless/no_additional_add_when_alignment_is_discoverable.ll b/IGC/Compiler/tests/StatelessToStateful/Bindless/no_additional_add_when_alignment_is_discoverable.ll
@@ -0,0 +1,110 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+; REQUIRES: llvm-16-plus
+; RUN: igc_opt --opaque-pointers %s -S -o - -igc-stateless-to-stateful-resolution -platformdg2 --target-addressing-mode bindless | FileCheck %s
+;
+; // Ensure that no unnecessary "add" is generated when alignment of the load is known (align 4)
+; CHECK-NOT: [[ADD:%.*]] = add {{.*}} %bufferOffset
+
+; Function Attrs: convergent nounwind
+define spir_kernel void @convolve_1d_horizontal(ptr addrspace(1) %src, ptr addrspace(1) %dst, ptr addrspace(1) %gaussian_kernel, i32 %diameter, <8 x i32> %r0, <3 x i32> %globalOffset, <3 x i32> %enqueuedLocalSize, i16 %localIdX, i16 %localIdY, i16 %localIdZ, ptr %privateBase, i64 %inlineSampler, i32 %bufferOffset, i32 %bindlessOffset) #0 {
+entry:
+br label %for.body.lr.ph.new
+
+for.body.lr.ph.new:                               ; preds = %for.body.lr.ph
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %for.body.lr.ph.new
+  %index = phi i32 [ 0, %for.body.lr.ph.new ], [ %inc.3, %for.body ]
+  %iter = phi i32 [ 0, %for.body.lr.ph.new ], [ %iterNext, %for.body ]
+
+  %idxprom = zext i32 %index to i64
+
+; // Random int value 500123
+  %ptrInStateFulAddrSpace = inttoptr i32 500123 to ptr addrspace(131073)
+  %arrayidx = getelementptr inbounds float, ptr addrspace(131073) %ptrInStateFulAddrSpace, i64 %idxprom
+  %load = load <4 x float>, ptr addrspace(131073) %arrayidx, align 4
+
+  %inc.3 = add nuw nsw i32 %index, 4
+  %iterNext = add i32 %iter, 4
+  %condition = icmp eq i32 %iterNext, 15
+  br i1 %condition, label %cleanup.cont, label %for.body
+
+cleanup.cont:
+  ret void
+}
+
+!igc.functions = !{!24}
+!IGCMetadata = !{!28}
+
+!4 = !{!5, !6, !11}
+!5 = !{!"function_type", i32 0}
+!6 = !{!"arg_desc", !7}
+!7 = !{null, !8, !9, !10}
+!8 = !{!"explicit_arg_num", i32 0}
+!9 = !{!"img_access_float_coords", i1 false}
+!10 = !{!"img_access_int_coords", i1 true}
+
+!11 = !{!"implicit_arg_desc", !12, !13, !14, !15, !16, !17, !18, !19, !21, !23}
+!12 = !{i32 0}
+!13 = !{i32 2}
+!14 = !{i32 7}
+!15 = !{i32 8}
+!16 = !{i32 9}
+!17 = !{i32 10}
+!18 = !{i32 13}
+!19 = !{i32 33, !20}
+!20 = !{!"explicit_arg_num", i32 18}
+!21 = !{i32 15, !22}
+!22 = !{!"explicit_arg_num", i32 2}
+!23 = !{i32 59, !22}
+
+!24 = !{ptr @convolve_1d_horizontal, !4}
+
+!28 = !{!"ModuleMD", !30, !163}
+!30 = !{!"compOpt", !65, !66, !67}
+
+!65 = !{!"HasPositivePointerOffset", i1 false}
+!66 = !{!"HasBufferOffsetArg", i1 true}
+!67 = !{!"BufferOffsetArgOptional", i1 true}
+
+!163 = !{!"FuncMD", !299, !300}
+
+!203 = !{!"srvsNumType", i32 0}
+!204 = !{!"samplersNumType", i32 0}
+
+!205 = !{!"argAllocMDList", !206, !210, !212, !216, !217, !218, !219, !220, !221, !222, !223, !224, !225, !226}
+!206 = !{!"argAllocMDListVec[0]", !207, !208, !209}
+!207 = !{!"type", i32 4}
+!208 = !{!"extensionType", i32 0}
+!209 = !{!"indexType", i32 0}
+!210 = !{!"argAllocMDListVec[1]", !207, !208, !211}
+!211 = !{!"indexType", i32 1}
+!212 = !{!"argAllocMDListVec[2]", !213, !214, !215}
+!213 = !{!"type", i32 0}
+!214 = !{!"extensionType", i32 -1}
+!215 = !{!"indexType", i32 -1}
+!216 = !{!"argAllocMDListVec[3]", !213, !214, !215}
+!217 = !{!"argAllocMDListVec[4]", !213, !214, !215}
+!218 = !{!"argAllocMDListVec[5]", !213, !214, !215}
+!219 = !{!"argAllocMDListVec[6]", !213, !214, !215}
+!220 = !{!"argAllocMDListVec[7]", !213, !214, !215}
+!221 = !{!"argAllocMDListVec[8]", !213, !214, !215}
+!222 = !{!"argAllocMDListVec[9]", !213, !214, !215}
+!223 = !{!"argAllocMDListVec[10]", !213, !214, !215}
+!224 = !{!"argAllocMDListVec[11]", !213, !214, !215}
+!225 = !{!"argAllocMDListVec[12]", !213, !214, !215}
+!226 = !{!"argAllocMDListVec[13]", !213, !214, !215}
+
+!299 = !{!"FuncMDMap[1]", ptr @convolve_1d_horizontal}
+!300 = !{!"FuncMDValue[1]", !306}
+
+!306 = !{!"resAllocMD", !203, !204, !205, !307, !308, !309}
+!307 = !{!"uavsNumType", i32 0}
+!308 = !{!"argAllocMDList"}
+!309 = !{!"inlineSamplersMD"}
diff --git a/IGC/Compiler/tests/StatelessToStateful/Bindless/no_additional_add_when_alignment_is_discoverable_typed.ll b/IGC/Compiler/tests/StatelessToStateful/Bindless/no_additional_add_when_alignment_is_discoverable_typed.ll
diff --git a/IGC/ocloc_tests/optimizations/StatelessToStateful/AlignmentEdgeCase.cl b/IGC/ocloc_tests/optimizations/StatelessToStateful/AlignmentEdgeCase.cl
