feat(iSTA): support generated clocks and common SDC constraints

src/database/manager/parser/liberty/Lib.hh

@@ -606,6 +606,8 @@ class LibPort : public LibObject
 
   void set_fanout_load(double fanout_load_val) { _fanout_load = fanout_load_val; }
   auto& get_fanout_load() { return _fanout_load; }
+  void set_max_fanout(double max_fanout) { _max_fanout = max_fanout; }
+  auto& get_max_fanout() { return _max_fanout; }
 
   double driveResistance();
 
@@ -635,6 +637,7 @@ class LibPort : public LibObject
   std::array<std::optional<double>, MODE_SPLIT> _slew_limits{};
 
   std::optional<double> _fanout_load;
+  std::optional<double> _max_fanout;
 
   absl::InlinedVector<std::unique_ptr<LibInternalPowerInfo>, 64> _internal_powers;  //!< The internal power information.
 

src/database/manager/parser/liberty/LibParserCpp.cc

@@ -379,6 +379,10 @@ unsigned LibertyReader::visitSimpleAttri(LibertySimpleAttrStmt* attri) {
     const char* default_wire_load = attri_value_handle->value;
     current_lib->set_default_wire_load(default_wire_load);
     liberty_free_string_value(attri_value_handle);
+  } else if (is_attri("max_fanout")) {
+    auto* attri_value_handle = liberty_convert_float_value(attri_value);
+    lib_port->set_max_fanout(attri_value_handle->value);
+    liberty_free_float_value(attri_value_handle);
   } else if (is_attri("fanout_load")) {
     auto* attri_value_handle = liberty_convert_float_value(attri_value);
     double fanout_load_val = attri_value_handle->value;

src/operation/iSTA/interface/STAInterface.cpp

@@ -91,6 +91,10 @@ void STAInterface::initSTA(std::map<std::string, std::any> config_map)
   STADM.input(config_map);
   DelayCalculator::initInst();
   SdcCommand::initInst({
+      {"current_design", sdc::executeTclCommand<sdc::TclCurrentDesign>},
+      {"remove_from_collection", sdc::executeTclCommand<sdc::TclRemoveFromCollection>},
+      {"set_clock_transition", sdc::executeTclCommand<sdc::TclSetClockTransition>},
+      {"set_max_fanout", sdc::executeTclCommand<sdc::TclSetMaxFanout>},
       {"set_case_analysis", sdc::executeTclCommand<sdc::TclSetCaseAnalysis>},
       {"set_input_delay", sdc::executeTclCommand<sdc::TclSetInputDelay>},
       {"set_output_delay", sdc::executeTclCommand<sdc::TclSetOutputDelay>},
@@ -102,6 +106,12 @@ void STAInterface::initSTA(std::map<std::string, std::any> config_map)
       {"get_port", sdc::executeTclCommand<sdc::TclGetPorts>},
       {"get_ports", sdc::executeTclCommand<sdc::TclGetPorts>},
       {"create_clock", sdc::executeTclCommand<sdc::TclCreateClock>},
+      {"create_generated_clock", sdc::executeTclCommand<sdc::TclCreateGeneratedClock>},
+      {"set_clock_groups", sdc::executeTclCommand<sdc::TclSetClockGroups>},
+      {"set_false_path", sdc::executeTclCommand<sdc::TclSetFalsePath>},
+      {"get_pins", sdc::executeTclCommand<sdc::TclGetPins>},
+      {"all_inputs", sdc::executeTclCommand<sdc::TclAllInputs>},
+      {"all_outputs", sdc::executeTclCommand<sdc::TclAllOutputs>},
       {"set_propagated_clock", sdc::executeTclCommand<sdc::TclSetPropagatedClock>},
   });
   STADM.readConstraint();
@@ -698,6 +708,9 @@ void STAInterface::wrapTimingCellPort(TimingCell& timing_cell, idb::LibPort* lib
   timing_cell_port.set_port_name(lib_port->get_port_name());
   timing_cell_port.set_capacitance(lib_port->get_port_cap());
   timing_cell_port.set_drive_resistance(lib_port->driveResistance());
+  idb::LibLibrary* library = lib_port->get_ower_cell()->get_owner_lib();
+  timing_cell_port.set_fanout_load(lib_port->get_fanout_load().value_or(library->get_default_fanout_load().value_or(0.0)));
+  timing_cell_port.set_max_fanout(lib_port->get_max_fanout() ? lib_port->get_max_fanout() : library->get_default_max_fanout());
   for (idb::AnalysisMode analysis_mode : {idb::AnalysisMode::kMax, idb::AnalysisMode::kMin}) {
     for (idb::TransType trans_type : {idb::TransType::kRise, idb::TransType::kFall}) {
       std::optional<double> port_cap = lib_port->get_port_cap(analysis_mode, trans_type);

src/operation/iSTA/source/data_manager/DataManager.cpp

@@ -309,6 +309,10 @@ void DataManager::readConstraint()
   database.get_timing_constraint().get_clock_map().clear();
   database.get_timing_constraint().get_port_constraint_map().clear();
   database.get_timing_constraint().get_case_analysis_map().clear();
+  database.get_timing_constraint().get_false_path_list().clear();
+  database.get_timing_constraint().get_clock_group_list().clear();
+  database.get_timing_constraint().get_max_fanout().reset();
+  database.get_timing_constraint().get_port_max_fanout_map().clear();
   if (sdc_file_path.empty()) {
     return;
   }
@@ -318,6 +322,7 @@ void DataManager::readConstraint()
     for (const SdcError& error : sdc_command.getErrors()) {
       STALOG.warn(Loc::current(), "SDC command failed in '", sdc_file_path, "' at line ", error.line_number, ": ", error.message);
     }
+    STALOG.error(Loc::current(), "SDC contains invalid or unsupported constraints; timing analysis stopped");
   }
 }
 

src/operation/iSTA/source/data_manager/advance/Database.hpp

@@ -27,6 +27,7 @@
 #include "STAHeader.hpp"
 #include "Summary.hpp"
 #include "TimingConstraint.hpp"
+#include "TimingFanoutCheck.hpp"
 #include "TimingLibrary.hpp"
 #include "TimingPathGroup.hpp"
 #include "TimingPoint.hpp"
@@ -59,6 +60,7 @@ class Database
   ParasiticLibrary& get_parasitic_library() { return _parasitic_library; }
   TimingConstraint& get_timing_constraint() { return _timing_constraint; }
   Summary& get_summary() { return _summary; }
+  std::vector<TimingFanoutCheck>& get_fanout_check_list() { return _fanout_check_list; }
   // setter
   void set_design_name(const std::string& design_name) { _design_name = design_name; }
   // function
@@ -76,6 +78,7 @@ class Database
   std::vector<std::string> _timing_order_list;
   std::map<std::string, TimingPoint> _timing_point_map;
   std::vector<TimingPathGroup> _timing_path_group_list;
+  std::vector<TimingFanoutCheck> _fanout_check_list;
   std::map<std::string, PowerActivity> _vcd_activity_map;
   std::map<std::string, PowerActivity> _power_activity_map;
   std::map<std::string, InstancePower> _instance_power_map;

src/operation/iSTA/source/data_manager/advance/TimingCellPort.hpp

@@ -37,6 +37,8 @@ class TimingCellPort
   bool get_is_input() const { return _is_input; }
   bool get_is_output() const { return _is_output; }
   bool get_is_clock() const { return _is_clock; }
+  double get_fanout_load() const { return _fanout_load; }
+  std::optional<double>& get_max_fanout() { return _max_fanout; }
   // setter
   void set_port_name(const std::string& port_name) { _port_name = port_name; }
   void set_capacitance(const double capacitance) { _capacitance = capacitance; }
@@ -49,6 +51,8 @@ class TimingCellPort
   void set_is_input(const bool is_input) { _is_input = is_input; }
   void set_is_output(const bool is_output) { _is_output = is_output; }
   void set_is_clock(const bool is_clock) { _is_clock = is_clock; }
+  void set_fanout_load(double fanout_load) { _fanout_load = fanout_load; }
+  void set_max_fanout(const std::optional<double>& max_fanout) { _max_fanout = max_fanout; }
   // function
 
  private:
@@ -60,6 +64,8 @@ class TimingCellPort
   bool _is_input = false;
   bool _is_output = false;
   bool _is_clock = false;
+  double _fanout_load = 0.0;
+  std::optional<double> _max_fanout;
 };
 
 }  // namespace ista

