no load_core or load_core_cp without load_pdi + restuct

Signed-off-by: Himanshu Choudhary <Himanshu.Choudhary@amd.com>

Author: HimanshuChoudhary-Xilinx

src/cpp/preprocessor/aie2ps/aie2ps_preprocessor.h

@@ -115,18 +115,25 @@ class aie2ps_preprocessor: public preprocessor
       if (!ok)
         throw error(error::error_code::invalid_asm,
           "load_pdi opcode count mismatch: " + std::to_string(exp) +
-          " for col 0, but " + std::to_string(got) +
-          " for col " + std::to_string(col) + "\n");
+          " for column 0, but " + std::to_string(got) +
+          " for column " + std::to_string(col) + "\n");
     }
 
+    // Verify that load_cores / load_cores_cp are not used without load_pdi.
+    // cert needs load_pdi as the recovery anchor; load_cores / load_cores_cp
+    // alone are not sufficient to reconstruct hw state.
+    if (!parser->verify_load_cores_requires_load_pdi())
+      throw error(error::error_code::invalid_asm,
+        "load_cores / load_cores_cp opcode requires at least one load_pdi in the same control code elf\n");
+
     // Verify load_cores opcode count is equal across all columns.
     {
       auto [ok, exp, col, got] = parser->verify_load_cores_count();
       if (!ok)
         throw error(error::error_code::invalid_asm,
           "load_cores opcode count mismatch: " + std::to_string(exp) +
-          " for col 0, but " + std::to_string(got) +
-          " for col " + std::to_string(col) + "\n");
+          " for column 0, but " + std::to_string(got) +
+          " for column " + std::to_string(col) + "\n");
     }
 
     // Verify load_cores_cp opcode count is equal across all columns.
@@ -135,8 +142,8 @@ class aie2ps_preprocessor: public preprocessor
       if (!ok)
         throw error(error::error_code::invalid_asm,
           "load_cores_cp opcode count mismatch: " + std::to_string(exp) +
-          " for col 0, but " + std::to_string(got) +
-          " for col " + std::to_string(col) + "\n");
+          " for column 0, but " + std::to_string(got) +
+          " for column " + std::to_string(col) + "\n");
     }
 
     // Verify start_cond_job_preempt opcode count is equal across all columns.
@@ -145,8 +152,8 @@ class aie2ps_preprocessor: public preprocessor
       if (!ok)
         throw error(error::error_code::invalid_asm,
           "start_cond_job_preempt opcode count mismatch: " + std::to_string(exp) +
-          " for col 0, but " + std::to_string(got) +
-          " for col " + std::to_string(col) + "\n");
+          " for column 0, but " + std::to_string(got) +
+          " for column " + std::to_string(col) + "\n");
     }
 
     // Verify .target directive matches the -t command line option

src/cpp/preprocessor/asm/asm_parser.cpp

@@ -217,6 +217,120 @@ parse_lines()
   finalize_preempt();
 }
 
