Handle implicit args buffer info in zebin

Related-To: NEO-5081, IGC-4710
Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

shared/source/device_binary_format/elf/zebin_elf.h

@@ -217,6 +217,7 @@ static constexpr ConstStringRef argBypointer("arg_bypointer");
 static constexpr ConstStringRef bufferOffset("buffer_offset");
 static constexpr ConstStringRef printfBuffer("printf_buffer");
 static constexpr ConstStringRef workDimensions("work_dimensions");
+static constexpr ConstStringRef implicitArgBuffer("implicit_arg_buffer");
 } // namespace ArgType
 namespace MemoryAddressingMode {
 static constexpr ConstStringRef stateless("stateless");
@@ -399,7 +400,8 @@ enum ArgType : uint8_t {
     ArgTypeArgBypointer,
     ArgTypeBufferOffset,
     ArgTypePrintfBuffer,
-    ArgTypeWorkDimensions
+    ArgTypeWorkDimensions,
+    ArgTypeImplicitArgBuffer
 };
 
 namespace PerThreadPayloadArgument {

shared/source/device_binary_format/zebin_decoder.cpp

@@ -373,6 +373,8 @@ bool readEnumChecked(const Yaml::Token *token, NEO::Elf::ZebinKernelMetadata::Ty
         out = ArgTypeT::ArgTypePrintfBuffer;
     } else if (tokenValue == PayloadArgument::ArgType::workDimensions) {
         out = ArgTypeT::ArgTypeWorkDimensions;
+    } else if (tokenValue == PayloadArgument::ArgType::implicitArgBuffer) {
+        out = ArgTypeT::ArgTypeImplicitArgBuffer;
     } else {
         outErrReason.append("DeviceBinaryFormat::Zebin::" + NEO::Elf::SectionsNamesZebin::zeInfo.str() + " : Unhandled \"" + tokenValue.str() + "\" argument type in context of " + context.str() + "\n");
         return false;
@@ -904,6 +906,11 @@ NEO::DecodeError populateArgDescriptor(const NEO::Elf::ZebinKernelMetadata::Type
         dst.payloadMappings.dispatchTraits.workDim = src.offset;
         break;
     }
+    case NEO::Elf::ZebinKernelMetadata::Types::Kernel::ArgTypeImplicitArgBuffer: {
+        dst.payloadMappings.implicitArgs.implcitArgsBuffer = src.offset;
+        dst.kernelAttributes.flags.requiresImplicitArgs = true;
+        break;
+    }
     }
 
     return DecodeError::Success;

shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp

@@ -4888,6 +4888,41 @@ TEST(PopulateArgDescriptorCrossthreadPayload, GivenArgTypeWorkDimensionsWhenSize
     EXPECT_EQ(32U, programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.dispatchTraits.workDim);
 }
 
+TEST(PopulateArgDescriptorCrossthreadPayload, GivenArgTypeImplicitArgBufferWhenPopulatingKernelDescriptorThenProperOffsetIsSetAndImplicitArgsAreRequired) {
+    NEO::ConstStringRef zeinfo = R"===(
+kernels:
+    - name : some_kernel
+      execution_env:
+        simd_size: 32
+      payload_arguments:
+        - arg_type:        implicit_arg_buffer
+          offset:          4
+          size:            8
+)===";
+    NEO::ProgramInfo programInfo;
+    ZebinTestData::ValidEmptyProgram zebin;
+    zebin.appendSection(NEO::Elf::SHT_PROGBITS, NEO::Elf::SectionsNamesZebin::textPrefix.str() + "some_kernel", {});
+    std::string errors, warnings;
+    auto elf = NEO::Elf::decodeElf(zebin.storage, errors, warnings);
+    ASSERT_NE(nullptr, elf.elfFileHeader) << errors << " " << warnings;
+
+    NEO::Yaml::YamlParser parser;
+    bool parseSuccess = parser.parse(zeinfo, errors, warnings);
+    ASSERT_TRUE(parseSuccess) << errors << " " << warnings;
+
+    NEO::ZebinSections zebinSections;
+    auto extractErr = NEO::extractZebinSections(elf, zebinSections, errors, warnings);
+    ASSERT_EQ(NEO::DecodeError::Success, extractErr) << errors << " " << warnings;
+
+    auto &kernelNode = *parser.createChildrenRange(*parser.findNodeWithKeyDfs("kernels")).begin();
+    auto err = NEO::populateKernelDescriptor(programInfo, elf, zebinSections, parser, kernelNode, errors, warnings);
+    EXPECT_EQ(NEO::DecodeError::Success, err);
+    EXPECT_TRUE(errors.empty()) << errors;
+    EXPECT_TRUE(warnings.empty()) << warnings;
+    EXPECT_EQ(4u, programInfo.kernelInfos[0]->kernelDescriptor.payloadMappings.implicitArgs.implcitArgsBuffer);
+    EXPECT_TRUE(programInfo.kernelInfos[0]->kernelDescriptor.kernelAttributes.flags.requiresImplicitArgs);
+}
+
 TEST(PopulateArgDescriptorCrossthreadPayload, GivenArgTypeWorkDimensionsWhenSizeIsInvalidThenPopulateKernelDescriptorFails) {
     NEO::KernelDescriptor kernelDescriptor;
     kernelDescriptor.payloadMappings.explicitArgs.resize(1);