pin_c: validate -internal_pin names

Author: serge-rs

planning/src/file_readers/pln_csv_reader.cpp

@@ -29,6 +29,7 @@ void PcCsvReader::reset() noexcept {
   rx_cols_.reset();
   tx_cols_.reset();
   gpio_cols_.reset();
+  fullchipNames_.clear();
 
   bcd_good_.clear();
 
@@ -973,12 +974,16 @@ bool PcCsvReader::read_csv(const string& fn, uint num_udes_pins) {
 
   flush_out(false);
 
+  fullchipNames_.clear();
   S_tmp = crd.getColumn("Fullchip_NAME");
   assert(S_tmp.size() > 1);
   assert(S_tmp.size() <= num_rows);
   S_tmp.resize(num_rows);
+  fullchipNames_.reserve(num_rows + 2);
   for (uint i = 0; i < num_rows; i++) {
     bcd_[i]->fullchipName_ = std::move(S_tmp[i]);
+    if (not bcd_[i]->fullchipName_.empty())
+      fullchipNames_.insert(bcd_[i]->fullchipName_);
   }
 
   flush_out(false);

planning/src/file_readers/pln_csv_reader.h

@@ -283,6 +283,10 @@ class PcCsvReader {
   uint getModeCol(const string& mode) const noexcept;
   bool hasMode(const string& key) const noexcept { return getModeCol(key); }
 
+  bool hasFullchipName(const string& key) const noexcept {
+    return fullchipNames_.count(key);
+  }
+
   uint printModeNames() const;
 
   string bumpName2CustomerName(const string& bump_name) const noexcept;
@@ -336,6 +340,8 @@ class PcCsvReader {
   std::bitset<MAX_PT_COLS> tx_cols_;    // which columns are "Mode_..._TX"
   std::bitset<MAX_PT_COLS> gpio_cols_;  // which columns are "Mode_..._GPIO"
 
+  std::unordered_set<string> fullchipNames_; // for -internal_pin validation
+
   vector<BCD*> bcd_;         // all BCD records, indexed by csv row
 
   vector<BCD*> bcd_AXI_;     // BCD records with .isCustomerInternalOnly() predicate (AXI pins)

planning/src/file_readers/pln_pcf_reader.cpp

@@ -26,6 +26,7 @@ bool PcfReader::read_pcf(const string& f) {
   bool has_error = false;
   string set_io_cmd, user_pin, bump_or_ball_name, dash_mode, mode_name;
   string optional_dash_internal_pin, optional_internal_pin;
+  string internal_str;
 
   vector<string> dat;
   string row_str;
@@ -65,11 +66,32 @@ bool PcfReader::read_pcf(const string& f) {
     optional_internal_pin.clear();
 
     bool has_internal_pin = false;
+    internal_str.clear();
     if (line.find("-internal_pin") != string::npos) {
+      int index_in_dat = -1;
+      assert(dat.size() > 1);
+      for (int k = int(dat.size()) - 1; k > 0; k--) {
+        if (dat[k] == "-internal_pin") {
+          index_in_dat = k;
+          break;
+        }
+      }
+      if (index_in_dat < 0 or index_in_dat == int(dat.size()) - 1) {
+        flush_out(true);
+        err_puts();
+        lprintf2("[Error] PCF Reader: syntax error regarding -internal_pin\n");
+        flush_out(true);
+        lprintf("  PCF line with syntax error: %s\n", line.c_str());
+        flush_out(true);
+        return false;
+      }
       has_internal_pin = true;
+      internal_str = dat[index_in_dat + 1];
     }
 
-    if (tr >= 4) ls << "(pcf line) " << line << endl;
+    if (tr >= 5) {
+      ls << "(pcf line) " << line << endl;
+    }
 
     if (has_internal_pin) {
       if (!(iss >> set_io_cmd >> user_pin >> bump_or_ball_name >> dash_mode >>
@@ -87,27 +109,28 @@ bool PcfReader::read_pcf(const string& f) {
 
     if (tr >= 4) {
       ls << "    user_pin:" << user_pin << "  bump_or_ball_name:" << bump_or_ball_name
-         << "  mode_name:" << mode_name << endl;
+         << "  mode_name:" << mode_name << "  internal_str:" << internal_str << endl;
     }
 
     commands_.emplace_back();
     Cmd& last = commands_.back();
-    vector<string>& cur_command = last.cmd_;
+    last.clearInternalPin();
 
-    cur_command.push_back(set_io_cmd);
-    cur_command.push_back(user_pin);
-    cur_command.push_back(bump_or_ball_name);
-    cur_command.push_back(dash_mode);
-    cur_command.push_back(mode_name);
+    last.cmd_.push_back(set_io_cmd);
+    last.cmd_.push_back(user_pin);
+    last.cmd_.push_back(bump_or_ball_name);
+    last.cmd_.push_back(dash_mode);
+    last.cmd_.push_back(mode_name);
 
     if (has_internal_pin) {
-      cur_command.push_back(optional_dash_internal_pin);
-      cur_command.push_back(optional_internal_pin);
+      last.cmd_.push_back(optional_dash_internal_pin);
+      last.cmd_.push_back(optional_internal_pin);
+      last.setInternalPin(internal_str);
     }
 
     if (row_num > 0) {
-      cur_command.emplace_back("-pt_row");
-      cur_command.emplace_back(std::to_string(row_num));
+      last.cmd_.emplace_back("-pt_row");
+      last.cmd_.emplace_back(std::to_string(row_num));
     }
   }
 

planning/src/file_readers/pln_pcf_reader.h

@@ -11,11 +11,19 @@ struct PcfReader {
 
   struct Cmd {
     vector<string> cmd_;
-    bool hasInternalPin_ = false;
+    string internalPin_;
 
     Cmd() noexcept = default;
 
     size_t size() const noexcept { return cmd_.size(); }
+
+    bool hasInternalPin() const noexcept { return not internalPin_.empty(); }
+
+    void setInternalPin(const string& nm) noexcept {
+      assert(not nm.empty());
+      internalPin_ = nm;
+    }
+    void clearInternalPin() noexcept { internalPin_.clear(); }
   };
 
   vector<Cmd> commands_;
@@ -25,8 +33,6 @@ struct PcfReader {
   PcfReader(const string& f) { read_pcf(f); }
 
   bool read_pcf(const string& f);
-
-  //// const vector<Cmd>& get_commands() const noexcept { return commands_; }
 };
 
 }

planning/src/main.cpp

@@ -1,4 +1,4 @@
-static const char* _pln_VERSION_STR = "pln0238";
+static const char* _pln_VERSION_STR = "pln0240";
 
 #include "RS/rsEnv.h"
 #include "util/pln_log.h"

planning/src/pin_loc/pcf_place.cpp

@@ -412,14 +412,21 @@ bool PinPlacer::read_pcf(const PcCsvReader& csv) {
   if (rd_pcf.commands_.empty())
     return true;
 
-  // validate modes
+  assert(rd_pcf.commands_.size() < UINT_MAX);
+  uint num_pcf_commands = rd_pcf.commands_.size();
+  uint num_internal_pins = 0;
+
+  // -- validate modes
   string mode, key;
-  for (uint cmd_i = 0; cmd_i < rd_pcf.commands_.size(); cmd_i++) {
-    const vector<string>& pcf_cmd = rd_pcf.commands_[cmd_i].cmd_;
+  for (uint cmd_i = 0; cmd_i < num_pcf_commands; cmd_i++) {
+    const PcfReader::Cmd& cmdObj = rd_pcf.commands_[cmd_i];
+    if (cmdObj.hasInternalPin())
+      num_internal_pins++;
+    const vector<string>& cmdl = cmdObj.cmd_;
     mode.clear();
-    for (uint j = 1; j < pcf_cmd.size() - 1; j++) {
-      if (pcf_cmd[j] == "-mode") {
-        mode = pcf_cmd[j + 1];
+    for (uint j = 1; j < cmdl.size() - 1; j++) {
+      if (cmdl[j] == "-mode") {
+        mode = cmdl[j + 1];
         break;
       }
     }
@@ -442,6 +449,28 @@ bool PinPlacer::read_pcf(const PcCsvReader& csv) {
     return false;
   }
 
+  if (tr >= 3) {
+    lprintf("pin_c PCF:  num_pcf_commands= %u  num_internal_pins= %u\n",
+            num_pcf_commands, num_internal_pins);
+  }
+
+  // -- validate internal_pins
+  for (uint cmd_i = 0; cmd_i < num_pcf_commands; cmd_i++) {
+    const PcfReader::Cmd& cmdObj = rd_pcf.commands_[cmd_i];
+    if (not cmdObj.hasInternalPin())
+      continue;
+    const string& ip = cmdObj.internalPin_;
+    if (ip.empty())
+      continue;
+    if (csv.hasFullchipName(ip))
+      continue;
+    flush_out(true);
+    err_puts();
+    lprintf2("[Error] invalid -internal_pin in PCF: %s\n", ip.c_str());
+    flush_out(true);
+    return false;
+  }
+
   pcf_pin_cmds_ = std::move(rd_pcf.commands_);
 
   if (tr >= 3) {