Xclbin to ELF flow migration for aie2 (#81)

HimanshuChoudhary-Xilinx · web-flow · commit b7f0754b758b · 2025-04-10T11:08:30.000-07:00
Signed-off-by: HimanshuChoudhary-Xilinx &lt;Himanshu.Choudhary@amd.com&gt;
diff --git a/src/cpp/assembler/aiebu_assembler.cpp b/src/cpp/assembler/aiebu_assembler.cpp
@@ -56,6 +56,11 @@ aiebu_assembler(buffer_type type,
     aiebu::assembler a(assembler::elf_type::aie2ps_asm);
     elf_data = a.process(buffer1, libs, libpaths, patch_json);
   }
+  else if (type == buffer_type::config)
+  {
+    aiebu::assembler a(assembler::elf_type::config);
+    elf_data = a.process(buffer1, libs, libpaths, patch_json, buffer2);
+  }
   else {
     throw error(error::error_code::invalid_buffer_type, "Buffer_type not supported !!!");
   }
diff --git a/src/cpp/assembler/assembler.cpp b/src/cpp/assembler/assembler.cpp
@@ -12,6 +12,8 @@
 #include "elfwriter.h"
 #include "encoder.h"
 #include "preprocessor.h"
+#include "elf/config/config_elfwriter.h"
+#include "config_preprocessor.h"
 
 #include "aiebu/aiebu_error.h"
 
@@ -48,6 +50,12 @@ assembler(const elf_type type)
     m_elfwriter = std::make_unique<aie2ps_elf_writer>();
     m_ppi = std::make_shared<aie2ps_preprocessor_input>();
   }
+  else if (type == elf_type::config)  {
+    m_preprocessor = std::make_unique<config_preprocessor>();
+    m_enoder = std::make_unique<aie2_blob_encoder>();
+    m_elfwriter = std::make_unique<config_elf_writer>();
+    m_ppi = std::make_shared<config_preprocessor_input>();
+  }
   else {
     throw error(error::error_code::invalid_buffer_type ,"Invalid elf type!!!");
   }
diff --git a/src/cpp/assembler/assembler.h b/src/cpp/assembler/assembler.h
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #ifndef _ADSM_COMMOM_ASSEMBLER_H_
 #define _ADSM_COMMOM_ASSEMBLER_H_
@@ -29,7 +29,8 @@ class assembler
     aie2_transaction_blob,
     aie2_dpu_blob,
     aie2ps_asm,
-    aie2_asm
+    aie2_asm,
+    config
   };
 
   explicit assembler(const elf_type type);
diff --git a/src/cpp/common/file_utils.h b/src/cpp/common/file_utils.h
@@ -22,6 +22,10 @@ readfile(const std::string& filename)
 
   std::ifstream input(filename, std::ios::in | std::ios::binary);
   auto file_size = std::filesystem::file_size(filename);
+
+  if (!file_size)
+    throw error(error::error_code::invalid_asm, "filename " + filename + " is empty!!");
+
   std::vector<char> buffer(file_size);
   input.read(buffer.data(), static_cast<std::streamsize>(file_size));
   return buffer;
diff --git a/src/cpp/common/symbol.h b/src/cpp/common/symbol.h
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #ifndef _AIEBU_COMMOM_SYMBOL_H_
 #define _AIEBU_COMMOM_SYMBOL_H_
@@ -22,7 +22,8 @@ class symbol
     shim_dma_48 = 5,
     shim_dma_57_aie4 = 6,
     control_packet_57 = 7,
-    unknown = 8,
+    address_64 = 8,
+    unknown = 9,
   };
 
 private:
diff --git a/src/cpp/common/writer.h b/src/cpp/common/writer.h
@@ -1,12 +1,13 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #ifndef _AIEBU_COMMON_WRITER_H_
 #define _AIEBU_COMMON_WRITER_H_
 
 #include <map>
 #include <string>
 #include <vector>
+#include <unordered_map>
 #include "symbol.h"
 #include "code_section.h"
 
@@ -19,10 +20,14 @@ class writer
   const code_section m_type;
   std::vector<uint8_t> m_data;
   std::vector<symbol> m_symbols;
+  std::unordered_map<std::string, std::string> m_metadata;
 
 public:
