Merge pull request #8980 from The-OpenROAD-Project-staging/secure-override-highest-net-above

dbNetwork: Overridden `Net* Network::highestNetAbove(Net*)` to resolve hang issue

Author: maliberty

src/dbSta/include/db_sta/dbNetwork.hh

@@ -337,6 +337,11 @@ class dbNetwork : public ConcreteNetwork
 
   bool hasPort(const Net* net) const;
 
+  // Return the highest net above the given net.
+  // - If the net is a flat net, return it.
+  // - If the net is a hier net, return the modnet in the highest hierarchy.
+  Net* highestNetAbove(Net* net) const override;
+
   ////////////////////////////////////////////////////////////////
   // Edit functions
   Instance* makeInstance(LibertyCell* cell,

src/dbSta/src/dbNetwork.cc

@@ -5014,4 +5014,36 @@ bool dbNetwork::isPGSupply(dbNet* net) const
   return net->isSpecial() && net->getSigType().isSupply();
 }
 
+Net* dbNetwork::highestNetAbove(Net* net) const
+{
+  if (net == nullptr) {
+    return nullptr;
+  }
+
+  dbNet* dbnet;
+  dbModNet* modnet;
+  staToDb(net, dbnet, modnet);
+
+  if (dbnet) {
+    // If a flat net, return it.
+    // - We should not return the highest modnet related to the flat net.
+    // - Otherwise, it breaks estimate_parasitics function.
+    //   . est module uses flat nets for parasitic estimation
+    //   . It has (highestNetAbove(flat_net) != flat_net) comparison.
+    //   . If highestNetAbove(flat_net) returns the highest modnet, it
+    //     changes the estimate_parasitics behavior.
+    return net;
+  }
+
+  if (modnet) {
+    if (dbNet* related_dbnet = modnet->findRelatedNet()) {
+      if (dbModNet* highest_modnet = related_dbnet->findModNetInHighestHier()) {
+        return dbToSta(highest_modnet);  // Found the highest modnet
+      }
+    }
+  }
+
+  return net;
+}
+
 }  // namespace sta

src/dbSta/test/cpp/TestDbSta.cc

@@ -5,6 +5,7 @@
 #include <cstdio>
 #include <string>
 
+#include "db_sta/dbNetwork.hh"
 #include "gtest/gtest.h"
 #include "odb/db.h"
 #include "sta/NetworkClass.hh"
@@ -22,7 +23,7 @@ class TestDbSta : public tst::IntegratedFixture
   }
 };
 
-TEST_F(TestDbSta, TestIsConnected)
+TEST_F(TestDbSta, TestHierarchyConnectivity)
 {
   std::string test_name = "TestDbSta_0";
   readVerilogAndSetup(test_name + ".v");
@@ -59,6 +60,41 @@ TEST_F(TestDbSta, TestIsConnected)
 
   bool_return = db_network_->isConnected(sta_net, sta_modnet);
   ASSERT_TRUE(bool_return);
+
+  // Check Network::highestNetAbove(Net* net)
+  odb::dbNet* dbnet_out2 = block_->findNet("out2");
+  ASSERT_NE(dbnet_out2, nullptr);
+  Net* sta_dbnet_out2 = db_network_->dbToSta(dbnet_out2);
+  ASSERT_NE(sta_dbnet_out2, nullptr);
+  Net* sta_highest_net = db_network_->highestNetAbove(sta_dbnet_out2);
+  ASSERT_EQ(sta_highest_net, sta_dbnet_out2);
+
+  odb::dbModNet* modnet_mod_out = block_->findModNet("sub_inst/mod_out");
+  ASSERT_NE(modnet_mod_out, nullptr);
+  Net* sta_modnet_mod_out = db_network_->dbToSta(modnet_mod_out);
+  ASSERT_NE(sta_modnet_mod_out, nullptr);
+  odb::dbModNet* modnet_out2 = block_->findModNet("out2");
+  ASSERT_NE(modnet_out2, nullptr);
+  Net* sta_modnet_out2 = db_network_->dbToSta(modnet_out2);
+  ASSERT_NE(sta_modnet_out2, nullptr);
+  Net* sta_highest_modnet_out
+      = db_network_->highestNetAbove(sta_modnet_mod_out);
+  ASSERT_EQ(sta_highest_modnet_out, sta_modnet_out2);
+
+  // Check get_ports -of_object Net*
+  NetTermIterator* term_iter = db_network_->termIterator(sta_dbnet_out2);
+  while (term_iter->hasNext()) {
+    Term* term = term_iter->next();
+    Pin* pin = db_network_->pin(term);
+    Port* port = db_network_->port(pin);
+    ASSERT_EQ(db_network_->name(port), block_->findBTerm("out2")->getName());
+  }
+
+  // Check dbBTerm::getITerm()
+  odb::dbBTerm* bterm_clk = block_->findBTerm("in1");
+  ASSERT_NE(bterm_clk, nullptr);
+  // There is no related dbITerm for a dbBTerm
+  ASSERT_EQ(bterm_clk->getITerm(), nullptr);
 }
 
 }  // namespace sta

