1################################################################################ 2# 3# Copyright 2009 (c) Synopsys, Inc. 4# 5################################################################################ 6# 7# Title : SDC-parser commands declaration for SDC version 1.8 8# 9# Update By : Ibna Faruque 10# Updated On : July, 2009 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#added on SDC1.7 30declare all_registers { 31 {-clock List } 32 {-rise_clock List } 33 {-fall_clock List } 34 {-no_hierarchy Flag } 35 {-cells Flag } 36 {-data_pins Flag } 37 {-clock_pins Flag } 38 {-slave_clock_pins Flag } 39 {-async_pins Flag } 40 {-output_pins Flag } 41 {-level_sensitive Flag } 42 {-edge_triggered Flag } 43 {-master_slave Flag } 44 } 45 46 declare create_clock { 47 {-period Float {$par>=0} } 48 {-name String } 49 {-waveform List {type_Float {length($length>=2 && ($length % 2)==0)} } } 50 {port_pin_list List } 51 {-add Flag } 52 } {param(-period) && (param(-name) || param(port_pin_list))} 53 54 declare create_generated_clock { 55 {-name String } 56 {-source List } 57 {-edges List {type_Float {length($length>=2} } } 58 {-divide_by Int {1 && $par>=0} } 59 {-multiply_by Int {1 && $par>=0} } 60 {-edge_shift List } 61 {-duty_cycle Float {$par>=0 && $par <=100} } 62 {-invert Flag } 63 {-combinational Flag } 64 {port_pin_list List } 65 {-add Flag } 66 {-master_clock List } 67} {param(-source) && param(port_pin_list) && !(param(-multiply_by) && param(-divide_by))} 68 69 declare current_design { 70 } 71 72 declare current_instance { 73 {-instance String } 74 } 75 76# added SDC1.7 77 declare group_path { 78 {-name String } 79 {-default Flag } 80 {-weight Float {$par>=0.0 && $par <=100.0} } 81 {-from List } 82 {-rise_from List } 83 {-fall_from List } 84 {-to List } 85 {-rise_to List } 86 {-fall_to List } 87 {-through List {dup} } 88 {-rise_through List {dup} } 89 {-fall_through List {dup} } 90 } {((param(-name) && !param(-default)) || \ 91 (param(-default) && !param(-name)) || !param(-name) && \ 92 (param(-from) ^ param(-rise_from) ^ param(-fall_from)))} 93 94 95 declare get_cells { 96 {-of_objects List } 97 {patterns List } 98 {-hierarchical Flag } 99 {-regexp Flag } 100 {-nocase Flag } 101 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 102 # { } 103 } {(param(patterns) && !param(-of_objects)) || \ 104 (param(-of_objects) && !param(patterns)) || !param(patterns)} 105# && !param(-hierarchical))} 106 107# get_cell synonym for get_cells 108 declare get_cell { 109 {-of_objects List } 110 {patterns List } 111 {-hierarchical Flag } 112 {-regexp Flag } 113 {-nocase Flag } 114 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 115 } {(param(patterns) && !param(-of_objects)) || \ 116 (param(-of_objects) && !param(patterns)) || !param(patterns)} 117 118 119 120 declare get_clocks { 121 {patterns List } 122 {-regexp Flag } 123 {-nocase Flag } 124 } 125 126 declare get_clock { 127 {patterns List } 128 {-regexp Flag } 129 {-nocase Flag } 130} 131 132 declare get_lib_cells { 133 {patterns List } 134 {-regexp Flag } 135 {-nocase Flag } 136 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 137 } {param(patterns)} 138 139 declare get_lib_cell { 140 {patterns List } 141 {-regexp Flag } 142 {-nocase Flag } 143 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 144 } {param(patterns)} 145 146 147 declare get_lib_pins { 148 {patterns List } 149 {-regexp Flag } 150 {-nocase Flag } 151 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 152 } {param(patterns)} 153 154 declare get_lib_pin { 155 {patterns List } 156 {-regexp Flag } 157 {-nocase Flag } 158 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 159 } {param(patterns)} 160 161 162 declare get_libs { 163 {-regexp Flag } 164 {-nocase Flag } 165 {patterns List } 166} 167 168 declare get_nets { 169 {patterns List } 170 {-of_objects List } 171 {-hierarchical Flag } 172 {-regexp Flag } 173 {-nocase Flag } 174 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 175} {(param(patterns) && !param(-of_objects)) || \ 176 (param(-of_objects) && !param(patterns)) || !param(patterns)} 177 178 179 declare get_net { 180 {patterns List } 181 {-of_objects List } 182 {-hierarchical Flag } 183 {-regexp Flag } 184 {-nocase Flag } 185 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 186} {(param(patterns) && !param(-of_objects)) || \ 187 (param(-of_objects) && !param(patterns)) || !param(patterns)} 188 189 190 191 declare get_pins { 192 {patterns List } 193 {-hierarchical Flag } 194 {-regexp Flag } 195 {-nocase Flag } 196 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 197 } 198 199 declare get_pin { 200 {patterns List } 201 {-hierarchical Flag } 202 {-regexp Flag } 203 {-nocase Flag } 204 {-hsc Enum {{/} {@} {^} {#} {.} {|}}} 205 } 206 207 declare get_ports { 208 {-hierarchical Flag } 209 {-regexp Flag } 210 {patterns List } 211} 212# } {param(patterns)} 213 214 declare get_port { 215 {-hierarchical Flag } 216 {-regexp Flag } 217 {patterns List } 218} 219# } {param(patterns)} 220 221# sdc1.7 updte 222 declare set_units { 223 {-capacitance String } 224 {-resistance String } 225 {-time String } 226 {-voltage String } 227 {-current String } 228 {-power String } 229} 230 231# set_unit synonym for set_units 232 declare set_unit { 233 {-capacitance String } 234 {-resistance String } 235 {-time String } 236 {-voltage String } 237 {-current String } 238 {-power String } 239} 240 241 declare set_case_analysis { 242 {value Enum {0 1 rising falling zero one rise fall}} 243 {port_pin_list List } 244 } {param(value) && param(port_pin_list)} 245 246 declare set_clock_gating_check { 247 {-setup Float {$par>=0}} 248 {-hold Float {$par>=0}} 249 {-rise Flag } 250 {-fall Flag } 251 {-high Flag } 252 {-low Flag } 253 {object_list List } 254 } {(param(-setup) || param(-hold) || param(-high) || param(-low)) && \ 255 !(param(-high) && param(-low))} 256 257# sdc1.7 command 258 declare set_clock_groups { 259 {-name String } 260 {-physically_exclusive Flag } 261 {-logically_exclusive Flag } 262 {-asynchronous Flag } 263 {-allow_paths Flag } 264 {-group List {dup} } 265 } {(param(-physically_exclusive) ^ param(-logically_exclusive) ^ param(-asynchronous)) } 266 267# set_clock_group synonym for set_clock_groups 268 declare set_clock_group { 269 {-name String } 270 {-physically_exclusive Flag } 271 {-logically_exclusive Flag } 272 {-asynchronous Flag } 273 {-allow_paths Flag } 274 {-group List } 275 } {(param(-physically_exclusive) ^ param(-logically_exclusive) ^ param(-asynchronous)) } 276 277# sdc1.7 command 278 declare set_clock_sense { 279 {-clocks List } 280 {-positive Flag } 281 {-negative Flag } 282 {-stop_propagation Flag } 283 {-pulse Enum {rise_triggered_high_pulse rise_triggered_low_pulse \ 284 fall_triggered_high_pulse fall_triggered_low_pulse} } 285 {pins List } 286 } {(param(-positive) ^ param(-negative) ^ param(-stop_propagation) ^ param(-pulse)) } 287 288 declare set_clock_latency { 289 {delay Float {1}} 290 {object_list List } 291 {-rise Flag } 292 {-fall Flag } 293 {-min Flag } 294 {-max Flag } 295 {-source Flag } 296 {-early Flag } 297 {-late Flag } 298 {-clock List } 299 } {param(delay) && param(object_list)} 300 301#sdc1.7 302 declare set_ideal_latency { 303 {value Float {1}} 304 {object_list List } 305 {-rise Flag } 306 {-fall Flag } 307 {-min Flag } 308 {-max Flag } 309 } {param(value) && param(object_list)} 310 311#sdc1.7 312 declare set_ideal_network { 313 {object_list List } 314 {-no_propagate Flag } 315 } {param(object_list)} 316 317#sdc1.7 318 declare set_ideal_transition { 319 {value Float {1}} 320 {object_list List } 321 {-rise Flag } 322 {-fall Flag } 323 {-min Flag } 324 {-max Flag } 325 } {param(value) && param(object_list)} 326 327#sdc1.8 328 declare set_voltage { 329 {value Float {1}} 330 {-object_list List } 331 {-min Float {$par>=0} } 332 } {param(value) && param(-object_list)} 333 334 declare set_clock_transition { 335 {transition Float {1}} 336 {clock_list List } 337 {-rise Flag } 338 {-fall Flag } 339 {-min Flag } 340 {-max Flag } 341 } {param(transition) && param(clock_list) && \ 342 !(param(-rise) && param(-fall))} 343 344 declare set_clock_uncertainty { 345 {uncertainty Float {1}} 346 {-from List } 347 {-to List } 348 {-rise_to List } 349 {-fall_to List } 350 {-rise_from List } 351 {-fall_from List } 352 {-rise Flag } 353 {-fall Flag } 354 {-setup Flag } 355 {-hold Flag } 356 {object_list List } 357 } {param(uncertainty) && param(object_list) ^ \ 358 (((param(-from) ^ param(-rise_from) ^ param(-fall_from))) \ 359 && (param(-to) ^ param(-rise_to) ^ param(-fall_to)))} 360 361 declare set_disable_timing { 362 {object_list List } 363 {-from String } 364 {-to String } 365 } {param(object_list) && \ 366 !(param(-to) ^ param(-from))} 367 368 declare set_drive { 369 {resistance Float {$par>=0}} 370 {port_list List } 371 {-rise Flag } 372 {-fall Flag } 373 {-min Flag } 374 {-max Flag } 375 } {param(resistance) && param(port_list)} 376 377 declare set_driving_cell { 378 {-lib_cell String } 379 {-rise Flag } 380 {-fall Flag } 381 {-library String } 382 {-pin String } 383 {-from_pin String } 384 {-multiply_by Float {$par>=0}} 385 {-dont_scale Flag } 386 {-no_design_rule Flag } 387 {-input_transition_rise Float {$par>=0}} 388 {-input_transition_fall Float {$par>=0}} 389 {port_list List } 390 {-min Flag } 391 {-max Flag } 392 {-clock List } 393 {-clock_fall Flag } 394 } {param(port_list) && param(-lib_cell)} 395 396 declare set_false_path { 397 {-setup Flag } 398 {-hold Flag } 399 {-rise Flag } 400 {-fall Flag } 401 {-from List } 402 {-rise_from List } 403 {-fall_from List } 404 {-to List } 405 {-rise_to List } 406 {-fall_to List } 407 {-through List {dup} } 408 {-fall_throough List {dup} } 409 {-rise_throough List {dup} } 410 } {(param(-from) || param(-to) || param(-through)) && \ 411 !(param(-rise) && param(-fall)) && !(param(-setup) && param(-hold))} 412 413 declare set_fanout_load { 414 {value Float {$par>=0}} 415 {port_list List } 416 } {param(value) && param(port_list)} 417 418 declare set_hierarchy_separator { 419 {hchar Enum {{/} {@} {^} {#} {.} {|}}} 420 } {param(hchar)} 421 422 declare set_input_delay { 423 {-clock List } 424 {-clock_fall Flag } 425 {-level_sensitive Flag } 426 {-rise Flag } 427 {-fall Flag } 428 {-min Flag } 429 {-max Flag } 430 {-add_delay Flag } 431 {delay_value Float {1} } 432 {port_pin_list List } 433 {-network_latency_included Flag } 434 {-source_latency_included Flag } 435 } {param(delay_value) && param(port_pin_list) && \ 436 !((param(-clock_fall) || param(-level_sensitive)) && !param(-clock))} 437 438 declare set_input_transition { 439 {-rise Flag } 440 {-fall Flag } 441 {-min Flag } 442 {-max Flag } 443 {transition Float {$par>=0}} 444 {port_list List } 445 {-clock List } 446 {-clock_fall Flag } 447 } {param(transition) && param(port_list)} 448 449 declare set_load { 450 {-min Flag } 451 {-max Flag } 452 {-substract_pin_load Flag } 453 {-pin_load Flag } 454 {-wire_load Flag } 455 {value Float {$par>=0}} 456 {objects List } 457 } {param(value) && param(objects)} 458 459 declare set_logic_dc { 460 {port_list List } 461 } {param(port_list)} 462 463 declare set_logic_one { 464 {port_list List } 465 } {param(port_list)} 466 467 declare set_logic_zero { 468 {port_list List } 469 } {param(port_list)} 470 471 declare set_max_area { 472 {area_value Float {$par>=0}} 473 } {param(area_value)} 474 475 declare set_max_capacitance { 476 {capacitance_value Float {$par>=0}} 477 {object_list List } 478 } {param(capacitance_value) && param(object_list)} 479 480 declare set_max_delay { 481 {delay_value Float {1} } 482 {-rise Flag } 483 {-fall Flag } 484 {-from List } 485 {-rise_from List } 486 {-fall_from List } 487 {-to List } 488 {-rise_to List } 489 {-fall_to List } 490 {-through List {dup} } 491 {-fall_through List {dup} } 492 {-rise_through List {dup} } 493 } {param(delay_value) && \ 494 !(param(-rise) && param(-fall))} 495 496 declare set_max_fanout { 497 {fanout_value Float {$par>=0}} 498 {object_list List } 499 } {param(fanout_value) && param(object_list)} 500 501 declare set_max_time_borrow { 502 {delay_value Float {$par>=0}} 503 {object_list List } 504 } {param(delay_value) && param(object_list)} 505 506 declare set_max_transition { 507 {transition_value Float {$par>=0}} 508 {-clock_path Flag } 509 {-fall Flag } 510 {-rise Flag} 511 {object_list List } 512 } {param(transition_value) && param(object_list)} 513 514 declare set_min_capacitance { 515 {capacitance_value Float {$par>=0}} 516 {object_list List } 517 } {param(capacitance_value) && param(object_list)} 518 519 declare set_min_delay { 520 {delay_value Float {1} } 521 {-rise Flag } 522 {-fall Flag } 523 {-from List } 524 {-rise_from List } 525 {-fall_from List } 526 {-to List } 527 {-rise_to List } 528 {-fall_to List } 529 {-through List {dup} } 530 {-fall_through List {dup} } 531 {-rise_through List {dup} } 532 } {param(delay_value) && \ 533 !(param(-rise) && param(-fall))} 534 535 declare set_multicycle_path { 536 {path_multiplier Int {1}} 537 {-setup Flag } 538 {-hold Flag } 539 {-rise Flag } 540 {-fall Flag } 541 {-start Flag } 542 {-end Flag } 543 {-from List } 544 {-to List } 545 {-rise_to List } 546 {-fall_to List } 547 {-rise_from List } 548 {-fall_from List } 549 {-rise_through List {dup}} 550 {-fall_through List {dup}} 551 {-through List {dup}} 552 } {param(path_multiplier)} 553 554 declare set_operating_conditions { 555 {-analysis_type Enum {single bc_wc on_chip_variation}} 556 {-library List } 557 {-max String } 558 {-min String } 559 {-max_library List } 560 {-object_list List } 561 {-min_library List } 562 {condition String } 563 } 564 565 declare set_output_delay { 566 {-clock List } 567 {-clock_fall Flag } 568 {-level_sensitive Flag } 569 {-rise Flag } 570 {-fall Flag } 571 {-min Flag } 572 {-max Flag } 573 {-add_delay Flag } 574 {delay_value Float {1}} 575 {port_pin_list List } 576 {-network_latency_included Flag } 577 {-source_latency_included Flag } 578 579 } {param(delay_value) && param(port_pin_list) && \ 580 !((param(-clock_fall) || param(-level_sensitive)) && !param(-clock))} 581 582 declare set_port_fanout_number { 583 {fanout_number Int {($par>=0) && ($par<=100000)}} 584 {port_list List } 585 } {param(fanout_number) && param(port_list)} 586 587 declare set_propagated_clock { 588 {object_list List } 589 } {param(object_list)} 590 591 declare set_resistance { 592 {value Float {$par>=0}} 593 {net_list List } 594 {-min Flag } 595 {-max Flag } 596 } {param(value) && param(net_list)} 597 598 declare set_wire_load_min_block_size { 599 {size Float {$par>=0}} 600 } {param(size)} 601 602 declare set_wire_load_mode { 603 {mode_name Enum {top enclosed segmented}} 604 } {param(mode_name)} 605 606 declare set_wire_load_model { 607 {-name String } 608 {-library List } 609 {-min Flag } 610 {-max Flag } 611 {object_list List } 612 } {param(-name)} 613 614 declare set_wire_load_selection_group { 615 {group_name String } 616 {-library List } 617 {-min Flag } 618 {-max Flag } 619 {object_list List } 620 } {param(group_name)} 621 622 declare set_data_check { 623 {-from List } 624 {-rise_from List } 625 {-fall_from List } 626 {-to List } 627 {-rise_to List } 628 {-fall_to List } 629 {-rise Flag } 630 {-fall Flag } 631 {-setup Flag } 632 {-hold Flag } 633 {-clock List } 634 {value Float {$par>=0} } 635 } {(param(-rise_from) || param(-from) || param(-fall_from)) && \ 636 ((param(-to) || param(-rise_to)) || param(-fall_to)) } 637 638 declare set_timing_derate { 639 {derate_value Float {$par>=0.1 } } 640 {object_list List } 641# {derate_value Float {$par>=0.1 && $par<=2.0}} 642 {-min Flag } 643 {-max Flag } 644 {-rise Flag } 645 {-fall Flag } 646 {-early Flag } 647 {-late Flag } 648 {-clock Flag } 649 {-data Flag } 650 {-net_delay Flag } 651 {-cell_delay Flag } 652 {-cell_check Flag } 653} {param(derate_value) && (param(-early) && !param(-late)) || (param(-late) && !param(-early))} 654 655 656 657 declare set_max_dynamic_power { 658 {power_value Float {$par>=0} } 659 {-unit Enum {GW MW KW W mW uW nW pW fW aW} } 660 } {param(power_value)} 661 662 declare set_max_leakage_power { 663 {power_value Float {$par>=0}} 664 {-unit Enum {GW MW KW W mW uW nW pW fW aW}} 665 } {param(power_value)} 666 667declare create_voltage_area { 668 {-name String {1} } 669 {-coordinate List } 670 {-guard_band_x List } 671 {-guard_band_y List } 672 {cell_list List {1} } 673 } {param(-name) && {param(cell_list)}} 674 675declare set_level_shifter_strategy { 676 {-rule Enum {all low_to_high high_to_low}} 677 } {param(-rule)} 678 679declare set_level_shifter_threshold { 680 {-voltage Float {1} } 681 {-percent Float {1} } 682 } {param(-voltage)} 683 684 685 686 declare set_min_porosity { 687 {porosity_value Float {$par>=0 && $par <=90}} 688 {object_list List } 689 } {param(porosity_value) && param(object_list)} 690 691 692 693# register_new_type EdgeList { 694# if {[sdc::check_type List $value]} { 695# if {[expr {[llength $value] % 2}] || [llength $value]==0} { 696# return 0 697# } 698# 699# set startvalue -0.1 700# 701# foreach parv $value { 702# if {[catch {expr {$parv + 1}}]} { 703# return 0 704# } 705# if {$parv<=$startvalue} { 706# return 0 707# } 708# set startvalue $parv 709# } 710# 711# return 1 712# } else { 713# return 0 714# } 715# } 716