-  writer(const std::string name, code_section type, std::vector<uint8_t>& data): m_name(name), m_type(type), m_data(std::move(data)) {}
-  writer(const std::string name, code_section type): m_name(name), m_type(type) {}
+  writer(std::string name, code_section type, std::vector<uint8_t>&& data)
+    : m_name(std::move(name)),
+      m_type(type),
+      m_data(std::move(data)) {}
+  writer(std::string name, code_section type): m_name(std::move(name)), m_type(type) {}
   virtual ~writer() = default;
 
   virtual void write_byte(uint8_t byte);
@@ -80,6 +85,17 @@ class writer
   }
 
   void padding(offset_type size);
+
+  void add_metadata(std::unordered_map<std::string, std::string>&& metadata)
+  {
+    m_metadata = std::move(metadata);
+  }
+
+  std::string&
+  get_metadata(const std::string& key)
+  {
+    return m_metadata[key];
+  }
 };
 }
 #endif //_AIEBU_COMMON_WRITER_H_
diff --git a/src/cpp/elf/aie2ps/aie2ps_elfwriter.h b/src/cpp/elf/aie2ps/aie2ps_elfwriter.h
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #ifndef _AIEBU_ELF_AIE2PS_ELF_WRITER_H_
 #define _AIEBU_ELF_AIE2PS_ELF_WRITER_H_
@@ -10,8 +10,8 @@ namespace aiebu {
 
 class aie2ps_elf_writer: public elf_writer
 {
-  constexpr static int ob_abi = 0x40;
-  constexpr static int version = 0x02;
+  constexpr static unsigned char ob_abi = 0x40;
+  constexpr static unsigned char version = 0x02;
 public:
   aie2ps_elf_writer(): elf_writer(ob_abi, version)
   { }
diff --git a/src/cpp/elf/config/config_elfwriter.h b/src/cpp/elf/config/config_elfwriter.h
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+// Copyright (C) 2025, Advanced Micro Devices, Inc. All rights reserved.
+
+#ifndef AIEBU_ELF_CONFIG_ELF_WRITER_H_
+#define AIEBU_ELF_CONFIG_ELF_WRITER_H_
+
+#include <elfwriter.h>
+
+namespace aiebu {
+
+class config_elf_writer: public elf_writer
+{
+  constexpr static unsigned char ob_abi = 0x46;
+  constexpr static unsigned char version = 0x02;
+  const std::string const_configuration = "configuration";
+  const std::string xrt_configuration = ".note.xrt.configuration";
+  const std::string const_kernel_signature = "kernel.signature";
+
+public:
+  config_elf_writer(): elf_writer(ob_abi, version)
+  { }
+
+  std::vector<char>
+  process(std::vector<writer>& mwriter) override
+  {
+    process_common_helper(mwriter);
+    //std::string uuid = mwriter[0].get_metadata("kernel.config.uuid");
+    //if (!uuid.empty())
+    //  add_note(NT_XRT_UUID, ".note.xrt.kernel.config.uuid", uuid);
+
+    const std::string configuration = mwriter[0].get_metadata(const_configuration);
+    std::vector<char> configuration_vec(configuration.begin(), configuration.end());
+    if (!configuration.empty())
+      add_note(NT_XRT_PARTITION_SIZE, xrt_configuration, configuration_vec);
+
+    std::string kernel_signature = mwriter[0].get_metadata(const_kernel_signature);
+    if (!kernel_signature.empty())
+      add_symtab(kernel_signature);
+
+    return finalize();
+  }
+};
+
+}
+#endif //AIEBU_ELF_CONFIG_ELF_WRITER_H_
diff --git a/src/cpp/elf/elfwriter.cpp b/src/cpp/elf/elfwriter.cpp
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #include "elfwriter.h"
 
@@ -219,9 +219,33 @@ add_text_data_section(const std::vector<writer>& mwriter, std::vector<symbol>& s
   }
 }
 
-std::vector<char>
+void
 elf_writer::
-process(std::vector<writer>& mwriter)
+add_symtab(const std::string& name)
+{
+  std::call_once(symtab_flag, [this] {
+    str_sec = m_elfio.sections.add(".strtab");
+    str_sec->set_type(ELFIO::SHT_STRTAB);
+    str_sec->set_entry_size(0);
+    sym_sec = m_elfio.sections.add(".symtab");
+    sym_sec->set_type(ELFIO::SHT_SYMTAB);
+    sym_sec->set_info(1);
+    sym_sec->set_addr_align(0x4);
+    sym_sec->set_entry_size(m_elfio.get_default_entry_size(ELFIO::SHT_SYMTAB));
+    sym_sec->set_link(str_sec->get_index());
+  });
+
+  ELFIO::string_section_accessor stra(str_sec);
+  // Create symbol table writer
+  ELFIO::symbol_section_accessor syma( m_elfio, sym_sec );
+  // Another way to add symbol
+  syma.add_symbol( stra, name.c_str(), 0x00000000, 0, ELFIO::STB_WEAK, ELFIO::STT_FUNC, 0,
+                   ELFIO::SHN_UNDEF );
+}
+
+void
+elf_writer::
+process_common_helper(std::vector<writer>& mwriter)
 {
   // add sections
   std::vector<symbol> syms;
@@ -233,6 +257,13 @@ process(std::vector<writer>& mwriter)
     add_reldyn_section(syms);
     add_dynamic_section_segment();
   }
+}
+
+std::vector<char>
+elf_writer::
+process(std::vector<writer>& mwriter)
+{
+  process_common_helper(mwriter);
   return finalize();
 }
 
