AlignmentAnalysis: set correct dst alignment for memcpy from

global constant

If memcpy source is zeroinitialized constant global, memcpy is
equivalent to memset to zero. In this case alignment can be set based
only on destination.

This change also removes early run of LLVM's MemCpy Optimization pass
when Khronos SPIR-V translator is used, as there is no longer need to
change memcpy to memsets before AlignmentAnalysis.

(cherry picked from commit 10bc149)

Author: pkwasnie-intel

IGC/AdaptorOCL/UnifyIROCL.cpp

@@ -331,7 +331,6 @@ static void CommonOCLBasedPasses(
 #ifdef IGC_SCALAR_USE_KHRONOS_SPIRV_TRANSLATOR
     mpmSPIR.add(new PreprocessSPVIR());
     mpmSPIR.add(new PromoteBools());
-    mpmSPIR.add(llvm::createMemCpyOptPass());
 #endif // IGC_SCALAR_USE_KHRONOS_SPIRV_TRANSLATOR
     mpmSPIR.add(new TypesLegalizationPass());
     mpmSPIR.add(new TargetLibraryInfoWrapperPass());

IGC/Compiler/Optimizer/OpenCLPasses/AlignmentAnalysis/AlignmentAnalysis.cpp

@@ -474,6 +474,32 @@ void AlignmentAnalysis::SetInstAlignment(MemSetInst& I)
 
 void AlignmentAnalysis::SetInstAlignment(MemCpyInst& I)
 {
+    std::function<bool(Value*)> isConstGlobalZero = [&](Value* V)
+    {
+        if (auto* GEP = dyn_cast<GetElementPtrInst>(V))
+            return isConstGlobalZero(GEP->getPointerOperand());
+
+        if (auto* GV = dyn_cast<GlobalVariable>(V))
+        {
+            if (!GV->isConstant())
+                return false;
+
+            if (auto* initializer = GV->getInitializer())
+                return initializer->isZeroValue();
+        }
+
+        return false;
+    };
+
+    // If memcpy source is zeroinitialized constant global, memcpy is equivalent to memset to zero.
+    // In this case, we can set the alignment of memcpy to the alignment of its destination only.
+    if (isConstGlobalZero(I.getRawSource()))
+    {
+        auto alignment = IGCLLVM::Max(IGCLLVM::getDestAlign(I), IGCLLVM::Align(getAlignValue(I.getRawDest())));
+        I.setDestAlignment(alignment);
+        return;
+    }
+
     // Set the align attribute of the memcpy based on the minimum alignment of its source and dest fields
     auto minRawAlignment = iSTD::Min(getAlignValue(I.getRawDest()), getAlignValue(I.getRawSource()));
     auto alignment = IGCLLVM::Max(IGCLLVM::getDestAlign(I), IGCLLVM::Align(minRawAlignment));

IGC/Compiler/tests/AlignmentAnalysis/align_memcpy.ll

@@ -0,0 +1,46 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2024 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+
+; RUN: igc_opt --igc-fix-alignment -S < %s 2>&1 | FileCheck %s
+
+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"
+target triple = "spir64-unknown-unknown"
+
+@globalConstantZero = internal unnamed_addr addrspace(2) constant [8 x i8] zeroinitializer
+@globalNonconstantZero = internal unnamed_addr addrspace(2) global [8 x i8] zeroinitializer
+
+; memcpy from a zeroinitialized constant global is equivalent to memset to zero.
+; In this case, we can set the alignment of memcpy based only on destination pointer.
+;
+; CHECK-LABEL: @memcpy_from_global_constant_zero(
+; CHECK:         call void @llvm.memcpy.p0i8.p2i8.i64(i8* align 8 %2, i8 addrspace(2)* %3, i64 8, i1 false)
+define void @memcpy_from_global_constant_zero() {
+entry:
+  %0 = alloca [5 x [6 x double]], align 8
+  %1 = getelementptr inbounds [5 x [6 x double]], [5 x [6 x double]]* %0, i64 0, i64 0, i64 0
+  %2 = bitcast double* %1 to i8*
+  %3 = getelementptr inbounds [8 x i8], [8 x i8] addrspace(2)* @globalConstantZero, i32 0, i32 0
+  call void @llvm.memcpy.p0i8.p2i8.i64(i8* %2, i8 addrspace(2)* %3, i64 8, i1 false)
+  ret void
+}
+
+; memcpy from a non-constant global has to be aligned based on both source and destination pointers.
+;
+; CHECK-LABEL: @memcpy_from_global_nonconstant_zero(
+; CHECK:         call void @llvm.memcpy.p0i8.p2i8.i64(i8* align 1 %2, i8 addrspace(2)* %3, i64 8, i1 false)
+define void @memcpy_from_global_nonconstant_zero() {
+entry:
+  %0 = alloca [5 x [6 x double]], align 8
+  %1 = getelementptr inbounds [5 x [6 x double]], [5 x [6 x double]]* %0, i64 0, i64 0, i64 0
+  %2 = bitcast double* %1 to i8*
+  %3 = getelementptr inbounds [8 x i8], [8 x i8] addrspace(2)* @globalNonconstantZero, i32 0, i32 0
+  call void @llvm.memcpy.p0i8.p2i8.i64(i8* %2, i8 addrspace(2)* %3, i64 8, i1 false)
+  ret void
+}
+
+declare void @llvm.memcpy.p0i8.p2i8.i64(i8* noalias nocapture writeonly, i8 addrspace(2)* noalias nocapture readonly, i64, i1 immarg)

IGC/ocloc_tests/SPIRV-Asm/OpCopyMemorySized_alignment.spvasm

@@ -9,6 +9,7 @@
 ; Test if in both cases AlignmentAnalysis pass assigns correct allignment to pointer.
 
 ; REQUIRES: regkeys, spirv-as, pvc-supported
+; UNSUPPORTED: legacy-translator
 ; RUN: spirv-as --target-env spv1.0 -o %t.spv %s
 ; RUN: ocloc compile -spirv_input -file %t.spv -device pvc -options " -igc_opts 'PrintToConsole=1 PrintAfter=AlignmentAnalysisPass'" 2>&1 | FileCheck %s
 
@@ -55,6 +56,7 @@
 ; CHECK-LABEL: @test(
 ; CHECK-NOT:     call void @llvm.memcpy
 ; CHECK:         [[ALLOCA:%.*]] = alloca %struct.complex
-; CHECK:         [[PTR:%.*]] = bitcast %struct.complex* [[ALLOCA]] to i8*
-; CHECK:         call void @llvm.memset.p0i8.i64(i8* align 8 [[PTR]], i8 0, i64 16, i1 false)
+; CHECK:         [[DST:%.*]] = bitcast %struct.complex* [[ALLOCA]] to i8*
+; CHECK:         [[SRC:%.*]] = getelementptr inbounds [16 x i8], [16 x i8] addrspace(2)* @0, i32 0, i32 0
+; CHECK:         call void @llvm.memcpy.p0i8.p2i8.i64(i8* align 8 [[DST]], i8 {{.*}}[[SRC]], i64 16, i1 false)
 ; CHECK:         ret void