Merge remote-tracking branch 'upstream/master'

Author: maliberty

graph/Graph.cc

@@ -594,7 +594,6 @@ Graph::deletePaths(Vertex *vertex)
 {
   vertex->setPaths(nullptr);
   vertex->tag_group_index_ = tag_group_index_max;
-  vertex->crpr_path_pruning_disabled_ = false;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -998,7 +997,6 @@ Vertex::init(Pin *pin,
   visited1_ = false;
   visited2_ = false;
   bfs_in_queue_ = 0;
-  crpr_path_pruning_disabled_ = false;
 }
 
 Vertex::~Vertex()
@@ -1120,12 +1118,6 @@ Vertex::removeSlewAnnotated()
   slew_annotated_ = 0;
 }
 
-void
-Vertex::setCrprPathPruningDisabled(bool disabled)
-{
-  crpr_path_pruning_disabled_ = disabled;
-}
-
 TagGroupIndex
 Vertex::tagGroupIndex() const
 {

include/sta/Graph.hh

@@ -304,8 +304,6 @@ public:
   bool bfsInQueue(BfsIndex index) const;
   void setBfsInQueue(BfsIndex index, bool value);
   bool isRegClk() const { return is_reg_clk_; }
-  bool crprPathPruningDisabled() const { return crpr_path_pruning_disabled_;}
-  void setCrprPathPruningDisabled(bool disabled);
 
   // ObjectTable interface.
   ObjectIdx objectIdx() const { return object_idx_; }
@@ -353,7 +351,6 @@ protected:
   bool is_check_clk_:1;
   bool is_constrained_:1;
   bool has_downstream_clk_pin_:1;
-  bool crpr_path_pruning_disabled_:1;
   bool visited1_:1;
   bool visited2_:1;
 

include/sta/PathGroup.hh

@@ -134,8 +134,12 @@ public:
   PathGroup *findPathGroup(const Clock *clock,
 			   const MinMax *min_max) const;
   PathGroup *pathGroup(const PathEnd *path_end) const;
-  static bool isGroupPathName(const char *group_name);
+  static std::string pathGroupName(const PathEnd *path_end,
+				   const StaState *sta);
   static const char *asyncPathGroupName() { return async_group_name_; }
+  static const char *pathDelayGroupName() { return  path_delay_group_name_; }
+  static const char *gatedClkGroupName() { return gated_clk_group_name_; }
+  static const char *unconstrainedGroupName() { return unconstrained_group_name_; }
 
 protected:
   void makeGroupPathEnds(ExceptionTo *to,
@@ -175,7 +179,8 @@ protected:
 		  const MinMax *min_max);
   bool reportGroup(const char *group_name,
 		   PathGroupNameSet *group_names) const;
-  GroupPath *groupPathTo(const PathEnd *path_end) const;
+  static GroupPath *groupPathTo(const PathEnd *path_end,
+				const StaState *sta);
 
   int group_path_count_;
   int endpoint_path_count_;

include/sta/Sta.hh

@@ -73,6 +73,7 @@ typedef InstanceSeq::Iterator SlowDrvrIterator;
 typedef Vector<const char*> CheckError;
 typedef Vector<CheckError*> CheckErrorSeq;
 typedef Vector<Corner*> CornerSeq;
+typedef std::vector<std::string> StdStringSeq;
 
 enum class CmdNamespace { sta, sdc };
 
@@ -516,7 +517,10 @@ public:
 		     ExceptionThruSeq *thrus,
 		     ExceptionTo *to,
 		     const char *comment);
-  bool isGroupPathName(const char *group_name);
+  // Deprecated 10/24/2025
+  bool isGroupPathName(const char *group_name) __attribute__ ((deprecated));
+  bool isPathGroupName(const char *group_name) const;
+  StdStringSeq pathGroupNames() const;
   void resetPath(ExceptionFrom *from,
 		 ExceptionThruSeq *thrus,
 		 ExceptionTo *to,
@@ -1002,6 +1006,10 @@ public:
 		 const MinMax *min_max);
   Slack pinSlack(const Pin *pin,
 		 const MinMax *min_max);
+  // Worst slack for an endpoint in a path group.
+  Slack endpointSlack(const Pin *pin,
+		      const std::string &path_group_name,
+		      const MinMax *min_max);
   Slack vertexSlack(Vertex *vertex,
 		    const MinMax *min_max);
   Slack vertexSlack(Vertex *vertex,
@@ -1437,8 +1445,6 @@ protected:
 			Corner *corner,
 			const MinMax *min_max);
   void powerPreamble();
-  void disableFanoutCrprPruning(Vertex *vertex,
-				int &fanou);
   virtual void replaceCell(Instance *inst,
                            Cell *to_cell,
                            LibertyCell *to_lib_cell);

sdc/Sdc.i