diff --git a/src/cpp/elf/elfwriter.h b/src/cpp/elf/elfwriter.h
@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #ifndef _AIEBU_ELF_ELF_WRITER_H_
 #define _AIEBU_ELF_ELF_WRITER_H_
 
 #include <sstream>
 #include <iterator>
+#include <mutex>
 #include "writer.h"
 #include "symbol.h"
 #include "elfio/elfio.hpp"
@@ -21,6 +22,8 @@ constexpr int program_header_static_count = 2;
 constexpr int program_header_dynamic_count = 3;
 
 constexpr ELFIO::Elf_Word NT_XRT_UID = 4;
+constexpr ELFIO::Elf_Word NT_XRT_UUID       = 5;
+constexpr ELFIO::Elf_Word NT_XRT_PARTITION_SIZE = 6;
 
 class elf_section
 {
@@ -69,6 +72,9 @@ class elf_writer
 {
 protected:
   ELFIO::elfio m_elfio;
+  ELFIO::section* str_sec = nullptr;
+  ELFIO::section* sym_sec = nullptr;
+  std::once_flag symtab_flag;
   uid_md5 m_uid;
 
   ELFIO::section* add_section(const elf_section& data);
@@ -80,7 +86,8 @@ class elf_writer
   std::vector<char> finalize();
   void add_text_data_section(const std::vector<writer>& mwriter, std::vector<symbol>& syms);
   void add_note(ELFIO::Elf_Word type, const std::string& name, const std::vector<char>& dec);
-
+  void add_symtab(const std::string& name);
+  void process_common_helper(std::vector<writer>& mwriter);
 public:
 
   elf_writer(unsigned char abi, unsigned char version)
@@ -103,7 +110,7 @@ class elf_writer
 
   }
 
-  std::vector<char> process(std::vector<writer>& mwriter);
+  virtual std::vector<char> process(std::vector<writer>& mwriter);
 
   virtual ~elf_writer() = default;
 
diff --git a/src/cpp/encoder/aie2/aie2_blob_encoder.h b/src/cpp/encoder/aie2/aie2_blob_encoder.h
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #ifndef _AIEBU_ENCODER_AIE2_BLOB_ENCODER_H_
 #define _AIEBU_ENCODER_AIE2_BLOB_ENCODER_H_
@@ -24,12 +24,12 @@ class aie2_blob_encoder: public encoder
 
     for(auto key : rinput->get_keys())
       if ( !key.compare(".ctrltext") )
-        rwriter.emplace_back(key, code_section::text, rinput->get_data(key));
+        rwriter.emplace_back(key, code_section::text, std::move(rinput->get_data(key)));
       else
-        rwriter.emplace_back(key, code_section::data, rinput->get_data(key));
+        rwriter.emplace_back(key, code_section::data, std::move(rinput->get_data(key)));
 
     rwriter[0].add_symbols(rinput->get_symbols());
-
+    rwriter[0].add_metadata(std::move(rinput->get_metadata()));
     return rwriter;
   }
 };
