Revert "[LLVM16][StatelessToStateful] DeterminePointerAlignment algorithm fix"

This PR reverts this commit: c4f288e

Author: bokrzesi

IGC/Compiler/Optimizer/OpenCLPasses/StatelessToStateful/StatelessToStateful.cpp

@@ -520,6 +520,59 @@ bool StatelessToStateful::pointerIsFromKernelArgument(Value &ptr) {
   return false;
 }
 
+static alignment_t determinePointerAlignment(Value *Ptr, const DataLayout &DL, AssumptionCache *AC,
+                                             Instruction *InsertionPt) {
+  alignment_t BestAlign = 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()) {
+    if (auto *LI = dyn_cast<LoadInst>(U)) {
+      // Load has an explicit alignment.
+      alignment_t LdAlign = LI->getAlign().value();
+      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 (StAlign > BestAlign)
+          BestAlign = StAlign;
+      }
+    } else if (auto *GEP = dyn_cast<GetElementPtrInst>(U)) {
+      // If the GEP's source element type is sized, we can guess an ABI
+      // alignment.
+      Type *BaseTy = GEP->getSourceElementType();
+      if (BaseTy && BaseTy->isSized()) {
+        alignment_t GEPAlign = DL.getABITypeAlign(BaseTy).value();
+        if (GEPAlign > BestAlign)
+          BestAlign = GEPAlign;
+      }
+    }
+  }
+
+  // 2) If this pointer is actually a function parameter, see if it has an
+  //    alignment attribute.
+  if (auto *Arg = dyn_cast<Argument>(Ptr)) {
+    if (Arg->hasAttribute(llvm::Attribute::Alignment)) {
+      if (MaybeAlign ArgAlign = Arg->getParamAlign()) {
+        alignment_t ArgAlignOrOne = ArgAlign.valueOrOne().value();
+        if (ArgAlignOrOne > BestAlign)
+          BestAlign = ArgAlignOrOne;
+      }
+    }
+  }
+
+  // 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);
+  if (Known > BestAlign)
+    BestAlign = Known.value();
+
+  return BestAlign;
+}
+
 bool StatelessToStateful::pointerIsPositiveOffsetFromKernelArgument(Function *F, Value *V, Value *&offset,
                                                                     unsigned int &argNumber, bool ignoreSyncBuffer) {
   const DataLayout *DL = &F->getParent()->getDataLayout();
@@ -572,9 +625,8 @@ bool StatelessToStateful::pointerIsPositiveOffsetFromKernelArgument(Function *F,
     //
     // Note that implicit arg is always aligned.
     bool isAlignedPointee = arg->isImplicitArg()
-      ? true
-      : getKnownAlignment((Value *)arg->getArg(), *DL, F->getEntryBlock().getFirstNonPHI(), AC) >= 4;
-
+                                ? true
+                                : determinePointerAlignment(base, *DL, AC, F->getEntryBlock().getFirstNonPHI()) >= 4;
 
     // If m_hasBufferOffsetArg is true, the offset argument is added to
     // the final offset to make it definitely positive. Thus skip checking

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)* align 4 %srcA, %spirv.Image._void_1_0_0_0_0_0_0 addrspace(1)* %img, i32 addrspace(1)* align 4 %dst) {
+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) {
 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)

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)* align 4 %srcA, %spirv.Image._void_1_0_0_0_0_0_1 addrspace(1)* %img, i32 addrspace(1)* align 4 %dst) {
+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) {
 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)

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)* align 4 %srcA, i32 %srcB, i32 addrspace(1)* align 4 %dst) {
+define spir_kernel void @test(i32 addrspace(1)* %srcA, i32 %srcB, i32 addrspace(1)* %dst) {
 entry:
   ; CHECK: %[[VAL_A:[0-9]+]] = load i32, i32 addrspace(131072)* %{{.*}}, align 4
   %ptrA = getelementptr inbounds i32, i32 addrspace(1)* %srcA, i64 1

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)* 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 {
+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 {
 ; CHECK-LABEL: @func_b(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr i32, i32 addrspace(1)* [[R:%.*]], i32 16, !dbg [[DBG104:![0-9]+]]

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)* 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 {
+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 {
 bb1:
   %add.ptr1 = getelementptr inbounds i32, i32 addrspace(1)* %r, i64 16
   %add.ptr2 = getelementptr inbounds i32, i32 addrspace(1)* %r, i64 128

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)* align 4 %in, i32 addrspace(1)* align 4 %out) {
+define spir_kernel void @test(i32 addrspace(1)* %in, i32 addrspace(1)* %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)* %{{.*}})

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)* align 4 %in, i32 addrspace(1)* align 4 %out) {
+define spir_kernel void @test(i32 addrspace(1)* %in, i32 addrspace(1)* %out) {
 entry:
   %arrayidx = getelementptr inbounds i32, i32 addrspace(1)* %out, i64 1
   %arrayidx1 = getelementptr inbounds i32, i32 addrspace(1)* %in, i64 1

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)* align 4 %srcA, i32 addrspace(1)* align 4 %srcB, i32 addrspace(1)* align 4 %srcC, i32 addrspace(1)* align 4 %dst) {
+define spir_kernel void @test(i32 addrspace(1)* %srcA, i32 addrspace(1)* %srcB, i32 addrspace(1)* %srcC, i32 addrspace(1)* %dst) {
 entry:
   %ptrA = getelementptr inbounds i32, i32 addrspace(1)* %srcA, i64 1
   ; CHECK: %[[VAL_A:[0-9]+]] = load i32, i32 addrspace(131072)* %{{.*}}, align 4