Merge pull request #8021 from The-OpenROAD-Project-staging/secure-integrate-hier-fixes3

Hier: Added getOrFindFlatNet() APIs and fixed assert fails.

Author: maliberty

src/dbSta/include/db_sta/dbNetwork.hh

@@ -231,6 +231,7 @@ class dbNetwork : public ConcreteNetwork
   dbNet* findRelatedDbNet(const dbModNet*) const;
   dbModNet* findModNetForPin(const Pin*);
   dbModNet* findRelatedModNet(const dbNet*) const;
+  dbModInst* getModInst(Instance* inst) const;
 
   ////////////////////////////////////////////////////////////////
   // Pin functions
@@ -304,8 +305,11 @@ class dbNetwork : public ConcreteNetwork
   const Net* highestConnectedNet(Net* net) const override;
   bool isSpecial(Net* net);
   dbNet* flatNet(const Net* net) const;
-  Net* getFlatNet(Net* net) const;
-  dbModInst* getModInst(Instance* inst) const;
+  Net* getOrFindFlatNet(const Net* net) const;
+  dbNet* getOrFindFlatDbNet(const Net* net) const;
+  Net* getOrFindFlatNet(const Pin* pin) const;
+  dbNet* getOrFindFlatDbNet(const Pin* pin) const;
+  bool hasPort(const Net* net) const;
 
   ////////////////////////////////////////////////////////////////
   // Edit functions

src/dbSta/src/dbNetwork.cc

@@ -2621,8 +2621,8 @@ Net* dbNetwork::mergedInto(Net*)
 
 bool dbNetwork::isSpecial(Net* net)
 {
-  dbNet* db_net = staToDb(net);
-  return db_net->isSpecial();
+  dbNet* db_net = getOrFindFlatDbNet(net);
+  return (db_net && db_net->isSpecial());
 }
 
 ////////////////////////////////////////////////////////////////
@@ -3717,15 +3717,15 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
     for (auto module_to_clean_up : source_parent_tree) {
       dbModInst* mi = module_to_clean_up->getModInst();
       if (mi) {
-        mi->RemoveUnusedPortsAndPins();
+        mi->removeUnusedPortsAndPins();
         cleaned_up.insert(mi);
       }
     }
     for (auto module_to_clean_up : dest_parent_tree) {
       dbModInst* mi = module_to_clean_up->getModInst();
       if (mi) {
         if (cleaned_up.find(mi) == cleaned_up.end()) {
-          mi->RemoveUnusedPortsAndPins();
+          mi->removeUnusedPortsAndPins();
           cleaned_up.insert(mi);
         }
       }
@@ -3736,7 +3736,7 @@ void dbNetwork::hierarchicalConnect(dbITerm* source_pin,
 void dbNetwork::removeUnusedPortsAndPinsOnModuleInstances()
 {
   for (auto mi : block()->getModInsts()) {
-    mi->RemoveUnusedPortsAndPins();
+    mi->removeUnusedPortsAndPins();
   }
 }
 
@@ -4228,19 +4228,60 @@ void dbNetwork::checkAxioms()
   checkSanityNetNames();
 }
 
-Net* dbNetwork::getFlatNet(Net* net) const
+// Given a net that may be hierarchical, find the corresponding flat net.
+// If the net is already a flat net, it is returned as is.
+// If the net is a hierarchical net (dbModNet), find the associated dbNet and
+// return it as Net*.
+Net* dbNetwork::getOrFindFlatNet(const Net* net) const
+{
+  return dbToSta(getOrFindFlatDbNet(net));
+}
+
+// Given a net that may be hierarchical, find the corresponding flat dbNet.
+// If the net is already a flat net (dbNet), it is returned as is.
+// If the net is a hierarchical net (dbModNet), find the associated dbNet.
+dbNet* dbNetwork::getOrFindFlatDbNet(const Net* net) const
 {
   if (!net) {
     return nullptr;
   }
   // Convert net to a flat net, if not already
-  dbNet* db_net;
-  dbModNet* db_mod_net;
+  dbNet* db_net = nullptr;
+  dbModNet* db_mod_net = nullptr;
   staToDb(net, db_net, db_mod_net);
+
+  if (db_net) {
+    // If it's already a flat net, return it
+    return db_net;
+  }
+
   if (db_mod_net) {
+    // If it's a hierarchical net, find the associated dbNet
+    // by traversing the hierarchy.
     db_net = findRelatedDbNet(db_mod_net);
   }
-  return dbToSta(db_net);
+  return db_net;
+}
+
+// Find the flat net connected to the pin.
+// This function handles both internal instance pins and top-level port pins.
+Net* dbNetwork::getOrFindFlatNet(const Pin* pin) const
+{
+  return dbToSta(getOrFindFlatDbNet(pin));
+}
+
+// Find the flat net (dbNet) connected to the pin in the OpenDB database.
+// This function handles both internal instance pins and top-level port pins.
+dbNet* dbNetwork::getOrFindFlatDbNet(const Pin* pin) const
+{
+  dbNet* db_net = nullptr;
+  if (isTopLevelPort(pin)) {
+    Net* net = this->net(term(pin));
+    db_net = flatNet(net);
+  } else {
+    db_net = flatNet(pin);
+  }
+  return db_net;
 }
 
 dbModInst* dbNetwork::getModInst(Instance* inst) const
@@ -4255,6 +4296,24 @@ dbModInst* dbNetwork::getModInst(Instance* inst) const
   return db_mod_inst;
 }
 
