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