diff --git a/src/cpp/include/aiebu/aiebu.h b/src/cpp/include/aiebu/aiebu.h
@@ -24,7 +24,8 @@ enum aiebu_assembler_buffer_type {
   aiebu_assembler_buffer_type_blob_instr_prepost,
   aiebu_assembler_buffer_type_blob_instr_transaction,
   aiebu_assembler_buffer_type_blob_control_packet,
-  aiebu_assembler_buffer_type_asm_aie2ps
+  aiebu_assembler_buffer_type_asm_aie2ps,
+  aiebu_assembler_buffer_type_config
 };
 
 struct pm_ctrlpkt {
diff --git a/src/cpp/include/aiebu/aiebu_assembler.h b/src/cpp/include/aiebu/aiebu_assembler.h
@@ -24,6 +24,7 @@ class aiebu_assembler
       blob_control_packet,
       asm_aie2ps,
       asm_aie2,
+      config,
       elf_aie2,
       elf_aie2ps,
       pdi_aie2,
diff --git a/src/cpp/preprocessor/aie2/aie2_blob_preprocessed_output.h b/src/cpp/preprocessor/aie2/aie2_blob_preprocessed_output.h
@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: MIT
-// Copyright (C) 2024, Advanced Micro Devices, Inc. All rights reserved.
+// Copyright (C) 2024-2025, Advanced Micro Devices, Inc. All rights reserved.
 
 #ifndef _AIEBU_PREPROCESSOR_AIE2_BLOB_PREPROCESSED_OUTPUT_H_
 #define _AIEBU_PREPROCESSOR_AIE2_BLOB_PREPROCESSED_OUTPUT_H_
 
 #include <string>
 #include <map>
+#include <unordered_map>
 #include "symbol.h"
 #include "preprocessed_output.h"
 
@@ -19,6 +20,7 @@ class aie2_blob_preprocessed_output : public preprocessed_output
   // ELF binaries produced on Linux and Windows to look different .
   std::map<std::string, std::vector<uint8_t>> m_data;
   std::vector<symbol> m_sym;
+  std::unordered_map<std::string, std::string> m_metadata;
 
 public:
   aie2_blob_preprocessed_output() {}
@@ -58,6 +60,16 @@ class aie2_blob_preprocessed_output : public preprocessed_output
       throw error(error::error_code::internal_error, "Key (" + key + ") not found!!!");
     return m_data[key];
   }
+
+  void add_metadata(std::unordered_map<std::string, std::string>&& metadata)
+  {
+    m_metadata = std::move(metadata);
+  }
+
+  std::unordered_map<std::string, std::string>& get_metadata()
+  {
+    return m_metadata;
+  }
 };
 
 }
diff --git a/src/cpp/preprocessor/aie2/aie2_blob_preprocessor_input.cpp b/src/cpp/preprocessor/aie2/aie2_blob_preprocessor_input.cpp
diff --git a/src/cpp/preprocessor/aie2/aie2_blob_preprocessor_input.h b/src/cpp/preprocessor/aie2/aie2_blob_preprocessor_input.h
diff --git a/src/cpp/preprocessor/aie2/config_preprocessor.h b/src/cpp/preprocessor/aie2/config_preprocessor.h
diff --git a/src/cpp/preprocessor/preprocessor_input.h b/src/cpp/preprocessor/preprocessor_input.h
diff --git a/src/cpp/utils/asm/asm.cpp b/src/cpp/utils/asm/asm.cpp
diff --git a/src/cpp/utils/target/target.cpp b/src/cpp/utils/target/target.cpp
diff --git a/src/cpp/utils/target/target.h b/src/cpp/utils/target/target.h

Original file line number	Diff line number	Diff line change
`@@ -56,6 +56,11 @@ aiebu_assembler(buffer_type type,`
`56`	`56`	`aiebu::assembler a(assembler::elf_type::aie2ps_asm);`
`57`	`57`	`elf_data = a.process(buffer1, libs, libpaths, patch_json);`
`58`	`58`	`}`
	`59`	`+ else if (type == buffer_type::config)`
	`60`	`+ {`
	`61`	`+ aiebu::assembler a(assembler::elf_type::config);`
	`62`	`+ elf_data = a.process(buffer1, libs, libpaths, patch_json, buffer2);`
	`63`	`+ }`
`59`	`64`	`else {`
`60`	`65`	`throw error(error::error_code::invalid_buffer_type, "Buffer_type not supported !!!");`
`61`	`66`	`}`