+bool dbNetwork::hasPort(const Net* net) const
+{
+  if (!net) {
+    return false;
+  }
+
+  dbNet* db_net = nullptr;
+  dbModNet* db_mod_net = nullptr;
+  staToDb(net, db_net, db_mod_net);
+  if (db_net) {
+    return !db_net->getBTerms().empty();
+  }
+  if (db_mod_net) {
+    return !db_mod_net->getBTerms().empty();
+  }
+  return false;
+}
+
 void dbNetwork::checkSanityModBTerms()
 {
   if (block_ == nullptr) {

src/dbSta/test/cpp/TestHconn.cpp

@@ -107,7 +107,7 @@ void DbStrDebugHierarchy(dbBlock* block, std::stringstream& str_db)
     sprintf(tmp_str,
             "\tModule %s %s\n",
             (cur_obj == block->getTopModule()) ? "(Top Module)" : "",
-            ((dbModule*) cur_obj)->getName());
+            cur_obj->getName());
     str_db << tmp_str;
     // in case of top level, care as the bterms double up as pins
     if (cur_obj == block->getTopModule()) {

src/est/src/EstimateParasitics.cpp

@@ -993,13 +993,8 @@ SteinerTree* EstimateParasitics::makeSteinerTree(const Pin* drvr_pin)
   /*
     Handle hierarchy. Make sure all traversal on dbNets.
    */
-  odb::dbNet* db_net = db_network_->flatNet(drvr_pin);
-
-  Net* net
-      = network_->isTopLevelPort(drvr_pin)
-            ? network_->net(network_->term(drvr_pin))
-            // original code, could retrun a mod net  : network_->net(drvr_pin);
-            : db_network_->dbToSta(db_net);
+  odb::dbNet* db_net = db_network_->getOrFindFlatDbNet(drvr_pin);
+  Net* net = db_network_->dbToSta(db_net);
 
   debugPrint(logger_, EST, "steiner", 1, "Net {}", sdc_network->pathName(net));
   SteinerTree* tree = new SteinerTree(drvr_pin, db_network_, logger_);
@@ -1042,8 +1037,7 @@ SteinerTree* EstimateParasitics::makeSteinerTree(const Pin* drvr_pin)
       tree->locAddPin(pinloc.loc, pinloc.pin);
     }
     if (is_placed) {
-      stt::Tree ftree = stt_builder_->makeSteinerTree(
-          db_network_->staToDb(net), x, y, drvr_idx);
+      stt::Tree ftree = stt_builder_->makeSteinerTree(db_net, x, y, drvr_idx);
 
       tree->setTree(ftree);
       tree->createSteinerPtToPinMap();

src/gui/src/staGuiInterface.cpp

@@ -724,7 +724,7 @@ sta::Net* ClockTree::getNet(const sta::Pin* pin) const
 {
   sta::Term* term = network_->term(pin);
   sta::Net* net = term ? network_->net(term) : network_->net(pin);
-  return network_->getFlatNet(net);
+  return network_->getOrFindFlatNet(net);
 }
 
 bool ClockTree::isLeaf(const sta::Pin* pin) const

src/odb/include/odb/db.h

@@ -8025,7 +8025,7 @@ class dbModInst : public dbObject
 
   dbSet<dbModITerm> getModITerms();
 
-  void RemoveUnusedPortsAndPins();
+  void removeUnusedPortsAndPins();
 
   /// Swap the module of this instance.
   /// Returns new mod inst if the operations succeeds.
@@ -8116,7 +8116,7 @@ class dbModule : public dbObject
   // Get the ports of a module (STA world uses ports, which contain members).
   dbSet<dbModBTerm> getPorts();
   // Get the leaf level connections on a module (flat connected view).
-  dbSet<dbModBTerm> getModBTerms();
+  dbSet<dbModBTerm> getModBTerms() const;
   dbModBTerm* getModBTerm(uint id);
   dbSet<dbInst> getInsts();
 
@@ -8130,6 +8130,7 @@ class dbModule : public dbObject
   int getDbInstCount();
 
   const dbModBTerm* getHeadDbModBTerm() const;
+  bool canSwapWith(dbModule* new_module) const;
 
   static dbModule* create(dbBlock* block, const char* name);