src/operation/iSTA/source/data_manager/advance/TimingClock.hpp

@@ -16,7 +16,9 @@
 // ***************************************************************************************
 #pragma once
 
+#include "AnalysisType.hpp"
 #include "STAHeader.hpp"
+#include "TransType.hpp"
 
 namespace ista {
 
@@ -34,6 +36,10 @@ class TimingClock
   double get_setup_uncertainty() const { return _setup_uncertainty; }
   double get_hold_uncertainty() const { return _hold_uncertainty; }
   bool get_is_propagated() const { return _is_propagated; }
+  const std::string& get_master_clock_name() const { return _master_clock_name; }
+  const std::string& get_master_source() const { return _master_source; }
+  bool get_is_generated() const { return !_master_clock_name.empty(); }
+  std::map<AnalysisType, std::map<TransType, double>>& get_transition_map() { return _transition_map; }
   // setter
   void set_clock_name(const std::string& clock_name) { _clock_name = clock_name; }
   void set_source_list(const std::vector<std::string>& source_list) { _source_list = source_list; }
@@ -43,9 +49,13 @@ class TimingClock
   void set_setup_uncertainty(const double uncertainty) { _setup_uncertainty = uncertainty; }
   void set_hold_uncertainty(const double uncertainty) { _hold_uncertainty = uncertainty; }
   void set_is_propagated(const bool is_propagated) { _is_propagated = is_propagated; }
+  void set_master_clock_name(const std::string& name) { _master_clock_name = name; }
+  void set_master_source(const std::string& source) { _master_source = source; }
   // function
 
  private:
+  std::string _master_clock_name;
+  std::string _master_source;
   std::string _clock_name;
   std::vector<std::string> _source_list;
   double _period = 0.0;
@@ -54,6 +64,7 @@ class TimingClock
   double _setup_uncertainty = 0.0;
   double _hold_uncertainty = 0.0;
   bool _is_propagated = false;
+  std::map<AnalysisType, std::map<TransType, double>> _transition_map;
 };
 
 }  // namespace ista

