distrib/share/tcl/sdc1.6.tcl

   1 ################################################################################
   2 #
   3 #  Copyright 2006 (c) Synopsys, Inc.
   4 #
   5 ################################################################################
   6 #
   7 # Title        : SDC-parser commands declaration for SDC version 1.5
   8 #
   9 #              : Ibna Faruque
  10 # Updated      : june 12, 2006
  11 # Bug Fixes    :
  12 ################################################################################
  13
  14  declare all_clocks {
  15  }
  16
  17  declare all_inputs {
  18   {-level_sensitive     Flag       }
  19   {-edge_triggered      Flag       }
  20   {-clock               List       }
  21  } {!(param(-level_sensitive) && param(-edge_triggered))}
  22
  23  declare all_outputs {
  24   {-level_sensitive     Flag       }
  25   {-edge_triggered      Flag       }
  26   {-clock               List       }
  27  } {!(param(-level_sensitive) && param(-edge_triggered))}
  28
  29  declare create_clock {
  30   {-period              Float      {$par>=0}}
  31   {-name                String     }
  32   {-waveform            List       {type_Float {length($length>=2 && ($length % 2)==0)} } }
  33   {port_pin_list        List       }
  34   {-add                 Flag       }
  35  } {param(-period) && (param(-name) || param(port_pin_list))}
  36
  37  declare create_generated_clock {
  38  {-name                String     }
  39  {-source              List       }
  40  {-edges               List  {type_Float {length($length>=2} }    }
  41  {-divide_by           Int   {1 && $par>=0}  }
  42  {-multiply_by         Int   {1 && $par>=0}  }
  43  {-edge_shift          List       }
  44  {-duty_cycle          Float {$par>=0 && $par <=100} }
  45  {-invert              Flag       }
  46  {port_pin_list        List       }
  47  {-add                 Flag       }
  48  {-master_clock        List       }
  49 } {param(-source) && param(port_pin_list) && !(param(-multiply_by) && param(-divide_by))}
  50
  51  declare current_design {
  52  }
  53
  54  declare current_instance {
  55   {-instance            String     }
  56  }
  57
  58  declare get_cells {
  59   {-of_objects          List       }
  60   {patterns             List       }
  61   {-hierarchical        Flag       }
  62   {-regexp             Flag       }
  63   {-nocase              Flag       }
  64   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
  65  # {                                }
  66  } {(param(patterns) && !param(-of_objects)) || \
  67     (param(-of_objects) && !param(patterns)) || !param(patterns)}
  68 # && !param(-hierarchical))}
  69
  70 # get_cell synonym for get_cells
  71  declare get_cell {
  72   {-of_objects          List       }
  73   {patterns             List       }
  74   {-hierarchical        Flag       }
  75   {-regexp             Flag       }
  76   {-nocase              Flag       }
  77   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
  78  # {                                }
  79  } {(param(patterns) && !param(-of_objects)) || \
  80     (param(-of_objects) && !param(patterns)) || !param(patterns)}
  81
  82
  83
  84  declare get_clocks {
  85   {patterns             List       }
  86   {-regexp             Flag       }
  87   {-nocase              Flag       }
  88  }
  89 #} {param(patterns)}
  90
  91  declare get_clock {
  92   {patterns             List       }
  93   {-regexp             Flag       }
  94   {-nocase              Flag       }
  95 }
  96
  97  declare get_lib_cells {
  98   {patterns             List       }
  99   {-regexp             Flag       }
 100   {-nocase              Flag       }
 101   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 102  } {param(patterns)}
 103
 104  declare get_lib_cell {
 105   {patterns             List       }
 106   {-regexp             Flag       }
 107   {-nocase              Flag       }
 108   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 109  } {param(patterns)}
 110
 111
 112  declare get_lib_pins {
 113   {patterns             List       }
 114   {-regexp             Flag       }
 115   {-nocase              Flag       }
 116   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 117  } {param(patterns)}
 118
 119  declare get_lib_pin {
 120   {patterns             List       }
 121   {-regexp             Flag       }
 122   {-nocase              Flag       }
 123   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 124  } {param(patterns)}
 125
 126
 127  declare get_libs {
 128   {-regexp             Flag       }
 129   {-nocase              Flag       }
 130   {patterns             List       }
 131 }
 132  #} {param(patterns)}
 133
 134  declare get_nets {
 135   {patterns             List       }
 136   {-of_objects          List       }
 137   {-hierarchical        Flag       }
 138   {-regexp             Flag       }
 139   {-nocase              Flag       }
 140   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 141 } {(param(patterns) && !param(-of_objects)) || \
 142     (param(-of_objects) && !param(patterns)) || !param(patterns)}
 143
 144
 145  declare get_net {
 146   {patterns             List       }
 147   {-of_objects          List       }
 148   {-hierarchical        Flag       }
 149   {-regexp             Flag       }
 150   {-nocase              Flag       }
 151   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 152 } {(param(patterns) && !param(-of_objects)) || \
 153     (param(-of_objects) && !param(patterns)) || !param(patterns)}
 154
 155
 156
 157  declare get_pins {
 158   {patterns             List       }
 159   {-hierarchical        Flag       }
 160   {-regexp             Flag       }
 161   {-nocase              Flag       }
 162   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 163  }
 164
 165  declare get_pin {
 166   {patterns             List       }
 167   {-hierarchical        Flag       }
 168   {-regexp             Flag       }
 169   {-nocase              Flag       }
 170   {-hsc                 Enum       {{/} {@} {^} {#} {.} {|}}}
 171  }
 172
 173  declare get_ports {
 174   {-hierarchical        Flag       }
 175   {-regexp             Flag       }
 176   {patterns             List       }
 177 }
 178 # } {param(patterns)}
 179
 180  declare get_port {
 181   {-hierarchical        Flag       }
 182   {-regexp             Flag       }
 183   {patterns             List       }
 184 }
 185 # } {param(patterns)}
 186
 187
 188  declare set_case_analysis {
 189   {value                Enum        {0 1 rising falling zero one rise fall}}
 190   {port_pin_list        List        }
 191  } {param(value) && param(port_pin_list)}
 192
 193  declare set_clock_gating_check {
 194   {-setup               Float       {$par>=0}}
 195   {-hold                Float       {$par>=0}}
 196   {-rise                Flag        }
 197   {-fall                Flag        }
 198   {-high                Flag        }
 199   {-low                 Flag        }
 200   {object_list          List        }
 201  } {(param(-setup) || param(-hold) || param(-high) || param(-low)) && \
 202    !(param(-high) && param(-low))}
 203
 204  declare set_clock_latency {
 205   {delay                Float       {1}}
 206   {object_list          List        }
 207   {-rise                Flag        }
 208   {-fall                Flag        }
 209   {-min                 Flag        }
 210   {-max                 Flag        }
 211   {-source              Flag        }
 212   {-early               Flag        }
 213   {-late                Flag        }
 214   {-clock               List        }
 215  } {param(delay) && param(object_list)}
 216
 217  declare set_clock_transition {
 218   {transition           Float       {1}}
 219   {clock_list           List        }
 220   {-rise                Flag        }
 221   {-fall                Flag        }
 222   {-min                 Flag        }
 223   {-max                 Flag        }
 224  } {param(transition) && param(clock_list) && \
 225    !(param(-rise) && param(-fall))}
 226
 227  declare set_clock_uncertainty {
 228   {uncertainty          Float       {1}}
 229   {-from                List        }
 230   {-to                  List        }
 231   {-rise_to             List        }
 232   {-fall_to             List        }
 233   {-rise_from           List        }
 234   {-fall_from           List        }
 235   {-rise                Flag        }
 236   {-fall                Flag        }
 237   {-setup               Flag        }
 238   {-hold                Flag        }
 239   {object_list          List        }
 240  } {param(uncertainty) && param(object_list) ^ \
 241    (((param(-from) ^ param(-rise_from) ^ param(-fall_from))) \
 242     && (param(-to) ^ param(-rise_to) ^ param(-fall_to)))}
 243
 244  declare set_disable_timing {
 245   {object_list          List        }
 246   {-from                String      }
 247   {-to                  String      }
 248  } {param(object_list) && \
 249    !(param(-to) ^ param(-from))}
 250
 251  declare set_drive {
 252   {resistance           Float       {$par>=0}}
 253   {port_list            List        }
 254   {-rise                Flag        }
 255   {-fall                Flag        }
 256   {-min                 Flag        }
 257   {-max                 Flag        }
 258  } {param(resistance) && param(port_list)}
 259
 260  declare set_driving_cell {
 261   {-lib_cell            String      }
 262   {-rise                Flag        }
 263   {-fall                Flag        }
 264   {-library             String      }
 265   {-pin                 String      }
 266   {-from_pin            String      }
 267   {-multiply_by         Float       {$par>=0}}
 268   {-dont_scale          Flag        }
 269   {-no_design_rule      Flag        }
 270   {-input_transition_rise   Float   {$par>=0}}
 271   {-input_transition_fall   Float   {$par>=0}}
 272   {port_list            List        }
 273   {-min                 Flag        }
 274   {-max                 Flag        }
 275   {-clock               List        }
 276   {-clock_fall          Flag        }
 277  } {param(port_list) &&  param(-lib_cell)}
 278
 279  declare set_false_path {
 280   {-setup               Flag        }
 281   {-hold                Flag        }
 282   {-rise                Flag        }
 283   {-fall                Flag        }
 284   {-from                List        }
 285   {-to                  List        }
 286   {-through             List        {dup}}
 287  } {(param(-from) || param(-to) || param(-through)) && \
 288  !(param(-rise) && param(-fall)) && !(param(-setup) && param(-hold))}
 289
 290  declare set_fanout_load {
 291   {value                Float       {$par>=0}}
 292   {port_list            List        }
 293  } {param(value) && param(port_list)}
 294
 295  declare set_hierarchy_separator {
 296   {hchar                Enum        {{/} {@} {^} {#} {.} {|}}}
 297  } {param(hchar)}
 298
 299  declare set_input_delay {
 300   {-clock               List        }
 301   {-clock_fall          Flag        }
 302   {-level_sensitive     Flag        }
 303   {-rise                Flag        }
 304   {-fall                Flag        }
 305   {-min                 Flag        }
 306   {-max                 Flag        }
 307   {-add_delay           Flag        }
 308   {delay_value          Float       {1}}
 309   {port_pin_list        List        }
 310   {-network_latency_included     Flag  }
 311   {-source_latency_included      Flag  }
 312  } {param(delay_value) && param(port_pin_list) && \
 313  !((param(-clock_fall) || param(-level_sensitive)) && !param(-clock))}
 314
 315  declare set_input_transition {
 316   {-rise                Flag        }
 317   {-fall                Flag        }
 318   {-min                 Flag        }
 319   {-max                 Flag        }
 320   {transition           Float       {$par>=0}}
 321   {port_list            List        }
 322   {-clock               List        }
 323   {-clock_fall          Flag        }
 324  } {param(transition) && param(port_list)}
 325
 326  declare set_load {
 327   {-min                 Flag        }
 328   {-max                 Flag        }
 329   {-substract_pin_load  Flag        }
 330   {-pin_load            Flag        }
 331   {-wire_load           Flag        }
 332   {value                Float       {$par>=0}}
 333   {objects              List        }
 334  } {param(value) && param(objects)}
 335
 336  declare set_logic_dc {
 337   {port_list            List        }
 338  } {param(port_list)}
 339
 340  declare set_logic_one {
 341   {port_list            List        }
 342  } {param(port_list)}
 343
 344  declare set_logic_zero {
 345   {port_list            List        }
 346  } {param(port_list)}
 347
 348  declare set_max_area {
 349   {area_value           Float       {$par>=0}}
 350  } {param(area_value)}
 351
 352  declare set_max_capacitance {
 353   {capacitance_value    Float       {$par>=0}}
 354   {object_list          List        }
 355  } {param(capacitance_value) && param(object_list)}
 356
 357  declare set_max_delay {
 358   {delay_value          Float       {1}}
 359   {-rise                Flag        }
 360   {-fall                Flag        }
 361   {-from                List        }
 362   {-to                  List        }
 363   {-through             List        {dup}}
 364  } {param(delay_value) && \
 365  !(param(-rise) && param(-fall))}
 366
 367  declare set_max_fanout {
 368   {fanout_value         Float       {$par>=0}}
 369   {object_list          List        }
 370  } {param(fanout_value) && param(object_list)}
 371
 372  declare set_max_time_borrow {
 373   {delay_value          Float       {$par>=0}}
 374   {object_list          List        }
 375  } {param(delay_value) && param(object_list)}
 376
 377  declare set_max_transition {
 378   {transition_value     Float       {$par>=0}}
 379   {-clock_path          Flag  }
 380   {-fall                Flag }
 381   {-rise                Flag}
 382   {object_list          List        }
 383  } {param(transition_value) && param(object_list)}
 384
 385  declare set_min_capacitance {
 386   {capacitance_value    Float       {$par>=0}}
 387   {object_list          List        }
 388  } {param(capacitance_value) && param(object_list)}
 389
 390  declare set_min_delay {
 391   {delay_value          Float       {1}}
 392   {-rise                Flag        }
 393   {-fall                Flag        }
 394   {-from                List        }
 395   {-to                  List        }
 396   {-through             List        {dup}}
 397  } {param(delay_value) && \
 398   !(param(-rise) && param(-fall))}
 399
 400  declare set_multicycle_path {
 401   {path_multiplier      Int         {1}}
 402   {-setup               Flag        }
 403   {-hold                Flag        }
 404   {-rise                Flag        }
 405   {-fall                Flag        }
 406   {-start               Flag        }
 407   {-end                 Flag        }
 408   {-from                List        }
 409   {-to                  List        }
 410   {-through             List        {dup}}
 411  } {param(path_multiplier)}
 412
 413  declare set_operating_conditions {
 414   {-analysis_type       Enum        {single bc_wc on_chip_variation}}
 415   {-library             List        }
 416   {-max                 String      }
 417   {-min                 String      }
 418   {-max_library         List        }
 419   {-object_list         List        }
 420   {-min_library         List        }
 421   {condition            String      }
 422  }
 423
 424  declare set_output_delay {
 425   {-clock               List        }
 426   {-clock_fall          Flag        }
 427   {-level_sensitive     Flag        }
 428   {-rise                Flag        }
 429   {-fall                Flag        }
 430   {-min                 Flag        }
 431   {-max                 Flag        }
 432   {-add_delay           Flag        }
 433   {delay_value          Float       {1}}
 434   {port_pin_list        List        }
 435   {-network_latency_included     Flag  }
 436   {-source_latency_included      Flag  }
 437
 438  } {param(delay_value) && param(port_pin_list) && \
 439  !((param(-clock_fall) || param(-level_sensitive)) && !param(-clock))}
 440
 441  declare set_port_fanout_number {
 442   {fanout_number        Int         {($par>=0) && ($par<=100000)}}
 443   {port_list            List        }
 444  } {param(fanout_number) && param(port_list)}
 445
 446  declare set_propagated_clock {
 447   {object_list          List        }
 448  } {param(object_list)}
 449
 450  declare set_resistance {
 451   {value                Float       {$par>=0}}
 452   {net_list             List        }
 453   {-min                 Flag        }
 454   {-max                 Flag        }
 455  } {param(value) && param(net_list)}
 456
 457  declare set_wire_load_min_block_size {
 458   {size                 Float       {$par>=0}}
 459  } {param(size)}
 460
 461  declare set_wire_load_mode {
 462   {mode_name            Enum        {top enclosed segmented}}
 463  } {param(mode_name)}
 464
 465  declare set_wire_load_model {
 466   {-name                String      }
 467   {-library             List        }
 468   {-min                 Flag        }
 469   {-max                 Flag        }
 470   {object_list          List        }
 471  } {param(-name)}
 472
 473  declare set_wire_load_selection_group {
 474   {group_name          String      }
 475   {-library             List        }
 476   {-min                 Flag        }
 477   {-max                 Flag        }
 478   {object_list          List        }
 479  } {param(group_name)}
 480
 481  declare set_data_check {
 482   {-from                List        }
 483   {-rise_from           List        }
 484   {-fall_from           List        }
 485   {-to                  List        }
 486   {-rise_to             List        }
 487   {-fall_to             List        }
 488   {-rise                Flag        }
 489   {-fall                Flag        }
 490   {-setup               Flag        }
 491   {-hold                Flag        }
 492   {-clock               List        }
 493   {value                Float  {$par>=0}      }
 494  } {(param(-rise_from) || param(-from) || param(-fall_from)) && \
 495    ((param(-to) || param(-rise_to)) || param(-fall_to)) }
 496
 497  declare set_timing_derate {
 498   {derate_value        Float  {$par>=0.1  } }
 499   {object_list          List      }
 500 # {derate_value         Float {$par>=0.1 && $par<=2.0}}
 501   {-min                 Flag      }
 502   {-max                 Flag      }
 503   {-early               Flag      }
 504   {-late                Flag      }
 505   {-clock               Flag      }
 506   {-data                Flag      }
 507   {-net_delay           Flag      }
 508   {-cell_delay          Flag      }
 509   {-cell_check          Flag      }
 510 } {param(derate_value) && (param(-early) && !param(-late)) || (param(-late) && !param(-early))}
 511
 512
 513
 514  declare set_max_dynamic_power {
 515   {power_value           Float {$par>=0}       }
 516   {-unit                 Enum  {GW MW KW W mW uW nW pW fW aW} }
 517  } {param(power_value)}
 518
 519  declare set_max_leakage_power {
 520   {power_value         Float        {$par>=0}}
 521   {-unit               Enum         {GW MW KW W mW uW nW pW fW aW}}
 522  } {param(power_value)}
 523
 524 declare create_voltage_area {
 525   {-name                String {1}    }
 526   {-coordinate          List       }
 527   {-guard_band_x        List       }
 528   {-guard_band_y        List       }
 529   {cell_list            List {1}      }
 530  } {param(-name) && {param(cell_list)}}
 531
 532 declare set_level_shifter_strategy {
 533   {-rule               Enum         {all low_to_high high_to_low}}
 534  } {param(-rule)}
 535
 536 declare set_level_shifter_threshold {
 537   {-voltage            Float  {1}      }
 538   {-percent            Float   {1}  }
 539  } {param(-voltage)}
 540
 541
 542
 543  declare set_min_porosity {
 544  {porosity_value       Float        {$par>=0 && $par <=90}}
 545  {object_list          List          }
 546  } {param(porosity_value) && param(object_list)}
 547
 548
 549
 550 # register_new_type EdgeList {
 551 #    if {[sdc::check_type List $value]} {
 552 #        if {[expr {[llength $value] % 2}] || [llength $value]==0} {
 553 #            return 0
 554 #        }
 555 #
 556 #        set startvalue -0.1
 557 #
 558 #        foreach parv $value {
 559 #            if {[catch {expr {$parv + 1}}]} {
 560 #                return 0
 561 #            }
 562 #            if {$parv<=$startvalue} {
 563 #                return 0
 564 #            }
 565 #            set startvalue $parv
 566 #        }
 567 #
 568 #        return 1
 569 #    } else {
 570 #        return 0
 571 #    }
 572 # }