distrib/share/tcl/sdc1.4.tcl

   1 ################################################################################
   2 #                       >  COPYRIGHT NOTICE  <
   3 #
   4 #  Copyright 2003 (c) Synopsys.
   5 #
   6 #
   7 ################################################################################
   8 #
   9 # Title        : SDC-parser commands declaration for SDC version 1.4
  10 #
  11 # Project      : SDC-parser
  12 #
  13 # Authors      : Ibna Faruque, A.Gratchev,A.Sokhatski
  14 # Contributors : Specklin Benoit,Matthew Liberty
  15 # Updated      : Jan 7, 2003
  16 ################################################################################
  17
  18
  19  declare all_clocks {
  20  }
  21
  22  declare all_inputs {
  23   {-level_sensitive     Flag       }
  24   {-edge_triggered      Flag       }
  25   {-clock               List       }
  26  } {!(param(-level_sensitive) && param(-edge_triggered))}
  27
  28  declare all_outputs {
  29   {-level_sensitive     Flag       }
  30   {-edge_triggered      Flag       }
  31   {-clock               List       }
  32  } {!(param(-level_sensitive) && param(-edge_triggered))}
  33
  34  declare create_clock {
  35   {-period              Float      {$par>=0}}
  36   {-name                String     }
  37   {-waveform            List       {type_Float {length($length>=2 && ($length % 2)==0)} } }
  38   {port_pin_list        List       }
  39   {-add                 Flag       }
  40  } {param(-period) && (param(-name) || param(port_pin_list))}
  41
  42  declare create_generated_clock {
  43  {-name                String     }
  44  {-source              List       }
  45  {-edges               List  {type_Float {length($length>=2} }    }
  46  {-divide_by           Int   {1 && $par>=0}  }
  47  {-multiply_by         Int   {1 && $par>=0}  }
  48  {-edge_shift          List       }
  49  {-duty_cycle          Float {$par>=0 && $par <=100} }
  50  {-invert              Flag       }
  51  {port_pin_list        List       }
  52  {-add                 Flag       }
  53  {-master_clock        List       }
  54 } {param(-source) && param(port_pin_list) && !(param(-multiply_by) && param(-divide_by))}
  55
  56  declare current_design {
  57  }
  58
  59  declare current_instance {
  60   {-instance            String     }
  61  }
  62
  63  declare get_cells {
  64   {-of_objects          List       }
  65   {patterns             List       }
  66   {-hierarchical        Flag       }
  67   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
  68  } {(param(patterns) && !param(-of_objects)) || \
  69     (param(-of_objects) && !param(patterns))}
  70 # && !param(-hierarchical))}
  71
  72  declare get_clocks {
  73   {patterns             List       }
  74  } {param(patterns)}
  75
  76  declare get_lib_cells {
  77   {patterns             List       }
  78   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
  79  } {param(patterns)}
  80
  81  declare get_lib_pins {
  82   {patterns             List       }
  83   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
  84  } {param(patterns)}
  85
  86  declare get_libs {
  87   {patterns             List       }
  88  } {param(patterns)}
  89
  90  declare get_nets {
  91   {patterns             List       }
  92   {-hierarchical        Flag       }
  93   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
  94  } {param(patterns)}
  95
  96  declare get_pins {
  97   {patterns             List       }
  98   {-hierarchical        Flag       }
  99   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 100  } {param(patterns)}
 101
 102  declare get_ports {
 103   {patterns             List       }
 104  } {param(patterns)}
 105
 106  declare set_case_analysis {
 107   {value                Enum        {0 1 rising falling zero one rise fall}}
 108   {port_pin_list        List        }
 109  } {param(value) && param(port_pin_list)}
 110
 111  declare set_clock_gating_check {
 112   {-setup               Float       {$par>=0}}
 113   {-hold                Float       {$par>=0}}
 114   {-rise                Flag        }
 115   {-fall                Flag        }
 116   {-high                Flag        }
 117   {-low                 Flag        }
 118   {object_list          List        }
 119  } {(param(-setup) || param(-hold) || param(-high) || param(-low)) && \
 120    !(param(-high) && param(-low))}
 121
 122  declare set_clock_latency {
 123   {delay                Float       {1}}
 124   {object_list          List        }
 125   {-rise                Flag        }
 126   {-fall                Flag        }
 127   {-min                 Flag        }
 128   {-max                 Flag        }
 129   {-source              Flag        }
 130   {-early               Flag        }
 131   {-late                Flag        }
 132  } {param(delay) && param(object_list)}
 133
 134  declare set_clock_transition {
 135   {transition           Float       {1}}
 136   {clock_list           List        }
 137   {-rise                Flag        }
 138   {-fall                Flag        }
 139   {-min                 Flag        }
 140   {-max                 Flag        }
 141  } {param(transition) && param(clock_list) && \
 142    !(param(-rise) && param(-fall))}
 143
 144  declare set_clock_uncertainty {
 145   {uncertainty          Float       {1}}
 146   {-from                List        }
 147   {-to                  List        }
 148   {-rise                Flag        }
 149   {-fall                Flag        }
 150   {-setup               Flag        }
 151   {-hold                Flag        }
 152   {object_list          List        }
 153  } {param(uncertainty) && param(object_list) ^ (param(-from) && param(-to))}
 154
 155  declare set_disable_timing {
 156   {object_list          List        }
 157   {-from                String      }
 158   {-to                  String      }
 159  } {param(object_list) && \
 160    !(param(-to) ^ param(-from))}
 161
 162  declare set_drive {
 163   {resistance           Float       {$par>=0}}
 164   {port_list            List        }
 165   {-rise                Flag        }
 166   {-fall                Flag        }
 167   {-min                 Flag        }
 168   {-max                 Flag        }
 169  } {param(resistance) && param(port_list)}
 170
 171  declare set_driving_cell {
 172   {-lib_cell            String      }
 173   {-rise                Flag        }
 174   {-fall                Flag        }
 175   {-library             String      }
 176   {-pin                 String      }
 177   {-from_pin            String      }
 178   {-multiply_by         Float       {$par>=0}}
 179   {-dont_scale          Flag        }
 180   {-no_design_rule      Flag        }
 181   {-input_transition_rise   Float   {$par>=0}}
 182   {-input_transition_fall   Float   {$par>=0}}
 183   {port_list            List        }
 184   {-min                 Flag        }
 185   {-max                 Flag        }
 186   {-clock               List        }
 187   {-clock_fall          Flag        }
 188  } {param(port_list) &&  param(-lib_cell)}
 189
 190  declare set_false_path {
 191   {-setup               Flag        }
 192   {-hold                Flag        }
 193   {-rise                Flag        }
 194   {-fall                Flag        }
 195   {-from                List        }
 196   {-to                  List        }
 197   {-through             List        {dup}}
 198  } {(param(-from) || param(-to) || param(-through)) && \
 199  !(param(-rise) && param(-fall)) && !(param(-setup) && param(-hold))}
 200
 201  declare set_fanout_load {
 202   {value                Float       {$par>=0}}
 203   {port_list            List        }
 204  } {param(value) && param(port_list)}
 205
 206  declare set_hierarchy_separator {
 207   {hchar                Enum        {{/} {@} {^} {#} {.} {|}}}
 208  } {param(hchar)}
 209
 210  declare set_input_delay {
 211   {-clock               List        }
 212   {-clock_fall          Flag        }
 213   {-level_sensitive     Flag        }
 214   {-rise                Flag        }
 215   {-fall                Flag        }
 216   {-min                 Flag        }
 217   {-max                 Flag        }
 218   {-add_delay           Flag        }
 219   {delay_value          Float       {1}}
 220   {port_pin_list        List        }
 221   {-network_latency_included     Flag  }
 222   {-source_latency_included      Flag  }
 223  } {param(delay_value) && param(port_pin_list) && \
 224  !((param(-clock_fall) || param(-level_sensitive)) && !param(-clock))}
 225
 226  declare set_input_transition {
 227   {-rise                Flag        }
 228   {-fall                Flag        }
 229   {-min                 Flag        }
 230   {-max                 Flag        }
 231   {transition           Float       {$par>=0}}
 232   {port_list            List        }
 233   {-clock               List        }
 234   {-clock_fall          Flag        }
 235  } {param(transition) && param(port_list)}
 236
 237  declare set_load {
 238   {-min                 Flag        }
 239   {-max                 Flag        }
 240   {-substract_pin_load  Flag        }
 241   {-pin_load            Flag        }
 242   {-wire_load           Flag        }
 243   {value                Float       {$par>=0}}
 244   {objects              List        }
 245  } {param(value) && param(objects)}
 246
 247  declare set_logic_dc {
 248   {port_list            List        }
 249  } {param(port_list)}
 250
 251  declare set_logic_one {
 252   {port_list            List        }
 253  } {param(port_list)}
 254
 255  declare set_logic_zero {
 256   {port_list            List        }
 257  } {param(port_list)}
 258
 259  declare set_max_area {
 260   {area_value           Float       {$par>=0}}
 261  } {param(area_value)}
 262
 263  declare set_max_capacitance {
 264   {capacitance_value    Float       {$par>=0}}
 265   {object_list          List        }
 266  } {param(capacitance_value) && param(object_list)}
 267
 268  declare set_max_delay {
 269   {delay_value          Float       {1}}
 270   {-rise                Flag        }
 271   {-fall                Flag        }
 272   {-from                List        }
 273   {-to                  List        }
 274   {-through             List        {dup}}
 275  } {param(delay_value) && \
 276  !(param(-rise) && param(-fall))}
 277
 278  declare set_max_fanout {
 279   {fanout_value         Float       {$par>=0}}
 280   {object_list          List        }
 281  } {param(fanout_value) && param(object_list)}
 282
 283  declare set_max_time_borrow {
 284   {delay_value          Float       {$par>=0}}
 285   {object_list          List        }
 286  } {param(delay_value) && param(object_list)}
 287
 288  declare set_max_transition {
 289   {transition_value     Float       {$par>=0}}
 290   {object_list          List        }
 291  } {param(transition_value) && param(object_list)}
 292
 293  declare set_min_capacitance {
 294   {capacitance_value    Float       {$par>=0}}
 295   {object_list          List        }
 296  } {param(capacitance_value) && param(object_list)}
 297
 298  declare set_min_delay {
 299   {delay_value          Float       {1}}
 300   {-rise                Flag        }
 301   {-fall                Flag        }
 302   {-from                List        }
 303   {-to                  List        }
 304   {-through             List        {dup}}
 305  } {param(delay_value) && \
 306   !(param(-rise) && param(-fall))}
 307
 308  declare set_multicycle_path {
 309   {path_multiplier      Int         {1}}
 310   {-setup               Flag        }
 311   {-hold                Flag        }
 312   {-rise                Flag        }
 313   {-fall                Flag        }
 314   {-start               Flag        }
 315   {-end                 Flag        }
 316   {-from                List        }
 317   {-to                  List        }
 318   {-through             List        {dup}}
 319  } {param(path_multiplier)}
 320
 321  declare set_operating_conditions {
 322   {-analysis_type       Enum        {single bc_wc on_chip_variation}}
 323   {-library             List        }
 324   {-max                 String      }
 325   {-min                 String      }
 326   {-max_library         List        }
 327   {-min_library         List        }
 328   {condition            String      }
 329  }
 330
 331  declare set_output_delay {
 332   {-clock               List        }
 333   {-clock_fall          Flag        }
 334   {-level_sensitive     Flag        }
 335   {-rise                Flag        }
 336   {-fall                Flag        }
 337   {-min                 Flag        }
 338   {-max                 Flag        }
 339   {-add_delay           Flag        }
 340   {delay_value          Float       {1}}
 341   {port_pin_list        List        }
 342   {-network_latency_included     Flag  }
 343   {-source_latency_included      Flag  }
 344
 345  } {param(delay_value) && param(port_pin_list) && \
 346  !((param(-clock_fall) || param(-level_sensitive)) && !param(-clock))}
 347
 348  declare set_port_fanout_number {
 349   {fanout_number        Int         {($par>=0) && ($par<=100000)}}
 350   {port_list            List        }
 351  } {param(fanout_number) && param(port_list)}
 352
 353  declare set_propagated_clock {
 354   {object_list          List        }
 355  } {param(object_list)}
 356
 357  declare set_resistance {
 358   {value                Float       {$par>=0}}
 359   {net_list             List        }
 360   {-min                 Flag        }
 361   {-max                 Flag        }
 362  } {param(value) && param(net_list)}
 363
 364  declare set_wire_load_min_block_size {
 365   {size                 Float       {$par>=0}}
 366  } {param(size)}
 367
 368  declare set_wire_load_mode {
 369   {mode_name            Enum        {top enclosed segmented}}
 370  } {param(mode_name)}
 371
 372  declare set_wire_load_model {
 373   {-name                String      }
 374   {-library             List        }
 375   {-min                 Flag        }
 376   {-max                 Flag        }
 377   {object_list          List        }
 378  } {param(-name)}
 379
 380  declare set_wire_load_selection_group {
 381   {group_name          String      }
 382   {-library             List        }
 383   {-min                 Flag        }
 384   {-max                 Flag        }
 385   {object_list          List        }
 386  } {param(group_name)}
 387
 388  declare set_data_check {
 389   {-from                List        }
 390   {-rise_from           List        }
 391   {-fall_from           List        }
 392   {-to                  List        }
 393   {-rise_to             List        }
 394   {-fall_to             List        }
 395   {-rise                Flag        }
 396   {-fall                Flag        }
 397   {-setup               Flag        }
 398   {-hold                Flag        }
 399   {-clock               List        }
 400   {value                Float  {$par>=0}      }
 401  } {(param(-rise_from) || param(-from) || param(-fall_from)) && \
 402    ((param(-to) || param(-rise_to)) || param(-fall_to)) }
 403
 404  declare set_max_dynamic_power {
 405   {power_value           Float {$par>=0}       }
 406   {-unit                 Enum  {GW MW KW W mW uW nW pW fW aW} }
 407  } {param(power_value)}
 408
 409  declare set_max_leakage_power {
 410   {power_value         Float        {$par>=0}}
 411   {-unit               Enum         {GW MW KW W mW uW nW pW fW aW}}
 412  } {param(power_value)}
 413
 414  declare set_min_porosity {
 415  {porosity_value       Float        {$par>=0 && $par <=90}}
 416  {object_list          List          }
 417  } {param(porosity_value) && param(object_list)}
 418
 419
 420
 421 # register_new_type EdgeList {
 422 #    if {[sdc::check_type List $value]} {
 423 #        if {[expr {[llength $value] % 2}] || [llength $value]==0} {
 424 #            return 0
 425 #        }
 426 #
 427 #        set startvalue -0.1
 428 #
 429 #        foreach parv $value {
 430 #            if {[catch {expr {$parv + 1}}]} {
 431 #                return 0
 432 #            }
 433 #            if {$parv<=$startvalue} {
 434 #                return 0
 435 #            }
 436 #            set startvalue $parv
 437 #        }
 438 #
 439 #        return 1
 440 #    } else {
 441 #        return 0
 442 #    }
 443 # }