remove set_max_transition pin support

include/sta/Sdc.hh

@@ -295,15 +295,6 @@ public:
   void setSlewLimit(Port *port,
 		    const MinMax *min_max,
 		    float slew);
-  void slewLimit(const Pin *pin,
-		 const MinMax *min_max,
-		 // Return values.
-		 float &slew,
-		 bool &exists);
-  void setSlewLimit(const Pin *pin,
-		    const MinMax *min_max,
-		    float slew);
-  void slewLimitPins(ConstPinSeq &pins);
   void slewLimit(Cell *cell,
 		 const MinMax *min_max,
 		 float &slew,
@@ -1329,7 +1320,6 @@ protected:
   OutputDelaysPinMap output_delay_leaf_pin_map_;
 
   PortSlewLimitMap port_slew_limit_map_;
-  PinSlewLimitMap pin_slew_limit_map_;
   CellSlewLimitMap cell_slew_limit_map_;
   bool have_clk_slew_limits_;
   CellCapLimitMap cell_cap_limit_map_;

include/sta/Sta.hh

@@ -247,9 +247,6 @@ public:
   void setSlewLimit(Port *port,
 		    const MinMax *min_max,
 		    float slew);
-  void setSlewLimit(Pin *pin,
-		    const MinMax *min_max,
-		    float slew);
   void setSlewLimit(Cell *cell,
 		    const MinMax *min_max,
 		    float slew);

sdc/Sdc.cc

@@ -822,40 +822,6 @@ Sdc::setSlewLimit(Port *port,
   values.setValue(min_max, slew);
 }
 
-void
-Sdc::slewLimit(const Pin *pin,
-	       const MinMax *min_max,
-	       float &slew,
-	       bool &exists)
-{
-  slew = 0.0;
-  MinMaxFloatValues values;
-  pin_slew_limit_map_.findKey(pin, values, exists);
-  if (exists)
-    values.value(min_max, slew, exists);
-}
-
-void
-Sdc::setSlewLimit(const Pin *pin,
-		  const MinMax *min_max,
-		  float slew)
-{
-  MinMaxFloatValues &values = pin_slew_limit_map_[pin];
-  values.setValue(min_max, slew);
-}
-
-void
-Sdc::slewLimitPins(ConstPinSeq &pins)
-{
-  PinSlewLimitMap::Iterator iter(pin_slew_limit_map_);
-  while (iter.hasNext()) {
-    const Pin *pin;
-    MinMaxFloatValues values;
-    iter.next(pin, values);
-    pins.push_back(pin);
-  }
-}
-
 void
 Sdc::slewLimit(Cell *cell,
 	       const MinMax *min_max,

sdc/WriteSdc.cc

@@ -2239,24 +2239,6 @@ WriteSdc::writeSlewLimits() const
   }
   delete port_iter;
 
-  ConstPinSeq pins;
-  sdc_->slewLimitPins(pins);
-  sort(pins, PinPathNameLess(network_));
-  ConstPinSeq::Iterator pin_iter(pins);
-  while (pin_iter.hasNext()) {
-    const Pin *pin = pin_iter.next();
-    float slew;
-    bool exists;
-    sdc_->slewLimit(pin, min_max, slew, exists);
-    if (exists) {
-      fprintf(stream_, "set_max_transition ");
-      writeTime(slew);
-      fprintf(stream_, " ");
-      writeGetPin(pin, false);
-      fprintf(stream_, "\n");
-    }
-  }
-
   writeClkSlewLimits();
 }
 

search/CheckSlewLimits.cc