src/odb/include/odb/db.h

@@ -786,6 +786,20 @@ class dbBlock : public dbObject
   ///
   dbModInst* findModInst(const char* path);
 
+  ///
+  /// Find a specific moditerm in this block. path is
+  /// master_module_name/modinst_name/term_name Returns nullptr if the object
+  /// was not found.
+  ///
+  dbModITerm* findModITerm(const char* hierarchical_name);
+
+  ///
+  /// Find a specific modbterm in this block. path is
+  /// master_module_name/modinst_name/term_name Returns nullptr if the object
+  /// was not found.
+  ///
+  dbModBTerm* findModBTerm(const char* hierarchical_name);
+
   ///
   /// Find a specific PowerDomain in this block.
   /// Returns nullptr if the object was not found.

src/odb/src/db/dbBlock.cpp

@@ -3885,4 +3885,52 @@ const char* dbBlock::getBaseName(const char* full_name) const
   return full_name;
 }
 
+dbModITerm* dbBlock::findModITerm(const char* hierarchical_name)
+{
+  if (hierarchical_name == nullptr) {
+    return nullptr;
+  }
+
+  const char* last_delim = strrchr(hierarchical_name, getHierarchyDelimiter());
+  if (last_delim == nullptr) {
+    return nullptr;
+  }
+
+  std::string inst_path(hierarchical_name, last_delim - hierarchical_name);
+  const char* term_name = last_delim + 1;
+
+  dbModInst* inst = findModInst(inst_path.c_str());
+  if (inst) {
+    return inst->findModITerm(term_name);
+  }
+  return nullptr;
+}
+
+dbModBTerm* dbBlock::findModBTerm(const char* hierarchical_name)
+{
+  if (hierarchical_name == nullptr) {
+    return nullptr;
+  }
+
+  const char* last_delim = strrchr(hierarchical_name, getHierarchyDelimiter());
+  if (last_delim == nullptr) {
+    // Top level port
+    if (dbModule* top_module = getTopModule()) {
+      return top_module->findModBTerm(hierarchical_name);
+    }
+    return nullptr;
+  }
+
+  std::string inst_path(hierarchical_name, last_delim - hierarchical_name);
+  const char* term_name = last_delim + 1;
+
+  dbModInst* inst = findModInst(inst_path.c_str());
+  if (inst) {
+    if (dbModule* master = inst->getMaster()) {
+      return master->findModBTerm(term_name);
+    }
+  }
+  return nullptr;
+}
+
 }  // namespace odb

src/odb/src/db/dbNet.cpp

@@ -2531,10 +2531,16 @@ dbModNet* dbNet::findModNetInHighestHier() const
   size_t min_delimiters = (size_t) -1;
   char delim = getBlock()->getHierarchyDelimiter();
 
+  // Network::highestConnectedNet(Net *net) compares level of hierarchy and
+  // hierarchical net name as a tie breaker.
+  // For consistency, this API also uses the hierarchical net name as a tie
+  // breaker.
   for (dbModNet* modnet : modnets) {
     std::string name = modnet->getHierarchicalName();
     size_t num_delimiters = std::count(name.begin(), name.end(), delim);
-    if (highest == nullptr || num_delimiters < min_delimiters) {
+    if (highest == nullptr || num_delimiters < min_delimiters
+        || (num_delimiters == min_delimiters
+            && name < highest->getHierarchicalName())) {  // name = tie breaker
       min_delimiters = num_delimiters;
       highest = modnet;
     }