Merge remote-tracking branch 'origin/master' into secure-new-slew-fix

Author: precisionmoon

src/cut/src/abc_library_factory.cpp

@@ -99,6 +99,9 @@ static bool HasNonInputOutputPorts(sta::LibertyCell* cell)
     if (port->direction()->isInput()) {
       continue;
     }
+    if (port->isPwrGnd()) {
+      continue;
+    }
 
     return true;
   }

src/dbSta/src/dbNetwork.cc

@@ -2237,7 +2237,7 @@ void dbNetwork::makeCell(Library* library, dbMaster* master)
                      mterm->getSigType().getString());
           mterm->setSigType(dbSigType::CLOCK);
         }
-      } else if (!dir->isPowerGround() && !lib_cell->findPgPort(port_name)) {
+      } else if (!dir->isPowerGround() && !lib_cell->findPort(port_name)) {
         logger_->warn(ORD,
                       2001,
                       "LEF macro {} pin {} missing from liberty cell.",
@@ -2397,7 +2397,7 @@ void dbNetwork::readLibertyAfter(LibertyLibrary* lib)
                 cport->setLibertyPort(lport);
                 lport->setExtPort(cport->extPort());
               } else if (!cport->direction()->isPowerGround()
-                         && !lcell->findPgPort(port_name)) {
+                         && !lcell->findPort(port_name)) {
                 logger_->warn(ORD,
                               2002,
                               "Liberty cell {} pin {} missing from LEF macro.",

src/dft/src/replace/ScanReplace.cpp

@@ -37,7 +37,9 @@ sta::LibertyPort* FindEquivalentPortInScanCell(
   sta::LibertyCellPortIterator scan_cell_ports_iter(scan_cell);
   while (scan_cell_ports_iter.hasNext()) {
     sta::LibertyPort* scan_cell_port = scan_cell_ports_iter.next();
-
+    if (scan_cell_port->isPwrGnd()) {
+      continue;
+    }
     bool port_equiv
         = non_scan_cell_port->direction() == scan_cell_port->direction();
     if (non_scan_cell_port->function() == nullptr
@@ -62,15 +64,18 @@ sta::LibertyPort* FindEquivalentPortInScanCell(
 // Checks the power ports between non scan cell and scan cell and checks if they
 // are equivalent. Returns the equivalent port found, otherwise nullptr if there
 // is none
-sta::LibertyPgPort* FindEquivalentPortInScanCell(
-    const sta::LibertyPgPort* non_scan_cell_port,
+sta::LibertyPort* FindEquivalentPgPortInScanCell(
+    const sta::LibertyPort* non_scan_cell_port,
     const sta::LibertyCell* scan_cell)
 {
-  sta::LibertyCellPgPortIterator scan_cell_ports_iter(scan_cell);
+  sta::LibertyCellPortIterator scan_cell_ports_iter(scan_cell);
   while (scan_cell_ports_iter.hasNext()) {
-    sta::LibertyPgPort* scan_cell_port = scan_cell_ports_iter.next();
+    sta::LibertyPort* scan_cell_port = scan_cell_ports_iter.next();
+    if (!scan_cell_port->isPwrGnd()) {
+      continue;
+    }
     const bool port_equiv
-        = sta::LibertyPgPort::equiv(non_scan_cell_port, scan_cell_port);
+        = sta::LibertyPort::equiv(non_scan_cell_port, scan_cell_port);
     if (port_equiv) {
       return scan_cell_port;
     }
@@ -91,6 +96,9 @@ bool IsScanEquivalent(
   sta::LibertyCellPortIterator non_scan_cell_ports_iter(non_scan_cell);
   while (non_scan_cell_ports_iter.hasNext()) {
     sta::LibertyPort* non_scan_cell_port = non_scan_cell_ports_iter.next();
+    if (non_scan_cell_port->isPwrGnd()) {
+      continue;
+    }
     sta::LibertyPort* scan_equiv_port
         = FindEquivalentPortInScanCell(non_scan_cell_port, scan_cell);
     if (!scan_equiv_port) {
@@ -101,12 +109,15 @@ bool IsScanEquivalent(
     seen_on_scan_cell.insert(scan_equiv_port);
   }
 
-  sta::LibertyCellPgPortIterator non_scan_cell_pg_ports_iter(non_scan_cell);
+  sta::LibertyCellPortIterator non_scan_cell_pg_ports_iter(non_scan_cell);
   while (non_scan_cell_pg_ports_iter.hasNext()) {
-    sta::LibertyPgPort* non_scan_cell_pg_port
+    sta::LibertyPort* non_scan_cell_pg_port
         = non_scan_cell_pg_ports_iter.next();
-    sta::LibertyPgPort* scan_equiv_port
-        = FindEquivalentPortInScanCell(non_scan_cell_pg_port, scan_cell);
+    if (!non_scan_cell_pg_port->isPwrGnd()) {
+      continue;
+    }
+    sta::LibertyPort* scan_equiv_port
+        = FindEquivalentPgPortInScanCell(non_scan_cell_pg_port, scan_cell);
     if (!scan_equiv_port) {
       return false;
     }
@@ -121,6 +132,9 @@ bool IsScanEquivalent(
   sta::LibertyCellPortIterator scan_cell_ports_iter(scan_cell);
   while (scan_cell_ports_iter.hasNext()) {
     sta::LibertyPort* scan_cell_port = scan_cell_ports_iter.next();
+    if (scan_cell_port->isPwrGnd()) {
+      continue;
+    }
     if (seen_on_scan_cell.find(scan_cell_port) != seen_on_scan_cell.end()) {
       continue;
     }

src/gpl/src/mbff.cpp

@@ -753,7 +753,7 @@ MBFF::DataToOutputsMap MBFF::GetPinMapping(dbInst* tray)
     if (port->isBus() || port->isBundle()) {
       continue;
     }
-    if (port->isClock()) {
+    if (port->isPwrGnd() || port->isClock()) {
       continue;
     }
     if (port->direction()->isInput()) {

src/gui/src/mainWindow.cpp

@@ -634,8 +634,6 @@ void MainWindow::init(sta::dbSta* sta, const std::string& help_path)
       new LibertyLibraryDescriptor(sta));
   gui->registerDescriptor<sta::LibertyCell*>(new LibertyCellDescriptor(sta));
   gui->registerDescriptor<sta::LibertyPort*>(new LibertyPortDescriptor(sta));
-  gui->registerDescriptor<sta::LibertyPgPort*>(
-      new LibertyPgPortDescriptor(sta));
   gui->registerDescriptor<sta::Instance*>(new StaInstanceDescriptor(sta));
   gui->registerDescriptor<sta::Clock*>(new ClockDescriptor(sta));
 

src/gui/src/staDescriptors.cpp

@@ -301,9 +301,14 @@ Descriptor::Properties LibertyCellDescriptor::getProperties(
 
   std::array<SelectionSet, 8> ports;
   sta::LibertyCellPortIterator port_iter(cell);
+  SelectionSet pg_ports;
   while (port_iter.hasNext()) {
     auto port = port_iter.next();
-    ports[port->direction()->index()].insert(gui->makeSelected(port));
+    if (port->isPwrGnd()) {
+      pg_ports.insert(gui->makeSelected(port));
+    } else {
+      ports[port->direction()->index()].insert(gui->makeSelected(port));
+    }
   }
   for (auto dir : {sta::PortDirection::input(),
                    sta::PortDirection::output(),
@@ -321,11 +326,6 @@ Descriptor::Properties LibertyCellDescriptor::getProperties(
     }
   }
 
-  SelectionSet pg_ports;
-  sta::LibertyCellPgPortIterator pg_port_iter(cell);
-  while (pg_port_iter.hasNext()) {
-    pg_ports.insert(gui->makeSelected(pg_port_iter.next()));
-  }
   props.push_back({"PG Ports", pg_ports});
 
   SelectionSet insts;
@@ -476,9 +476,12 @@ Descriptor::Properties LibertyPortDescriptor::getProperties(
   std::any ground_pin;
   const char* power_pin_name = port->relatedPowerPin();
   const char* ground_pin_name = port->relatedGroundPin();
-  sta::LibertyCellPgPortIterator pg_port_iter(port->libertyCell());
+  sta::LibertyCellPortIterator pg_port_iter(port->libertyCell());
   while (pg_port_iter.hasNext()) {
     auto* pg_port = pg_port_iter.next();
+    if (!pg_port->isPwrGnd()) {
+      continue;
+    }
     if (power_pin_name != nullptr
         && strcmp(pg_port->name(), power_pin_name) == 0) {
       power_pin = gui->makeSelected(pg_port);
@@ -541,132 +544,6 @@ void LibertyPortDescriptor::visitAllObjects(
 
 //////////////////////////////////////////////////
 
-static const char* typeNameStr(sta::LibertyPgPort::PgType type)
-{
-  switch (type) {
-    case sta::LibertyPgPort::unknown:
-      return "unknown";
-    case sta::LibertyPgPort::primary_power:
-      return "primary_power";
-    case sta::LibertyPgPort::primary_ground:
-      return "primary_ground";
-    case sta::LibertyPgPort::backup_power:
-      return "backup_power";
-    case sta::LibertyPgPort::backup_ground:
-      return "backup_ground";
-    case sta::LibertyPgPort::internal_power:
-      return "internal_power";
-    case sta::LibertyPgPort::internal_ground:
-      return "internal_ground";
-    case sta::LibertyPgPort::nwell:
-      return "nwell";
-    case sta::LibertyPgPort::pwell:
-      return "pwell";
-    case sta::LibertyPgPort::deepnwell:
-      return "deepnwell";
-    case sta::LibertyPgPort::deeppwell:
-      return "deeppwell";
-  }
-  return "<unexpected>";
-}
-
-LibertyPgPortDescriptor::LibertyPgPortDescriptor(sta::dbSta* sta) : sta_(sta)
-{
-}
-
-std::string LibertyPgPortDescriptor::getName(const std::any& object) const
-{
-  return std::any_cast<sta::LibertyPgPort*>(object)->name();
-}
-
-std::string LibertyPgPortDescriptor::getTypeName() const
-{
-  return "Liberty PG port";
-}
-
-bool LibertyPgPortDescriptor::getBBox(const std::any& object,
-                                      odb::Rect& bbox) const
-{
-  return false;
-}
-
-void LibertyPgPortDescriptor::highlight(const std::any& object,
-                                        Painter& painter) const
-{
-  odb::dbMTerm* mterm = getMTerm(object);
-
-  if (mterm != nullptr) {
-    auto* mterm_desc = Gui::get()->getDescriptor<odb::dbMTerm*>();
-    mterm_desc->highlight(mterm, painter);
-  }
-}
-
-Descriptor::Properties LibertyPgPortDescriptor::getProperties(
-    const std::any& object) const
-{
-  auto port = std::any_cast<sta::LibertyPgPort*>(object);
-
-  auto gui = Gui::get();
-
-  Properties props;
-  props.push_back({"Cell", gui->makeSelected(port->cell())});
-  props.push_back({"Type", typeNameStr(port->pgType())});
-  props.push_back({"Voltage name", port->voltageName()});
-
-  odb::dbMTerm* mterm = getMTerm(object);
-  if (mterm != nullptr) {
-    props.push_back({"Terminal", gui->makeSelected(mterm)});
-  }
-
-  return props;
-}
-
-Selected LibertyPgPortDescriptor::makeSelected(const std::any& object) const
-{
-  if (auto port = std::any_cast<sta::LibertyPgPort*>(&object)) {
-    return Selected(*port, this);
-  }
-  return Selected();
-}
-
-bool LibertyPgPortDescriptor::lessThan(const std::any& l,
-                                       const std::any& r) const
-{
-  auto l_port = std::any_cast<sta::LibertyPgPort*>(l);
-  auto r_port = std::any_cast<sta::LibertyPgPort*>(r);
-  return strcmp(l_port->name(), r_port->name()) < 0;
-}
-
-void LibertyPgPortDescriptor::visitAllObjects(
-    const std::function<void(const Selected&)>& func) const
-{
-  sta::dbNetwork* network = sta_->getDbNetwork();
-  std::unique_ptr<sta::LibertyLibraryIterator> lib_iter{
-      network->libertyLibraryIterator()};
-
-  while (lib_iter->hasNext()) {
-    sta::LibertyLibrary* library = lib_iter->next();
-    sta::LibertyCellIterator cell_iter(library);
-    while (cell_iter.hasNext()) {
-      sta::LibertyCell* cell = cell_iter.next();
-      sta::LibertyCellPgPortIterator port_iter(cell);
-      while (port_iter.hasNext()) {
-        sta::LibertyPgPort* port = port_iter.next();
-        func({port, this});
-      }
-    }
-  }
-}
-
-odb::dbMTerm* LibertyPgPortDescriptor::getMTerm(const std::any& object) const
-{
-  auto port = std::any_cast<sta::LibertyPgPort*>(object);
-  odb::dbMaster* master = sta_->getDbNetwork()->staToDb(port->cell());
-  odb::dbMTerm* mterm = master->findMTerm(port->name());
-
-  return mterm;
-}
-
 CornerDescriptor::CornerDescriptor(sta::dbSta* sta) : sta_(sta)
 {
 }

src/gui/src/staDescriptors.h

@@ -90,30 +90,6 @@ class LibertyPortDescriptor : public Descriptor
   sta::dbSta* sta_;
 };
 
-class LibertyPgPortDescriptor : public Descriptor
-{
- public:
-  LibertyPgPortDescriptor(sta::dbSta* sta);
-
-  std::string getName(const std::any& object) const override;
-  std::string getTypeName() const override;
-  bool getBBox(const std::any& object, odb::Rect& bbox) const override;
-
-  void highlight(const std::any& object, Painter& painter) const override;
-
-  Properties getProperties(const std::any& object) const override;
-  Selected makeSelected(const std::any& object) const override;
-  bool lessThan(const std::any& l, const std::any& r) const override;
-
-  void visitAllObjects(
-      const std::function<void(const Selected&)>& func) const override;
-
- private:
-  odb::dbMTerm* getMTerm(const std::any& object) const;
-
-  sta::dbSta* sta_;
-};
-
 class CornerDescriptor : public Descriptor
 {
  public:

src/rsz/src/BaseMove.cc

@@ -864,7 +864,7 @@ vector<const LibertyPort*> BaseMove::getOutputPorts(const LibertyCell* cell)
   sta::LibertyCellPortIterator port_iter(cell);
   while (port_iter.hasNext()) {
     const LibertyPort* port = port_iter.next();
-    if (port->direction()->isOutput()) {
+    if (!port->isPwrGnd() && port->direction()->isOutput()) {
       fanouts.push_back(port);
     }
   }

src/rsz/src/RepairDesign.cc

@@ -589,7 +589,7 @@ bool RepairDesign::getLargestSizeCin(const Pin* drvr_pin, float& cin)
       int nports = 0;
       while (port_iter.hasNext()) {
         const LibertyPort* port = port_iter.next();
-        if (port->direction() == PortDirection::input()) {
+        if (!port->isPwrGnd() && port->direction() == PortDirection::input()) {
           size_cin += port->capacitance();
           nports++;
         }
@@ -618,7 +618,7 @@ bool RepairDesign::getCin(const Pin* drvr_pin, float& cin)
     int nports = 0;
     while (port_iter.hasNext()) {
       const LibertyPort* port = port_iter.next();
-      if (port->direction() == PortDirection::input()) {
+      if (!port->isPwrGnd() && port->direction() == PortDirection::input()) {
         cin += port->capacitance();
         nports++;
       }

src/rsz/src/Resizer.cc

@@ -1538,7 +1538,9 @@ std::vector<sta::LibertyPort*> Resizer::libraryPins(LibertyCell* cell) const
   sta::LibertyCellPortIterator itr(cell);
   while (itr.hasNext()) {
     auto port = itr.next();
-    pins.emplace_back(port);
+    if (!port->isPwrGnd()) {
+      pins.emplace_back(port);
+    }
   }
   return pins;
 }