src/operation/iSTA/source/data_manager/advance/TimingConstraint.hpp

@@ -18,6 +18,7 @@
 
 #include "STAHeader.hpp"
 #include "TimingClock.hpp"
+#include "TimingException.hpp"
 #include "TimingPortConstraint.hpp"
 
 namespace ista {
@@ -32,6 +33,10 @@ class TimingConstraint
   std::map<std::string, TimingClock>& get_clock_map() { return _clock_map; }
   std::map<std::string, TimingPortConstraint>& get_port_constraint_map() { return _port_constraint_map; }
   std::map<std::string, bool>& get_case_analysis_map() { return _case_analysis_map; }
+  std::vector<TimingException>& get_false_path_list() { return _false_path_list; }
+  std::vector<TimingClockGroup>& get_clock_group_list() { return _clock_group_list; }
+  std::optional<double>& get_max_fanout() { return _max_fanout; }
+  std::map<std::string, double>& get_port_max_fanout_map() { return _port_max_fanout_map; }
   // setter
   void set_sdc_file_path(const std::string& sdc_file_path) { _sdc_file_path = sdc_file_path; }
   void set_clock_map(const std::map<std::string, TimingClock>& clock_map) { _clock_map = clock_map; }
@@ -40,10 +45,14 @@ class TimingConstraint
   // function
 
  private:
+  std::vector<TimingException> _false_path_list;
+  std::vector<TimingClockGroup> _clock_group_list;
   std::string _sdc_file_path;
   std::map<std::string, TimingClock> _clock_map;
   std::map<std::string, TimingPortConstraint> _port_constraint_map;
   std::map<std::string, bool> _case_analysis_map;
+  std::optional<double> _max_fanout;
+  std::map<std::string, double> _port_max_fanout_map;
 };
 
 }  // namespace ista

src/operation/iSTA/source/data_manager/advance/TimingException.hpp

@@ -0,0 +1,65 @@
+// ***************************************************************************************
+// Copyright (c) 2023-2025 Peng Cheng Laboratory
+// Copyright (c) 2023-2025 Institute of Computing Technology, Chinese Academy of Sciences
+// Copyright (c) 2023-2025 Beijing Institute of Open Source Chip
+//
+// iEDA is licensed under Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+// http://license.coscl.org.cn/MulanPSL2
+//
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+// MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+//
+// See the Mulan PSL v2 for more details.
+// ***************************************************************************************
+#pragma once
+
+#include "STAHeader.hpp"
+
+namespace ista {
+
+class TimingException
+{
+ public:
+  TimingException() = default;
+  ~TimingException() = default;
+  // getter
+  const std::set<std::string>& get_from_objects() const { return _from_objects; }
+  const std::set<std::string>& get_to_objects() const { return _to_objects; }
+  bool get_setup() const { return _setup; }
+  bool get_hold() const { return _hold; }
+  // setter
+  void set_from_objects(const std::set<std::string>& objects) { _from_objects = objects; }
+  void set_to_objects(const std::set<std::string>& objects) { _to_objects = objects; }
+  void set_setup(bool value) { _setup = value; }
+  void set_hold(bool value) { _hold = value; }
+  // function
+
+ private:
+  std::set<std::string> _from_objects;
+  std::set<std::string> _to_objects;
+  bool _setup = true;
+  bool _hold = true;
+};
+
+class TimingClockGroup
+{
+ public:
+  TimingClockGroup() = default;
+  ~TimingClockGroup() = default;
+  // getter
+  const std::vector<std::set<std::string>>& get_groups() const { return _groups; }
+  bool get_allow_paths() const { return _allow_paths; }
+  // setter
+  void set_groups(const std::vector<std::set<std::string>>& groups) { _groups = groups; }
+  void set_allow_paths(bool value) { _allow_paths = value; }
+  // function
+
+ private:
+  std::vector<std::set<std::string>> _groups;
+  bool _allow_paths = false;
+};
+
+}  // namespace ista

