Revert disable EnableWriteOldFPToStack

Revert disable EnableWriteOldFPToStack flag.

(cherry picked from commit 14c0772)

Author: Kotynia, Piotr

IGC/Compiler/CISACodeGen/EmitVISAPass.cpp

@@ -10388,6 +10388,14 @@ void EmitPass::emitStackAlloca(GenIntrinsicInst* GII)
 {
     // Static private mem access is done through the FP
     CVariable* pFP = m_currShader->GetFP();
+    if IGC_IS_FLAG_ENABLED(EnableWriteOldFPToStack)
+    {
+        // If we have written the previous FP to the current frame's start, the start of
+        // private memory will be offset by 16 bytes
+        CVariable* tempFP = m_currShader->GetNewVariable(pFP);
+        emitAddPointer(tempFP, pFP, m_currShader->ImmToVariable(getFPOffset(), ISA_TYPE_UD));
+        pFP = tempFP;
+    }
     CVariable* pOffset = m_currShader->GetSymbol(GII->getOperand(0));
     emitAddPointer(m_destination, pFP, pOffset);
 }
@@ -18708,13 +18716,55 @@ void EmitPass::emitPushFrameToStack(unsigned& pushSize)
     m_encoder->Copy(pFP, pSP);
     m_encoder->Push();
 
+    // Allocate 1 extra oword to store previous frame's FP
+    pushSize += IGC_IS_FLAG_ENABLED(EnableWriteOldFPToStack) ? SIZE_OWORD : 0;
+
     // Since we use unaligned oword writes, pushSize should be OW aligned address
     pushSize = int_cast<unsigned>(llvm::alignTo(pushSize, SIZE_OWORD));
 
     if (pushSize != 0)
     {
         // Update SP by pushSize
         emitAddPointer(pSP, pSP, m_currShader->ImmToVariable(pushSize, ISA_TYPE_UD));
+
+        if IGC_IS_FLAG_ENABLED(EnableWriteOldFPToStack)
+        {
+            // Store old FP value to current FP
+            CVariable* pOldFP = m_currShader->GetPrevFP();
+            // If previous FP is null (for kernel frame), we initialize it to 0
+            if (pOldFP == nullptr)
+            {
+                pOldFP = m_currShader->GetNewVariable(pFP);
+                m_encoder->Copy(pOldFP, m_currShader->ImmToVariable(0, pOldFP->GetType()));
+                m_encoder->Push();
+            }
+
+            pFP = ReAlignUniformVariable(pFP, EALIGN_GRF);
+            bool useA64 = (pFP->GetSize() == 8);
+            if (shouldGenerateLSC())
+            {
+                ResourceDescriptor resource;
+                resource.m_surfaceType = ESURFACE_STATELESS;
+                emitLSCStore(nullptr, pOldFP, pFP, 64, 1, 0, &resource, (useA64 ? LSC_ADDR_SIZE_64b : LSC_ADDR_SIZE_32b), LSC_DATA_ORDER_TRANSPOSE, 0, 1);
+                m_encoder->Push();
+            }
+            else
+            {
+                if (useA64)
+                    m_encoder->OWStoreA64(pOldFP, pFP, SIZE_OWORD, 0);
+                else {
+                    // FP is in units of BYTES, but OWStore requires units of OWORDS
+                    CVariable* offsetShr = m_currShader->GetNewVariable(1, ISA_TYPE_UD, EALIGN_DWORD, true, "FPOffset_OW");
+                    m_encoder->SetSimdSize(SIMDMode::SIMD1);
+                    m_encoder->SetNoMask();
+                    m_encoder->SetSrcRegion(0, 0, 1, 0);
+                    m_encoder->Shr(offsetShr, pFP, m_currShader->ImmToVariable(4, ISA_TYPE_UD));
+                    m_encoder->Push();
+                    m_encoder->OWStore(pOldFP, ESURFACE_STATELESS, nullptr, offsetShr, SIZE_OWORD, 0);
+                }
+                m_encoder->Push();
+            }
+        }
     }
 }
 

