Merge pull request #8338 from The-OpenROAD-Project-staging/secure-fix-undo-issue

Fixed EQY fails in hierarchical flow

Author: maliberty

src/dbSta/src/dbEditHierarchy.cc

@@ -99,7 +99,7 @@ void PinModuleConnection::operator()(const Pin* pin)
   }
 }
 
-bool dbEditHierarchy::ConnectionToModuleExists(dbITerm* source_pin,
+bool dbEditHierarchy::connectionToModuleExists(dbITerm* source_pin,
                                                dbModule* dest_module,
                                                dbModBTerm*& dest_modbterm,
                                                dbModITerm*& dest_moditerm) const
@@ -145,18 +145,17 @@ void dbEditHierarchy::createHierarchyBottomUp(dbITerm* pin,
   dbModNet* db_mod_net = nullptr;
   const char* io_type_str = (io_type == dbIoType::OUTPUT) ? "o" : "i";
 
-  while (cur_module != highest_common_module) {
-    // Decide a new unique pin/net name
-    std::string unique_name
-        = fmt::format("{}_{}", connection_name, io_type_str);
-    int id = 0;
-    while (cur_module->findModBTerm(unique_name.c_str())
-           || cur_module->getModNet(unique_name.c_str())) {
-      id++;
-      unique_name = fmt::format("{}_{}_{}", connection_name, io_type_str, id);
-    }
-    const char* new_term_net_name = unique_name.c_str();
+  // Decide a new unique pin/net name
+  std::string unique_name = fmt::format("{}_{}", connection_name, io_type_str);
+  int id = 0;
+  while (cur_module->findModBTerm(unique_name.c_str())
+         || cur_module->getModNet(unique_name.c_str())) {
+    id++;
+    unique_name = fmt::format("{}_{}_{}", connection_name, io_type_str, id);
+  }
+  const char* new_term_net_name = unique_name.c_str();
 
+  while (cur_module != highest_common_module) {
     // Create BTerm & ModNet and connect them
     dlogCreateHierBTermAndModNet(level, cur_module, new_term_net_name);
     dbModBTerm* mod_bterm = dbModBTerm::create(cur_module, new_term_net_name);
@@ -190,6 +189,14 @@ void dbEditHierarchy::createHierarchyBottomUp(dbITerm* pin,
     dbModITerm* mod_iterm
         = dbModITerm::create(parent_inst, new_term_net_name, mod_bterm);
 
+    // Retry to get a new unique pin/net name in the new hierarchy
+    while (cur_module->findModBTerm(unique_name.c_str())
+           || cur_module->getModNet(unique_name.c_str())) {
+      id++;
+      unique_name = fmt::format("{}_{}_{}", connection_name, io_type_str, id);
+    }
+    new_term_net_name = unique_name.c_str();
+
     // Create ModNet for the ITerm
     if (io_type == dbIoType::OUTPUT
         || (io_type == dbIoType::INPUT
@@ -220,7 +227,7 @@ connection_name should be a base name, not a full name.
 */
 void dbEditHierarchy::hierarchicalConnect(dbITerm* source_pin,
                                           dbITerm* dest_pin,
-                                          const char* connection_name) const
+                                          const char* connection_name)
 {
   assert(source_pin != nullptr);
   assert(dest_pin != nullptr);
@@ -308,7 +315,7 @@ void dbEditHierarchy::hierarchicalConnect(dbITerm* source_pin,
     dbModITerm* dest_moditerm = nullptr;
     // Check do we already have a connection between the source and destination
     // pins? If so, reuse it.
-    if (ConnectionToModuleExists(
+    if (connectionToModuleExists(
             source_pin, dest_db_module, dest_modbterm, dest_moditerm)) {
       dbModNet* dest_mod_net = nullptr;
       if (dest_modbterm) {
@@ -381,11 +388,21 @@ void dbEditHierarchy::hierarchicalConnect(dbITerm* source_pin,
         // Get base name of source_pin_flat_net
         Pin* sta_source_pin = db_network_->dbToSta(source_pin);
         dbNet* source_pin_flat_net = db_network_->flatNet(sta_source_pin);
-        const char* base_name
-            = db_network_->name(db_network_->dbToSta(source_pin_flat_net));
+        std::string base_name = fmt::format(
+            "{}", db_network_->name(db_network_->dbToSta(source_pin_flat_net)));
+
+        // Decide a new unique net name to avoid collisions.
+        std::string unique_name = base_name;
+        int id = 0;
+        while (highest_common_module->findModBTerm(unique_name.c_str())
+               || highest_common_module->getModNet(unique_name.c_str())) {
+          id++;
+          unique_name = fmt::format("{}_{}", base_name, id);
+        }
 
         // Create and connect dbModNet
-        source_db_mod_net = dbModNet::create(highest_common_module, base_name);
+        source_db_mod_net
+            = dbModNet::create(highest_common_module, unique_name.c_str());
         top_mod_dest->connect(source_db_mod_net);
         db_network_->disconnectPin(sta_source_pin);
         db_network_->connectPin(sta_source_pin,

src/dbSta/src/dbEditHierarchy.hh

@@ -42,13 +42,13 @@ class dbEditHierarchy
                           std::vector<dbModule*>& parent_hierarchy) const;
   dbModule* findHighestCommonModule(std::vector<dbModule*>& itree1,
                                     std::vector<dbModule*>& itree2) const;
-  bool ConnectionToModuleExists(dbITerm* source_pin,
+  bool connectionToModuleExists(dbITerm* source_pin,
                                 dbModule* dest_module,
                                 dbModBTerm*& dest_modbterm,
                                 dbModITerm*& dest_moditerm) const;
   void hierarchicalConnect(dbITerm* source_pin,
                            dbITerm* dest_pin,
-                           const char* connection_name = "net") const;
+                           const char* connection_name = "net");
 
  private:
   void createHierarchyBottomUp(dbITerm* pin,

src/dbSta/src/dbNetwork.cc

@@ -65,6 +65,7 @@ Recommended conclusion: use map for concrete cells. They are invariant.
 #include "sta/Liberty.hh"
 #include "sta/PatternMatch.hh"
 #include "sta/PortDirection.hh"
+#include "sta/Search.hh"
 #include "utl/Logger.h"
 
 namespace sta {
@@ -3790,6 +3791,10 @@ void dbNetwork::reassociateHierFlatNet(dbModNet* mod_net,
 
 void dbNetwork::reassociateFromDbNetView(dbNet* flat_net, dbModNet* mod_net)
 {
+  if (flat_net == nullptr || mod_net == nullptr) {
+    return;
+  }
+
   DbModNetAssociation visitordb(this, mod_net);
   NetSet visited_dbnets(this);
   visitConnectedPins(dbToSta(flat_net), visitordb, visited_dbnets);
@@ -4055,13 +4060,13 @@ void dbNetwork::checkAxioms()
 {
   checkSanityModBTerms();
   checkSanityModITerms();
-  checkSanityModuleInsts();
   checkSanityModInstTerms();
   checkSanityUnusedModules();
   checkSanityTermConnectivity();
   checkSanityNetConnectivity();
   checkSanityInstNames();
   checkSanityNetNames();
+  checkSanityModuleInsts();
 }
 
 // Given a net that may be hierarchical, find the corresponding flat net.
@@ -4296,8 +4301,7 @@ void dbNetwork::checkSanityTermConnectivity()
 
   for (odb::dbInst* inst : block_->getInsts()) {
     for (odb::dbITerm* iterm : inst->getITerms()) {
-      if (iterm->getSigType() == dbSigType::POWER
-          || iterm->getSigType() == dbSigType::GROUND) {
+      if (iterm->getSigType().isSupply()) {
         continue;  // Skip power/ground pins
       }
 
@@ -4323,27 +4327,58 @@ void dbNetwork::checkSanityNetConnectivity()
   }
 
   // Check for incomplete flat net connections
-  for (odb::dbNet* net : block_->getNets()) {
-    const auto iterm_count = net->getITerms().size();
-    const auto bterm_count = net->getBTerms().size();
+  for (odb::dbNet* net_db : block_->getNets()) {
+    // Check for multiple drivers.
+    Net* net = dbToSta(net_db);
+    PinSeq loads;
+    PinSeq drvrs;
+    PinSet visited_drvrs(this);
+    FindNetDrvrLoads visitor(nullptr, visited_drvrs, loads, drvrs, this);
+    NetSet visited_nets(this);
+    visitConnectedPins(net, visitor, visited_nets);
+
+    if (drvrs.size() > 1) {
+      bool all_tristate = true;
+      for (const Pin* drvr : drvrs) {
+        LibertyPort* port = libertyPort(drvr);
+        if (!port || !port->direction()->isAnyTristate()) {
+          all_tristate = false;
+          break;
+        }
+      }
+
+      if (!all_tristate) {
+        std::string drivers_str;
+        for (const Pin* drvr : drvrs) {
+          drivers_str += " " + std::string(pathName(drvr));
+        }
+        logger_->error(
+            ORD,
+            2049,
+            "SanityCheck: Net '{}' has multiple non-tristate drivers:{}",
+            name(net),
+            drivers_str);
+      }
+    }
+    const auto iterm_count = net_db->getITerms().size();
+    const auto bterm_count = net_db->getBTerms().size();
     if (iterm_count + bterm_count >= 2) {
       continue;
     }
 
     // Skip power/ground net
-    if (net->getSigType() == odb::dbSigType::POWER
-        || net->getSigType() == odb::dbSigType::GROUND) {
+    if (net_db->getSigType().isSupply()) {
       continue;  // OK: Unconnected power/ground net
     }
 
     // A net connected to 1 terminal
     if (iterm_count == 1) {
-      odb::dbITerm* iterm = *(net->getITerms().begin());
+      odb::dbITerm* iterm = *(net_db->getITerms().begin());
       if (iterm->getIoType() == odb::dbIoType::OUTPUT) {
         continue;  // OK: Unconnected output pin
       }
     } else if (bterm_count == 1) {  // This is a top level port
-      odb::dbBTerm* bterm = *(net->getBTerms().begin());
+      odb::dbBTerm* bterm = *(net_db->getBTerms().begin());
       if (bterm->getIoType() == odb::dbIoType::INPUT) {
         continue;  // OK: Unconnected input port
       }
@@ -4353,7 +4388,7 @@ void dbNetwork::checkSanityNetConnectivity()
                    2039,
                    "SanityCheck: Net '{}' has less than 2 connections (# of "
                    "ITerms = {}, # of BTerms = {}).",
-                   net->getName(),
+                   net_db->getName(),
                    iterm_count,
                    bterm_count);
   }

src/dbSta/test/check_axioms.ok

@@ -1,5 +1,2 @@
 [INFO ODB-0227] LEF file: Nangate45/Nangate45.lef, created 22 layers, 27 vias, 135 library cells
-[WARNING ORD-2038] SanityCheck: Module 'i_empty' has no instances.
-[WARNING ORD-2038] SanityCheck: Module 'u1' has no instances.
-[WARNING ORD-2038] SanityCheck: Module 'u2' has no instances.
 [ERROR ORD-2039] SanityCheck: Net 'out_unconnected' has less than 2 connections (# of ITerms = 0, # of BTerms = 1).

src/odb/include/odb/db.h

@@ -1736,12 +1736,12 @@ class dbNet : public dbObject
   ///
   /// Get the net name.
   ///
-  std::string getName();
+  std::string getName() const;
 
   ///
   /// Get the net name.
   ///
-  const char* getConstName();
+  const char* getConstName() const;
 
   ///
   /// Print net name with or without id and newline
@@ -1949,7 +1949,7 @@ class dbNet : public dbObject
   ///
   /// Get the block this net belongs to.
   ///
-  dbBlock* getBlock();
+  dbBlock* getBlock() const;
 
   ///
   /// Get all the instance-terminals of this net.
@@ -2428,6 +2428,20 @@ class dbNet : public dbObject
   ///
   void mergeNet(dbNet* in_net);
 
+  ///
+  /// Find the parent module instance of this net by parsing its hierarchical
+  /// name.
+  /// Returns nullptr if the parent is the top module.
+  /// Note that a dbNet can be located at multiple hierarchical modules.
+  ///
+  dbModInst* findMainParentModInst() const;
+
+  ///
+  /// Find the parent module of this net by parsing its hierarchical name.
+  /// Returns the top module if the parent is the top module.
+  ///
+  dbModule* findMainParentModule() const;
+
   dbSet<dbGuide> getGuides() const;
 
   void clearGuides();
@@ -8245,6 +8259,12 @@ class dbModInst : public dbObject
 
   void removeUnusedPortsAndPins();
 
+  dbModNet* findHierNet(const char* base_name) const;
+  dbNet* findFlatNet(const char* base_name) const;
+  bool findNet(const char* base_name,
+               dbNet*& flat_net,
+               dbModNet*& hier_net) const;
+
   /// Swap the module of this instance.
   /// Returns new mod inst if the operations succeeds.
   /// Old mod inst is deleted along with its child insts.

src/odb/src/db/dbModInst.cpp

@@ -24,9 +24,11 @@
 // User Code Begin Includes
 #include "dbGroup.h"
 #include "dbModBTerm.h"
+#include "dbModNet.h"
 #include "dbModuleModInstItr.h"
 #include "dbModuleModInstModITermItr.h"
 #include "odb/dbBlockCallBackObj.h"
+#include "utl/Logger.h"
 // User Code End Includes
 namespace odb {
 template class dbTable<_dbModInst>;
@@ -326,12 +328,15 @@ std::string dbModInst::getHierarchicalName() const
 {
   _dbModInst* _obj = (_dbModInst*) this;
   dbBlock* block = (dbBlock*) _obj->getOwner();
-  std::string inst_name = std::string(getName());
+  const char* inst_name = getName();
   dbModule* parent = getParent();
   if (parent == block->getTopModule()) {
     return inst_name;
   }
-  return parent->getModInst()->getHierarchicalName() + "/" + inst_name;
+  return fmt::format("{}{}{}",
+                     parent->getModInst()->getHierarchicalName(),
+                     block->getHierarchyDelimiter(),
+                     inst_name);
 }
 
 dbModITerm* dbModInst::findModITerm(const char* name)
@@ -346,6 +351,37 @@ dbModITerm* dbModInst::findModITerm(const char* name)
   return nullptr;
 }
 
+dbModNet* dbModInst::findHierNet(const char* base_name) const
+{
+  dbModule* master = getMaster();
+  return master->getModNet(base_name);
+}
+
+dbNet* dbModInst::findFlatNet(const char* base_name) const
+{
+  dbModule* parent = getParent();
+  if (parent) {
+    dbBlock* block = parent->getOwner();
+    fmt::memory_buffer full_name_buf;
+    fmt::format_to(std::back_inserter(full_name_buf),
+                   "{}{}{}",
+                   getHierarchicalName(),
+                   block->getHierarchyDelimiter(),
+                   base_name);
+    return block->findNet(full_name_buf.data());
+  }
+  return nullptr;
+}
+
+bool dbModInst::findNet(const char* base_name,
+                        dbNet*& flat_net,
+                        dbModNet*& hier_net) const
+{
+  flat_net = findFlatNet(base_name);
+  hier_net = findHierNet(base_name);
+  return (flat_net || hier_net);
+}
+
 void dbModInst::removeUnusedPortsAndPins()
 {
   _dbModInst* obj = (_dbModInst*) this;
@@ -428,20 +464,16 @@ void dbModInst::removeUnusedPortsAndPins()
     mod_bterm->disconnect();
 
     // First destroy the net
-    if (moditerm_m_net && moditerm_m_net->getBTerms().size() == 0
-        && moditerm_m_net->getITerms().size() == 0
-        && moditerm_m_net->getModITerms().size() == 0
-        && moditerm_m_net->getModBTerms().size() == 0) {
+    if (moditerm_m_net && moditerm_m_net->getModITerms().empty()
+        && moditerm_m_net->getModBTerms().empty()) {
       dbModNet::destroy(moditerm_m_net);
     }
 
     // Now destroy the iterm
     dbModITerm::destroy(mod_iterm);
 
-    if (modbterm_m_net && modbterm_m_net->getBTerms().size() == 0
-        && modbterm_m_net->getITerms().size() == 0
-        && modbterm_m_net->getModITerms().size() == 0
-        && modbterm_m_net->getModBTerms().size() == 0) {
+    if (modbterm_m_net && modbterm_m_net->getModITerms().empty()
+        && modbterm_m_net->getModBTerms().empty()) {
       dbModNet::destroy(modbterm_m_net);
     }