+void
+asm_parser::
+handle_preempt_opcode(std::string& arg_str, std::string& line)
+{
+  if (get_target_type() == "aie2ps")
+    throw error(error::error_code::internal_error, "PREEMPT opcode is not supported for aie2ps target");
+
+  int current_group = current_col();
+  record_preempt_label(current_group);
+
+  std::vector<std::string> args;
+  if (!arg_str.empty()) {
+    std::stringstream ss(arg_str);
+    std::string arg;
+    while (std::getline(ss, arg, ','))
+      args.push_back(trim(arg));
+  }
+
+  if (args.empty())
+    throw error(error::error_code::internal_error, "PREEMPT opcode has no arguments");
+
+  std::string first_arg = args[0];
+  if (first_arg.empty())
+    throw error(error::error_code::internal_error, "PREEMPT opcode has empty first argument");
+
+  std::string hintmap_label;
+  if (args.size() >= 4) {
+    hintmap_label = args[3];
+    if (!hintmap_label.empty() && hintmap_label[0] == '@')
+      hintmap_label = hintmap_label.substr(1);
+    if (!hintmap_label.empty()) {
+      std::transform(hintmap_label.begin(), hintmap_label.end(), hintmap_label.begin(),
+                     [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+    }
+  }
+
+  std::pair<std::string, std::string> labels;
+  if (!hintmap_label.empty()) {
+    // Qualify the hintmap key with its label scope so that the same label
+    // name in different scopes (e.g. "default" vs "default:pdi") is treated
+    // as a distinct hintmap.
+    std::string qualified_key = m_current_label + ":" + hintmap_label;
+    // Get unique save/restore labels for this hintmap BEFORE adding to vector
+    // (so the index calculation is correct)
+    labels = get_hintmap_save_restore_labels(hintmap_label, current_group);
+    // Store qualified key for later processing (after getting labels)
+    m_preempt_hintmaps[current_group].push_back(qualified_key);
+  } else {
+    // No hintmap, use group-level labels
+    // Track that this group has PREEMPT opcodes without hintmaps
+    m_preempt_without_hintmap.insert(current_group);
+    labels = m_preempt_labels[current_group];
+  }
+
+  if (!hintmap_label.empty())
+    arg_str = first_arg + ", @" + labels.first + ", @" + labels.second + ", @" + hintmap_label;
+  else
+    arg_str = first_arg + ", @" + labels.first + ", @" + labels.second;
+
+  log_info() << "PREEMPT opcode: updated arg_str to '" << arg_str
+             << "' (hintmap: '" << hintmap_label << "', labels: @" << labels.first
+             << " / @" << labels.second << ")" << std::endl;
+
+  line = "preempt\t" + arg_str;
+}
+
+void
+asm_parser::
+handle_load_or_preempt_cond(const std::string& op_name, const std::string& arg_str, const smatch& sm)
+{
+  // col is common to all four opcodes; compute once.
+  int col = current_col();
+
+  if (sm[1].matched || sm[3].matched) {  // load_pdi or load_cores
+    // operator[] default-constructs col_data if the key is absent (single lookup).
+    auto& cdata = m_col[col];
+    bool is_load_pdi = sm[1].matched;
+
+    // Extract the @label at argument index 1 (<id>, @<label>).
+    // Compiled once (static); regex_search finds the first ", @<label>" token.
+    static const regex LOAD_LABEL_RE(",\\s*(@[a-zA-Z0-9_]+)");
+    std::string label_arg;
+    smatch lm;
+    if (regex_search(arg_str, lm, LOAD_LABEL_RE))
+      label_arg = lm[1].str();
+    // Enforce uniqueness of the PDI / core-elf address within this column.
+    // label_arg will never be empty
+    bool inserted = is_load_pdi
+                      ? cdata.try_add_load_pdi_label(label_arg)
+                      : cdata.try_add_load_cores_label(label_arg);
+    if (!inserted)
+      throw error(error::error_code::invalid_asm,
+        op_name + " location '" + label_arg + "' is not unique in column " +
+        std::to_string(col) + "; each " + op_name +
+        " in a control code elf must use a distinct address\n");
+
+    if (is_load_pdi)
+      cdata.increment_load_pdi_count();
+    else
+      cdata.increment_load_cores_count();
+  } else if (sm[2].matched) {  // load_cores_cp
+    m_col[col].increment_load_cores_cp_count();
+  } else {
+    // start_cond_job_preempt must only appear after at least one preempt in
+    // the same column (cert uses the preceding preempt point for recovery).
+    auto col_it = m_col.find(col);
+    if (col_it == m_col.end() || col_it->second.get_preempt_count() == 0)
+      throw error(error::error_code::invalid_asm,
+        "start_cond_job_preempt found in column " + std::to_string(col) +
+        " before any preempt opcode; it must follow a preempt opcode\n");
+    col_it->second.increment_start_cond_job_preempt_count();
+  }
+}
+
 void
 asm_parser::
 parse_lines(const std::vector<char>& data, std::string& file)
@@ -317,125 +431,13 @@ parse_lines(const std::vector<char>& data, std::string& file)
 
       // Handle PREEMPT opcode - record label for current group
       if (!op_name.compare("preempt")) {
-        if (get_target_type() == "aie2ps")
-          throw error(error::error_code::internal_error, "PREEMPT opcode is not supported for aie2ps target");
-
-        // Get current group (default to 0 if no attach_to_group yet)
-        int current_group = current_col();
-
-        // Record preempt label for this group (save_N/restore_N) - for backward compatibility
-        record_preempt_label(current_group);
-
-        // Parse arguments: id, @save, @restore, [@hintmap]
-        std::vector<std::string> args;
-        if (!arg_str.empty()) {
-          std::stringstream ss(arg_str);
-          std::string arg;
-          while (std::getline(ss, arg, ',')) {
-            args.push_back(trim(arg));
-          }
-        }
-
-        // Extract first argument (id)
-        std::string first_arg;
-        if (args.empty())
-          throw error(error::error_code::internal_error, "PREEMPT opcode has no arguments");
-
-        first_arg = args[0];
-        if (first_arg.empty())
-          throw error(error::error_code::internal_error, "PREEMPT opcode has empty first argument");
-
-        // Extract hintmap label if present (4th argument, optional)
-        std::string hintmap_label;
-        if (args.size() >= 4) {
-          hintmap_label = args[3];
-          // Remove @ prefix if present
-          if (!hintmap_label.empty() && hintmap_label[0] == '@') {
-            hintmap_label = hintmap_label.substr(1);
-          }
-          if (!hintmap_label.empty()) {
-            std::transform(hintmap_label.begin(), hintmap_label.end(), hintmap_label.begin(),
-                           [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
-          }
-        }
-
-        // Get save/restore labels - specific to hintmap if present, otherwise use group labels
-        std::pair<std::string, std::string> labels;
-        if (!hintmap_label.empty()) {
-          // Qualify the hintmap key with its label scope so that the same label
-          // name in different scopes (e.g. "default" vs "default:pdi") is treated
-          // as a distinct hintmap.
-          std::string qualified_key = m_current_label + ":" + hintmap_label;
-          // Get unique save/restore labels for this hintmap BEFORE adding to vector
-          // (so the index calculation is correct)
-          labels = get_hintmap_save_restore_labels(hintmap_label, current_group);
-          // Store qualified key for later processing (after getting labels)
-          m_preempt_hintmaps[current_group].push_back(qualified_key);
-        } else {
-          // No hintmap, use group-level labels
-          // Track that this group has PREEMPT opcodes without hintmaps
-          m_preempt_without_hintmap.insert(current_group);
-          labels = m_preempt_labels[current_group];
-        }
-
-        // Build new arg_str: <first_arg>, @<save_label>, @<restore_label>[, @<hintmap_label>]
-        if (!hintmap_label.empty())
-          arg_str = first_arg + ", @" + labels.first + ", @" + labels.second + ", @" + hintmap_label;
-        else
-          arg_str = first_arg + ", @" + labels.first + ", @" + labels.second;
-
-        log_info() << "PREEMPT opcode: updated arg_str to '" << arg_str
-                   << "' (hintmap: '" << hintmap_label << "', labels: @" << labels.first
-                   << " / @" << labels.second << ")" << std::endl;
-
-        line = op_name + "\t" + arg_str;
+        handle_preempt_opcode(arg_str, line);
       }
       // Per-opcode parse-time checks and counter updates.
       // These run after the preempt block so that m_preempt_count is already
       // incremented when we reach start_cond_job_preempt.
       else if (regex_match(op_name, sm, LOAD_OR_PREEMPT_COND_RE)) {
-        // col is common to all four opcodes; compute once.
-        int col = current_col();
-
-        if (sm[1].matched || sm[3].matched) {  // load_pdi or load_cores
-          // operator[] default-constructs col_data if the key is absent (single lookup).
-          auto& cdata = m_col[col];
-          bool is_load_pdi = sm[1].matched;  // if load_pdi
-
-          // Extract the @label at argument index 1 (<id>, @<label>).
-          // Compiled once (static); regex_search finds the first ", @<label>" token.
-          static const regex LOAD_LABEL_RE(",\\s*(@[a-zA-Z0-9_]+)");
-          std::string label_arg;
-          smatch lm;
-          if (regex_search(arg_str, lm, LOAD_LABEL_RE))
-            label_arg = lm[1].str();
-          // Enforce uniqueness of the PDI / core-elf address within this column.
-          if (!label_arg.empty()) {
-            bool inserted = is_load_pdi
-                            ? cdata.try_add_load_pdi_label(label_arg)
-                            : cdata.try_add_load_cores_label(label_arg);
-            if (!inserted)
-              throw error(error::error_code::invalid_asm,
-                op_name + " location '" + label_arg + "' is not unique in column " +
-                std::to_string(col) + "; each " + op_name +
-                " in a control code elf must use a distinct address\n");
-          }
-          if (is_load_pdi)
-            cdata.increment_load_pdi_count();
-          else
-            cdata.increment_load_cores_count();
-        } else if (sm[2].matched) {  // load_cores_cp
-          m_col[col].increment_load_cores_cp_count();
-        } else {
-          // start_cond_job_preempt must only appear after at least one preempt in
-          // the same column (cert uses the preceding preempt point for recovery).
-          auto col_it = m_col.find(col);
-          if (col_it == m_col.end() || col_it->second.get_preempt_count() == 0)
-            throw error(error::error_code::invalid_asm,
-              "start_cond_job_preempt found in column " + std::to_string(col) +
-              " before any preempt opcode; it must follow a preempt opcode\n");
-          col_it->second.increment_start_cond_job_preempt_count();
-        }
+        handle_load_or_preempt_cond(op_name, arg_str, sm);
       }
       insert_col_asmdata(std::make_shared<asm_data>(operation(op_name, arg_str), operation_type::op,
                                                     code_section::unknown, 0, (uint32_t)-1, linenumber,

src/cpp/preprocessor/asm/asm_parser.h

@@ -720,6 +720,18 @@ class asm_parser: public std::enable_shared_from_this<asm_parser>
     return true;
   }
 
+  // Verify that every column containing load_cores or load_cores_cp also has at
+  // least one load_pdi.  cert needs load_pdi as the anchor to recover the full
+  // hw context; load_cores / load_cores_cp are meaningless without it.
+  bool verify_load_cores_requires_load_pdi() const {
+    for (const auto& [col, data] : m_col) {
+      if ((data.get_load_cores_count() > 0 || data.get_load_cores_cp_count() > 0) &&
+          data.get_load_pdi_count() == 0)
+        return false;
+    }
+    return true;
+  }
+
   std::pair<std::vector<uint8_t>, std::vector<uint8_t>> get_preempt_save_restore(uint32_t key) const;
   std::pair<std::vector<std::string>, std::vector<std::string>> get_preempt_save_restore_bd(uint32_t key) const;
   std::pair<std::vector<std::string>, std::vector<std::string>> get_preempt_save_restore_shimbd(uint32_t key) const;
@@ -811,6 +823,13 @@ class asm_parser: public std::enable_shared_from_this<asm_parser>
 
   void parse_lines(const std::vector<char>& data, std::string& file);
 
+  // Rewrites arg_str and line in-place for a PREEMPT opcode.
+  void handle_preempt_opcode(std::string& arg_str, std::string& line);
+
+  // Runs parse-time counter updates and checks for load_pdi / load_cores /
+  // load_cores_cp / start_cond_job_preempt (matched via LOAD_OR_PREEMPT_COND_RE).
+  void handle_load_or_preempt_cond(const std::string& op_name, const std::string& arg_str, const smatch& sm);
+
   std::vector<char> get_asm_data(const std::string& name);
   // Switch active column for subsequent opcodes. Do not replace existing col_data:
   // the same column may be selected again after .include; wiping

test/aie4-ctrlcode/opcode_checks/CMakeLists.txt

@@ -46,6 +46,14 @@ add_aie4_config_neg_test("aie4_check_load_cores_cp_count_mismatch"
 add_aie4_config_neg_test("aie4_check_preempt_no_load_pdi"
   "config_preempt_no_load_pdi.json")
 
+# load_cores: used without any load_pdi in the same control code elf
+add_aie4_config_neg_test("aie4_check_load_cores_no_load_pdi"
+  "config_load_cores_no_load_pdi.json")
+
+# load_cores_cp: used without any load_pdi in the same control code elf
+add_aie4_config_neg_test("aie4_check_load_cores_cp_no_load_pdi"
+  "config_load_cores_cp_no_load_pdi.json")
+
 # start_cond_job_preempt: appears before any preempt in the same column
 add_aie4_config_neg_test("aie4_check_start_cond_before_preempt"
   "config_start_cond_before_preempt.json")

test/aie4-ctrlcode/opcode_checks/config_load_cores_cp_no_load_pdi.json

@@ -0,0 +1,14 @@
+{
+  "xrt-kernels": [
+    {
+      "name" : "DPU",
+      "arguments" : [],
+      "instance" : [
+          {
+            "id" : "dpu",
+            "ctrl_code_file" : "./load_cores_cp_no_load_pdi.asm"
+          }
+      ]
+    }
+  ]
+}

test/aie4-ctrlcode/opcode_checks/config_load_cores_no_load_pdi.json

@@ -0,0 +1,14 @@
+{
+  "xrt-kernels": [
+    {
+      "name" : "DPU",
+      "arguments" : [],
+      "instance" : [
+          {
+            "id" : "dpu",
+            "ctrl_code_file" : "./load_cores_no_load_pdi.asm"
+          }
+      ]
+    }
+  ]
+}

test/aie4-ctrlcode/opcode_checks/dup_load_cores_addr.asm

@@ -7,7 +7,13 @@
 .attach_to_group 0
 START_JOB 0
 	LOAD_PDI 0, @pdi0
+END_JOB
+
+START_JOB 1
 	LOAD_CORES 0, @cores0
+END_JOB
+
+START_JOB 2
 	LOAD_CORES 1, @cores0
 END_JOB