Avoid using %sp and %fp predefined variables

If a kernel uses VLA, but it doesn't use stack calls, then we can initilize
stack-related variables in a limited scope. Only stack and frame pointer need
to be initilized. All other stack-related variables like `ARGV`, `RETV`, etc. don't
need to be initialized as they are not needed for VLA handling.

Also `SP` and `FP` don't need to be initilized as predefined `%sp` and `%fp`
VISA variables. Using predefined variables is only necessary if stack calls
are present in a kernel.

Not using predefined `%sp` and `%fp` VISA variables allows to allocate any
register for stack and frame pointers.

Author: aratajew

IGC/Compiler/CISACodeGen/CShader.cpp

@@ -320,6 +320,25 @@ void CShader::InitializeStackVariables()
     }
 }
 
+// This function initializes the stack in a limited scope, only for the purpose
+// of handling VLA. It is intended to be called when VLA is used but stack calls
+// are not present. Only SP and PF variables are initialized. Note that these
+// variables are not initialized to the predefined %sp and %fp VISA variables
+// because it's not necessary. All other stack-related variables like ARGV,
+// RETV, etc. are also not initialized as they are not needed for VLA handling.
+void CShader::InitializeSPFPForVLA()
+{
+    IGC_ASSERT_MESSAGE(!HasStackCalls(), "InitializeSPFPForVLA should only be called if stack calls are not present!");
+
+    // Set the SP/FP variable types to match the private pointer size defined in the data layout
+    bool isA64Private = (GetContext()->getRegisterPointerSizeInBits(ADDRESS_SPACE_PRIVATE) == 64);
+
+    // create stack-pointer register
+    m_SP = GetNewVariable(1, (isA64Private ? ISA_TYPE_UQ : ISA_TYPE_UD), (isA64Private ? EALIGN_QWORD : EALIGN_DWORD), true, 1, "SP");
+    // create frame-pointer register
+    m_FP = GetNewVariable(1, (isA64Private ? ISA_TYPE_UQ : ISA_TYPE_UD), (isA64Private ? EALIGN_QWORD : EALIGN_DWORD), true, 1, "FP");
+}
+
 /// save FP of previous frame when entering a stack-call function
 void CShader::SaveStackState()
 {

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -11598,7 +11598,21 @@ void EmitPass::emitReturn(llvm::ReturnInst* inst)
 /// Initializes the kernel for stack call by initializing the SP and FP
 void EmitPass::InitializeKernelStack(Function* pKernel, CVariable* stackBufferBase)
 {
-    m_currShader->InitializeStackVariables();
+    if (m_currShader->HasStackCalls())
+    {
+        m_currShader->InitializeStackVariables();
+    }
+    else
+    {
+        // If there are no stack calls in pKernel, but it uses VLA,
+        // stack can be initialized in a limited scope, meaning that
+        // only SP and FP need to be initialized.
+        bool hasVLA = (m_FGA && m_FGA->getGroup(pKernel) &&
+            m_FGA->getGroup(pKernel)->hasVariableLengthAlloca()) || pKernel->hasFnAttribute("hasVLA");
+        IGC_ASSERT_MESSAGE(hasVLA, "Stack initialization, without presence of stack calls, is only allowed when VLA is used.");
+        m_currShader->InitializeSPFPForVLA();
+    }
+
     auto pCtx = getAnalysis<CodeGenContextWrapper>().getCodeGenContext();
     auto pModMD = pCtx->getModuleMetaData();
 

IGC/Compiler/CISACodeGen/ShaderCodeGen.hpp

@@ -270,6 +270,7 @@ class CShader
     bool hasFP() const { return m_FP != nullptr; }
 
     void InitializeStackVariables();
+    void InitializeSPFPForVLA();
     void SaveStackState();
     void RestoreStackState();
 

IGC/Compiler/tests/EmitVISAPass/stack-initialization-for-vla-without-stackcalls.ll

@@ -0,0 +1,81 @@
+;=========================== begin_copyright_notice ============================
+;
+; Copyright (C) 2025 Intel Corporation
+;
+; SPDX-License-Identifier: MIT
+;
+;============================ end_copyright_notice =============================
+; REQUIRES: llvm-14-plus, regkeys
+;
+; RUN: igc_opt --opaque-pointers -platformbmg -igc-emit-visa %s -regkey DumpVISAASMToConsole | FileCheck %s
+; ------------------------------------------------
+; EmitVISAPass
+; ------------------------------------------------
+
+; This test verifies stack-related variables initilization in case a kernel
+; uses VLA, but it doesn't use stack calls. In such scenario, stack-related
+; variables can be initilized in a very limited scope, meaning that only stack
+; pointer and frame pointer need to be initilized. Additionally, stack and
+; frame pointer don't need to be initilized as predefined %sp and %fp VISA
+; variables, they can just be a regular VISA variables.
+
+; CHECK-NOT: .decl SP{{.*}} alias=<%sp, 0>
+; CHECK-NOT: .decl FP{{.*}} alias=<%fp, 0>
+; CHECK-NOT: .decl ARGV{{.*}} alias=<%arg, 0>
+; CHECK-NOT: .decl RETV{{.*}} alias=<%retval, 0>
+
+; CHECK: add (M1_NM, 1) SP(0,0)<1> privateBase(0,0)<0;1,0> {{.*}}(0,0)<0;1,0>
+; CHECK: mov (M1_NM, 1) FP(0,0)<1> SP(0,0)<0;1,0>
+
+define spir_kernel void @test(ptr addrspace(1) %in, ptr addrspace(1) %out, <8 x i32> %r0, <8 x i32> %payloadHeader, ptr %privateBase, i32 %bufferOffset, i16 %localIdX, i16 %localIdY, i16 %localIdZ) #0 {
+entry:
+  %vlaSize = load i32, ptr addrspace(1) %in, align 4
+  %vlaStackAlloca = call ptr @llvm.genx.GenISA.VLAStackAlloca(i32 0, i32 %vlaSize)
+  %lidX = zext i16 %localIdX to i32
+  store i32 %lidX, ptr %vlaStackAlloca
+  ; ... some other basic blocks here ...
+  %val = load i32, ptr %vlaStackAlloca
+  store i32 %val, ptr addrspace(1) %out
+  ret void
+}
+
+declare ptr @llvm.genx.GenISA.VLAStackAlloca(i32, i32)
+
+attributes #0 = { "hasVLA" }
+
+!IGCMetadata = !{!0}
+!igc.functions = !{!22}
+
+!0 = !{!"ModuleMD", !1, !21}
+!1 = !{!"FuncMD", !2, !3}
+!2 = !{!"FuncMDMap[0]", ptr @test}
+!3 = !{!"FuncMDValue[0]", !4, !17}
+!4 = !{!"resAllocMD", !5}
+!5 = !{!"argAllocMDList", !6, !10, !11, !14, !15, !16, !31, !32}
+!6 = !{!"argAllocMDListVec[0]", !7, !8, !9}
+!7 = !{!"type", i32 0}
+!8 = !{!"extensionType", i32 -1}
+!9 = !{!"indexType", i32 -1}
+!10 = !{!"argAllocMDListVec[1]", !7, !8, !9}
+!11 = !{!"argAllocMDListVec[2]", !12, !8, !13}
+!12 = !{!"type", i32 1}
+!13 = !{!"indexType", i32 0}
+!14 = !{!"argAllocMDListVec[3]", !7, !8, !9}
+!15 = !{!"argAllocMDListVec[4]", !7, !8, !9}
+!16 = !{!"argAllocMDListVec[5]", !7, !8, !9}
+!17 = !{!"m_OpenCLArgTypeQualifiers", !18, !19, !20}
+!18 = !{!"m_OpenCLArgTypeQualifiersVec[0]", !""}
+!19 = !{!"m_OpenCLArgTypeQualifiersVec[1]", !""}
+!20 = !{!"m_OpenCLArgTypeQualifiersVec[2]", !""}
+!21 = !{!"isHDCFastClearShader", i1 false}
+!22 = !{ptr @test, !23}
+!23 = !{!24, !25}
+!24 = !{!"function_type", i32 0}
+!25 = !{!"implicit_arg_desc", !26, !27, !28, !29}
+!26 = !{i32 0}
+!27 = !{i32 1}
+!28 = !{i32 12}
+!29 = !{i32 14, !29}
+!30 = !{!"explicit_arg_num", i32 2}
+!31 = !{!"argAllocMDListVec[6]", !7, !8, !9}
+!32 = !{!"argAllocMDListVec[7]", !7, !8, !9}