distrib/share/tcl/sdc1.7.tcl

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