src/operation/iSTA/source/data_manager/advance/TimingFanoutCheck.hpp

@@ -0,0 +1,48 @@
+// ***************************************************************************************
+// Copyright (c) 2023-2025 Peng Cheng Laboratory
+// Copyright (c) 2023-2025 Institute of Computing Technology, Chinese Academy of Sciences
+// Copyright (c) 2023-2025 Beijing Institute of Open Source Chip
+//
+// iEDA is licensed under Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan PSL v2.
+// You may obtain a copy of Mulan PSL v2 at:
+// http://license.coscl.org.cn/MulanPSL2
+//
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+// MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+//
+// See the Mulan PSL v2 for more details.
+// ***************************************************************************************
+#pragma once
+
+#include "STAHeader.hpp"
+
+namespace ista {
+
+class TimingFanoutCheck
+{
+ public:
+  TimingFanoutCheck() = default;
+  ~TimingFanoutCheck() = default;
+  // getter
+  const std::string& get_net_name() const { return _net_name; }
+  const std::string& get_driver_pin() const { return _driver_pin; }
+  double get_fanout_load() const { return _fanout_load; }
+  double get_limit() const { return _limit; }
+  double get_slack() const { return _limit - _fanout_load; }
+  // setter
+  void set_net_name(const std::string& net_name) { _net_name = net_name; }
+  void set_driver_pin(const std::string& driver_pin) { _driver_pin = driver_pin; }
+  void set_fanout_load(double fanout_load) { _fanout_load = fanout_load; }
+  void set_limit(double limit) { _limit = limit; }
+  // function
+
+ private:
+  std::string _net_name;
+  std::string _driver_pin;
+  double _fanout_load = 0.0;
+  double _limit = 0.0;
+};
+
+}  // namespace ista

src/operation/iSTA/source/data_manager/advance/TimingPath.hpp

@@ -51,6 +51,8 @@ class TimingPath
   TimingCheckType get_check_type() const { return _check_type; }
   TransType get_trans_type() const { return _trans_type; }
   std::string& get_clock_name() { return _clock_name; }
+  std::string& get_capture_clock_name() { return _capture_clock_name; }
+  TransType get_capture_clock_transition() const { return _capture_clock_transition; }
   std::string& get_capture_clock_pin() { return _capture_clock_pin; }
   std::string& get_last_common_pin() { return _last_common_pin; }
   std::vector<TimingPathPoint>& get_point_list() { return _point_list; }
@@ -75,6 +77,8 @@ class TimingPath
   void set_check_type(const TimingCheckType& check_type) { _check_type = check_type; }
   void set_trans_type(const TransType& trans_type) { _trans_type = trans_type; }
   void set_clock_name(const std::string& clock_name) { _clock_name = clock_name; }
+  void set_capture_clock_name(const std::string_view name) { _capture_clock_name = name; }
+  void set_capture_clock_transition(TransType transition) { _capture_clock_transition = transition; }
   void set_capture_clock_pin(const std::string& capture_clock_pin) { _capture_clock_pin = capture_clock_pin; }
   void set_last_common_pin(const std::string& last_common_pin) { _last_common_pin = last_common_pin; }
   void set_point_list(const std::vector<TimingPathPoint>& point_list) { _point_list = point_list; }
@@ -101,6 +105,8 @@ class TimingPath
   TimingCheckType _check_type = TimingCheckType::kNone;
   TransType _trans_type = TransType::kNone;
   std::string _clock_name;
+  std::string _capture_clock_name;
+  TransType _capture_clock_transition = TransType::kRise;
   std::string _capture_clock_pin;
   std::string _last_common_pin;
   std::vector<TimingPathPoint> _point_list;