@@ -734,7 +734,7 @@ make_group_path(const char *name,
 bool
 is_path_group_name(const char *name)
 {
-  return Sta::sta()->isGroupPathName(name);
+  return Sta::sta()->isPathGroupName(name);
 }
 
 ExceptionFrom *
@@ -863,7 +863,7 @@ set_clock_sense_cmd(PinSet *pins,
   else if (stop_propagation)
     sta->setClockSense(pins, clks, ClockSense::stop);
   else
-    sta->report()->critical(1577, "unknown clock sense");
+    sta->report()->critical(2123, "unknown clock sense");
 }
 
 void
@@ -1328,7 +1328,7 @@ filter_timing_arcs(const char *property,
 ////////////////////////////////////////////////////////////////
 
 StringSeq
-path_group_names()
+group_path_names()
 {
   StringSeq pg_names;
   for (auto const& [name, group] : Sta::sta()->sdc()->groupPaths())

search/PathGroup.cc

@@ -248,15 +248,6 @@ const char *PathGroups::gated_clk_group_name_ = "gated clock";
 const char *PathGroups::async_group_name_ = "asynchronous";
 const char *PathGroups::unconstrained_group_name_ = "unconstrained";
 
-bool
-PathGroups::isGroupPathName(const char *group_name)
-{
-  return stringEq(group_name, path_delay_group_name_)
-    || stringEq(group_name, gated_clk_group_name_)
-    || stringEq(group_name, async_group_name_)
-    || stringEq(group_name, unconstrained_group_name_);
-}
-
 PathGroups::PathGroups(int group_path_count,
 		       int endpoint_path_count,
 		       bool unique_pins,
@@ -412,7 +403,7 @@ PathGroups::pathGroup(const PathEnd *path_end) const
 {
   const MinMax *min_max = path_end->minMax(this);
   int mm_index =  min_max->index();
-  GroupPath *group_path = groupPathTo(path_end);
+  GroupPath *group_path = groupPathTo(path_end, this);
   if (path_end->isUnconstrained())
     return unconstrained_[mm_index];
   // GroupPaths have precedence.
@@ -455,16 +446,63 @@ PathGroups::pathGroup(const PathEnd *path_end) const
   }
 }
 
+// Mirrors PathGroups::pathGroup.
+std::string
+PathGroups::pathGroupName(const PathEnd *path_end,
+			  const StaState *sta)
+{
+  GroupPath *group_path = groupPathTo(path_end, sta);
+  if (path_end->isUnconstrained())
+    return unconstrained_group_name_;
+  // GroupPaths have precedence.
+  else if (group_path) {
+   if (group_path->isDefault())
+     return path_delay_group_name_;
+   else
+     return group_path->name();
+  }
+  else if (path_end->isCheck() || path_end->isLatchCheck()) {
+    const TimingRole *check_role = path_end->checkRole(sta);
+    const Clock *tgt_clk = path_end->targetClk(sta);
+    if (check_role == TimingRole::removal()
+	|| check_role == TimingRole::recovery())
+      return async_group_name_;
+    else
+      return tgt_clk->name();
+  }
+  else if (path_end->isOutputDelay()
+	   || path_end->isDataCheck())
+    return path_end->targetClk(sta)->name();
+  else if (path_end->isGatedClock())
+    return gated_clk_group_name_;
+  else if (path_end->isPathDelay()) {
+    // Path delays that end at timing checks are part of the target clk group
+    // unless -ignore_clock_latency is true.
+    PathDelay *path_delay = path_end->pathDelay();
+    const Clock *tgt_clk = path_end->targetClk(sta);
+    if (tgt_clk
+	&& !path_delay->ignoreClkLatency())
+      return tgt_clk->name();
+    else
+      return path_delay_group_name_;
+  }
+  else {
+    sta->report()->critical(1391, "unknown path end type");
+    return nullptr;
+  }
+}
+
 GroupPath *
-PathGroups::groupPathTo(const PathEnd *path_end) const
+PathGroups::groupPathTo(const PathEnd *path_end,
+			const StaState *sta)
 {
   const Path *path = path_end->path();
-  const Pin *pin = path->pin(this);
+  const Pin *pin = path->pin(sta);
   ExceptionPath *exception = 
-    search_->exceptionTo(ExceptionPathType::group_path, path,
-			 pin, path->transition(this),
-			 path_end->targetClkEdge(this),
-			 path->minMax(this), false, false);
+    sta->search()->exceptionTo(ExceptionPathType::group_path, path,
+			       pin, path->transition(sta),
+			       path_end->targetClkEdge(sta),
+			       path->minMax(sta), false, false);
   return dynamic_cast<GroupPath*>(exception);
 }
 

search/Search.cc

@@ -1182,7 +1182,6 @@ ArrivalVisitor::visit(Vertex *vertex)
     visitFaninPaths(vertex);
     if (crpr_active_
         && search_->crprPathPruningEnabled()
-        && !vertex->crprPathPruningDisabled()
         // No crpr for ideal clocks.
         && tag_bldr_->hasPropagatedClk()
         && !has_fanin_one_)

search/Search.i

@@ -251,6 +251,31 @@ vertex_worst_slack_path(Vertex *vertex,
   return sta->vertexWorstSlackPath(vertex, min_max);
 }
 
+Slack
+endpoint_slack(const Pin *pin,
+	       const char *path_group_name,
+	       const MinMax *min_max)
+{
+  Sta *sta = Sta::sta();
+  sta->ensureLibLinked();
+  if (sta->isGroupPathName(path_group_name)) {
+    Slack slack = sta->endpointSlack(pin, std::string(path_group_name), min_max);
+    return sta->units()->timeUnit()->staToUser(slack);
+  }
+  else {
+    sta->report()->error(1577, "%s is not a known path group name.",
+			 path_group_name);
+    return INF;
+  }
+}
+
+StdStringSeq
+path_group_names()
+{
+  Sta *sta = Sta::sta();
+  return sta->pathGroupNames();
+}
+
 int
 tag_group_count()
 {