IGC/Compiler/CISACodeGen/EmitVISAPass.hpp

@@ -257,6 +257,7 @@ class EmitPass : public llvm::FunctionPass
     void emitFlushSamplerCache();
     void emitSurfaceInfo(llvm::GenIntrinsicInst* intrinsic);
 
+    static uint64_t getFPOffset() { return SIZE_OWORD; }
     void emitStackAlloca(llvm::GenIntrinsicInst* intrinsic);
     void emitVLAStackAlloca(llvm::GenIntrinsicInst* intrinsic);
 

IGC/Compiler/DebugInfo/ScalarVISAModule.cpp

@@ -135,6 +135,9 @@ llvm::StringRef ScalarVisaModule::GetVISAFuncName() const
     // matches that used by VISA.
     return getFunction()->getName();
 }
+uint64_t ScalarVisaModule::getFPOffset() const {
+    return EmitPass::getFPOffset();
+}
 
 bool ScalarVisaModule::usesSlot1ScratchSpill() const {
     return m_pShader->ProgramOutput()->getScratchSpaceUsageInSlot1();

IGC/Compiler/DebugInfo/ScalarVISAModule.h

@@ -102,6 +102,7 @@ class ScalarVisaModule final : public IGC::VISAModule {
     bool hasPTO() const  override {
         return getPerThreadOffset() != nullptr;
     }
+    uint64_t getFPOffset() const override;
     int getPTOReg() const override;
     int getFPReg() const override;
 

IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryResolution.cpp

@@ -251,6 +251,9 @@ bool PrivateMemoryResolution::runOnModule(llvm::Module& M)
                 return 0;
 
             uint32_t currFuncPrivateMem = (uint32_t)(funcIt->second.privateMemoryPerWI);
+            // Add 1 OWORD for FP stack write
+            if IGC_IS_FLAG_ENABLED(EnableWriteOldFPToStack)
+                currFuncPrivateMem += uint32_t(EmitPass::getFPOffset());
 
             CallGraphNode* Node = CG[F];
 
@@ -796,6 +799,26 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack)
 
     if (privateOnStack)
     {
+        // If the private memory is on the stack there may be a situation where
+        // some extra data is placed at the beginning of stack frame (e.g. prev FP).
+        // In that case, allocas' alignment may not be satisfied. To prevent this,
+        // a padding is added between that extra data and the private memory.
+        unsigned int allocasExtraOffset = 0;
+        unsigned int padding = 0;
+        if IGC_IS_FLAG_ENABLED(EnableWriteOldFPToStack)
+        {
+            allocasExtraOffset += uint32_t(EmitPass::getFPOffset());
+        }
+
+        if (allocasExtraOffset > 0)
+        {
+            alignment_t privateMemoryAlignment = m_ModAllocaInfo->getPrivateMemAlignment(m_currFunction);
+            padding = iSTD::Align(allocasExtraOffset, size_t(privateMemoryAlignment)) - allocasExtraOffset;
+        }
+
+        modMD->FuncMD[m_currFunction].privateMemoryPerWI += padding;
+        modMD->privateMemoryPerWI += padding;//redundant ?
+
         // Creates intrinsics that will be lowered in the CodeGen and will handle the stack-pointer
         Instruction* simdLaneId16 = entryBuilder.CreateCall(simdLaneIdFunc, llvm::None, VALUE_NAME("simdLaneId16"));
         Value* simdLaneId = entryBuilder.CreateIntCast(simdLaneId16, typeInt32, false, VALUE_NAME("simdLaneId"));
@@ -834,6 +857,10 @@ bool PrivateMemoryResolution::resolveAllocaInstructions(bool privateOnStack)
                 Value* increment = isUniform ? builder.getInt32(0) : simdLaneId;
                 Value* perLaneOffset = builder.CreateMul(increment, ConstantInt::get(typeInt32, bufferSize), VALUE_NAME("perLaneOffset"));
                 Value* totalOffset = builder.CreateAdd(bufferOffset, perLaneOffset, VALUE_NAME(pAI->getName() + ".totalOffset"));
+                if (padding > 0)
+                {
+                    totalOffset = builder.CreateAdd(totalOffset, ConstantInt::get(typeInt32, padding), VALUE_NAME(pAI->getName() + ".totalOffsetWithPadding"));
+                }
                 Function* stackAllocaFunc = GenISAIntrinsic::getDeclaration(m_currFunction->getParent(), GenISAIntrinsic::GenISA_StackAlloca);
                 Value* stackAlloca = builder.CreateCall(stackAllocaFunc, totalOffset, VALUE_NAME("stackAlloca"));
                 privateBuffer = builder.CreatePointerCast(stackAlloca, pAI->getType(), VALUE_NAME(pAI->getName() + ".privateBuffer"));

IGC/DebugInfo/DwarfCompileUnit.cpp

@@ -1276,13 +1276,12 @@ void CompileUnit::addSLMLocation(IGC::DIEBlock *Block, const DbgVariable &DV,
     // There is a private value in the current stack frame.
     // Location encoding is similar to a global variable except SIMD lane
     // location encoding and storage size connected to this, because since it is
-    // uniform we assume this size to be 0.
-    // 1 DW_OP_regx <Frame Pointer reg encoded>
-    // 2 DW_OP_const1u <bit-offset to Frame Pointer reg>
-    // 3 DW_OP_const1u 64, i.e. size in bits
-    // 4 DW_OP_INTEL_push_bit_piece_stack
-    // 6 DW_OP_plus_uconst storageOffset
-    // MD: StorageOffset -> the offset
+    // uniform we assume this size to be 0. 1 DW_OP_regx <Frame Pointer reg
+    // encoded> 2 DW_OP_const1u <bit-offset to Frame Pointer reg> 3
+    // DW_OP_const1u 64  , i.e. size in bits 4 DW_OP_INTEL_push_bit_piece_stack
+    // 5 DW_OP_plus_uconst  SIZE_OWORD        // i.e. 0x10 taken from
+    // getFPOffset(); same as emitted in EmitPass::emitStackAlloca() 6
+    // DW_OP_plus_uconst storageOffset      // MD: StorageOffset; the offset
     // where each variable is stored in the current stack frame
 
     const auto *VISAMod = Loc.GetVISAModule();
@@ -1323,6 +1322,11 @@ void CompileUnit::addSLMLocation(IGC::DIEBlock *Block, const DbgVariable &DV,
                                          // Frame Pointer reg>
     extractSubRegValue(Block, 64);
 
+    addUInt(Block, dwarf::DW_FORM_data1,
+            dwarf::DW_OP_plus_uconst); // 5 DW_OP_plus_uconst  SIZE_OWORD (taken
+                                       // from getFPOffset())
+    addUInt(Block, dwarf::DW_FORM_udata, VISAMod->getFPOffset());
+
     addUInt(Block, dwarf::DW_FORM_data1,
             dwarf::DW_OP_plus_uconst); // 6 DW_OP_plus_uconst storageOffset
     addUInt(Block, dwarf::DW_FORM_udata, storageOffset); // storageOffset
@@ -2825,13 +2829,11 @@ bool CompileUnit::buildFpBasedLoc(const DbgVariable &var, IGC::DIEBlock *Block,
   // 2 DW_OP_const1u <bit-offset to Frame Pointer reg>
   // 3 DW_OP_const1u 64  , i.e. size in bits
   // 4 DW_OP_INTEL_push_bit_piece_stack
-  // 5 DW_OP_push_simd_lane
-  // 6 DW_OP_const1u/2u/4u/8u  storageSize
-  // MD: StorageSize -> the size of the variable
-  // 7 DW_OP_mul
-  // 8 DW_OP_plus
-  // 9 DW_OP_plus_uconst storageOffset
-  // MD: StorageOffset -> the offset where
+  // 5 DW_OP_plus_uconst  SIZE_OWORD         // i.e. 0x10 taken from
+  // getFPOffset(); same as emitted in EmitPass::emitStackAlloca() 6
+  // DW_OP_push_simd_lane 7 DW_OP_const1u/2u/4u/8u  storageSize   // MD:
+  // StorageSize; the size of the variable 8 DW_OP_mul 9 DW_OP_plus 10
+  // DW_OP_plus_uconst storageOffset      // MD: StorageOffset; the offset where
   // each variable is stored in the current stack frame
 
   auto regNumFP = VISAMod->getFPReg();
@@ -2859,6 +2861,11 @@ bool CompileUnit::buildFpBasedLoc(const DbgVariable &var, IGC::DIEBlock *Block,
       bitOffsetToFPReg); // 2 DW_OP_const1u/2u <bit-offset to Frame Pointer reg>
   extractSubRegValue(Block, 64);
 
+  addUInt(Block, dwarf::DW_FORM_data1,
+          dwarf::DW_OP_plus_uconst); // 5 DW_OP_plus_uconst  SIZE_OWORD (taken
+                                     // from getFPOffset())
+  addUInt(Block, dwarf::DW_FORM_udata, VISAMod->getFPOffset());
+
   addUInt(Block, dwarf::DW_FORM_data1,
           DW_OP_INTEL_push_simd_lane);   // 6 DW_OP_INTEL_push_simd_lane
   addConstantUValue(Block, storageSize); // 7 DW_OP_const1u/2u/4u/8u storageSize

IGC/DebugInfo/VISAModule.hpp

@@ -549,6 +549,7 @@ class VISAModule {
   virtual bool hasPTO() const = 0;
   virtual int getPTOReg() const = 0;
   virtual int getFPReg() const = 0;
+  virtual uint64_t getFPOffset() const = 0;
   virtual bool usesSlot1ScratchSpill() const = 0;
 
   virtual llvm::ArrayRef<char> getGenDebug() const = 0;

IGC/VectorCompiler/lib/GenXCodeGen/GenXDebugInfo.cpp

@@ -1059,6 +1059,7 @@ class GenXFunction final : public IGC::VISAModule {
   bool hasPTO() const override { return false; }
   int getPTOReg() const override { return -1; }
   int getFPReg() const override { return -1; }
+  uint64_t getFPOffset() const override { return 16; }
 
   bool usesSlot1ScratchSpill() const override { return false; }
 

IGC/common/igc_flags.h

@@ -392,6 +392,7 @@ DECLARE_IGC_REGKEY(bool, AvoidUsingR0R1,                false, "Do not use r0 an
 DECLARE_IGC_REGKEY(bool, EnableGTLocationDebugging,     true, "Setting this to 1 (true) enables GT location expression emission for GPU debugger", true)
 DECLARE_IGC_REGKEY(bool, UseOffsetInLocation,           true,  "Setting this to 1 (true) preserves private base and per thread offset and removes preservation of any other debug variables", true)
 DECLARE_IGC_REGKEY(bool, EnableRelocations,             false, "Setting this to 1 (true) makes IGC emit relocatable ELF with debug info", true)
+DECLARE_IGC_REGKEY(bool, EnableWriteOldFPToStack,       true,  "Setting this to 1 (true) writes the caller frame's frame-pointer to the start of callee's frame on stack, to support stack walk", false)
 DECLARE_IGC_REGKEY(bool, ZeBinCompatibleDebugging,      true,  "Setting this to 1 (true) enables embed debug info in zeBinary", true)
 DECLARE_IGC_REGKEY(bool, DebugInfoEnforceAmd64EM,       false, "Enforces elf file with the debug infomation to have eMachine set to AMD64", false)
 DECLARE_IGC_REGKEY(bool, DebugInfoValidation,           false, "Enable optional (strict) checks to detect debug information inconsistencies", false)