@@ -181,6 +181,10 @@ CheckSlewLimits::findLimit(const Pin *pin,
 {
   exists = false;
   if (!sta_->graphDelayCalc()->isIdealClk(vertex)) {
+    // Default to top ("design") limit.
+    exists = top_limit_exists_;
+    limit = top_limit_;
+
     const Network *network = sta_->network();
     Sdc *sdc = sta_->sdc();
     bool is_clk = sta_->search()->isClock(vertex);
@@ -203,10 +207,6 @@ CheckSlewLimits::findLimit(const Pin *pin,
 	exists = true;
       }
     }
-    if (!exists) {
-      // Default to top ("design") limit.
-      exists = top_limit_exists_;
-      limit = top_limit_;
     if (network->isTopLevelPort(pin)) {
       Port *port = network->port(pin);
       sdc->slewLimit(port, min_max, limit1, exists1);
@@ -219,8 +219,9 @@ CheckSlewLimits::findLimit(const Pin *pin,
       }
     }
     else {
-	sdc->slewLimit(pin, min_max,
+      LibertyPort *port = network->libertyPort(pin);
-		       limit1, exists1);
+      if (port) {
+	port->slewLimit(min_max, limit1, exists1);
 	// Use the tightest limit.
 	if (exists1
 	    && (!exists
@@ -228,18 +229,7 @@ CheckSlewLimits::findLimit(const Pin *pin,
 	  limit = limit1;
 	  exists = true;
 	}
-	LibertyPort *port = network->libertyPort(pin);
+	if (port->direction()->isAnyOutput()
-	if (port) {
-	  port->slewLimit(min_max, limit1, exists1);
-	  // Use the tightest limit.
-	  if (exists1) {
-	    if (!exists
-		|| min_max->compare(limit, limit1)) {
-	      limit = limit1;
-	      exists = true;
-	    }
-	  }
-	  else if (port->direction()->isAnyOutput()
 	    && min_max == MinMax::max()) {
 	  port->libertyLibrary()->defaultMaxSlew(limit1, exists1);
 	  if (exists1
@@ -253,7 +243,6 @@ CheckSlewLimits::findLimit(const Pin *pin,
     }
   }
 }
-}
 
 void
 CheckSlewLimits::clockDomains(const Vertex *vertex,

search/Sta.cc

@@ -998,14 +998,6 @@ Sta::setSlewLimit(Port *port,
   sdc_->setSlewLimit(port, min_max, slew);
 }
 
-void
-Sta::setSlewLimit(Pin *pin,
-		  const MinMax *min_max,
-		  float slew)
-{
-  sdc_->setSlewLimit(pin, min_max, slew);
-}
-
 void
 Sta::setSlewLimit(Cell *cell,
 		  const MinMax *min_max,

tcl/Sdc.tcl

@@ -2600,7 +2600,7 @@ proc set_max_transition { args } {
   set slew [time_ui_sta $slew]
   
   set objects [lindex $args 1]
-  parse_clk_cell_port_pin_args $objects clks cells ports pins
+  parse_clk_cell_port_args $objects clks cells ports
   
   set tr [parse_rise_fall_flags flags]
   
@@ -2617,12 +2617,12 @@ proc set_max_transition { args } {
     lappend path_types "data"
   }
   
-  if { ($ports != {} || $pins != {} || $cells != {}) \
+  if { ($ports != {} || $cells != {}) \
 	 && ([info exists flags(-clock_path)] \
 	       || [info exists flags(-data_path)]
 	     || [info exists flags(-rise)]
 	     || [info exists flags(-fall)]) } {
-    sta_warn "-data_path, -clock_path, -rise, -fall ignored for ports, pins and designs."
+    sta_warn "-data_path, -clock_path, -rise, -fall ignored for ports and designs."
   }
   
   # -clock_path/-data_path and transition only apply to clock objects.
@@ -2637,9 +2637,6 @@ proc set_max_transition { args } {
   foreach port $ports {
     set_slew_limit_port $port "max" $slew
   }
-  foreach pin $pins {
-    set_slew_limit_pin $pin "max" $slew
-  }
 }
 
 ################################################################

tcl/StaTcl.i

@@ -3516,15 +3516,6 @@ set_slew_limit_port(Port *port,
   Sta::sta()->setSlewLimit(port, min_max, slew);
 }
 
-void
-set_slew_limit_pin(Pin *pin,
-		   const MinMax *min_max,
-		   float slew)
-{
-  cmdLinkedNetwork();
-  Sta::sta()->setSlewLimit(pin, min_max, slew);
-}
-
 void
 set_slew_limit_cell(Cell *cell,
 		    const MinMax *min_max,