diff --git a/vlsisapd/CMakeLists.txt b/vlsisapd/CMakeLists.txt index 97937860..a242cfe0 100644 --- a/vlsisapd/CMakeLists.txt +++ b/vlsisapd/CMakeLists.txt @@ -7,11 +7,13 @@ find_package(Bootstrap REQUIRED) list(INSERT CMAKE_MODULE_PATH 0 "${VLSISAPD_SOURCE_DIR}/cmake_modules/") - setup_boost(program_options filesystem python) + setup_boost(program_options filesystem python regex) find_package(LibXml2 REQUIRED) find_package(PythonSitePackages REQUIRED) find_package(PythonLibs REQUIRED) + find_package(BISON REQUIRED) + find_package(FLEX REQUIRED) find_package(Doxygen) add_subdirectory(src) diff --git a/vlsisapd/examples/CMakeLists.txt b/vlsisapd/examples/CMakeLists.txt index fa59bf16..abfa2611 100644 --- a/vlsisapd/examples/CMakeLists.txt +++ b/vlsisapd/examples/CMakeLists.txt @@ -2,3 +2,4 @@ ADD_SUBDIRECTORY(cif) ADD_SUBDIRECTORY(agds) ADD_SUBDIRECTORY(dtr) ADD_SUBDIRECTORY(openChams) +ADD_SUBDIRECTORY(liberty) diff --git a/vlsisapd/examples/liberty/CMakeLists.txt b/vlsisapd/examples/liberty/CMakeLists.txt new file mode 100644 index 00000000..63da01e7 --- /dev/null +++ b/vlsisapd/examples/liberty/CMakeLists.txt @@ -0,0 +1,4 @@ +ADD_SUBDIRECTORY(cplusplus) +#ADD_SUBDIRECTORY(python) + +#INSTALL ( FILES inverter.xml DESTINATION share/doc/coriolis2/examples/vlsisapd/openChams ) diff --git a/vlsisapd/examples/liberty/cplusplus/CMakeLists.txt b/vlsisapd/examples/liberty/cplusplus/CMakeLists.txt new file mode 100644 index 00000000..da3978b5 --- /dev/null +++ b/vlsisapd/examples/liberty/cplusplus/CMakeLists.txt @@ -0,0 +1,7 @@ +INCLUDE_DIRECTORIES ( ${VLSISAPD_SOURCE_DIR}/src/liberty/src ) +ADD_EXECUTABLE ( driveLiberty driveLiberty.cpp ) +ADD_EXECUTABLE ( parseLiberty parseLiberty.cpp ) +TARGET_LINK_LIBRARIES ( driveLiberty liberty ) +TARGET_LINK_LIBRARIES ( parseLiberty liberty ) +INSTALL ( TARGETS driveLiberty DESTINATION share/doc/coriolis2/examples/vlsisapd/liberty ) +INSTALL ( TARGETS parseLiberty DESTINATION share/doc/coriolis2/examples/vlsisapd/liberty ) diff --git a/vlsisapd/examples/liberty/cplusplus/driveLiberty.cpp b/vlsisapd/examples/liberty/cplusplus/driveLiberty.cpp new file mode 100644 index 00000000..48bf7f6d --- /dev/null +++ b/vlsisapd/examples/liberty/cplusplus/driveLiberty.cpp @@ -0,0 +1,68 @@ +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/Library.h" +#include "vlsisapd/liberty/WireLoad.h" +#include "vlsisapd/liberty/WireLoadSelection.h" +#include "vlsisapd/liberty/Cell.h" +#include "vlsisapd/liberty/Pin.h" +#include "vlsisapd/liberty/Timing.h" + +int main ( int argc, char * argv[] ) { + LIB::Name libName = LIB::Name("test"); + LIB::Library* library = new LIB::Library(libName); + + std::string valeur, unit; + + // Attributes + valeur="0.011"; library->addAttribute(LIB::Name("default_inout_pin_cap"), LIB::Attribute::Double, valeur); + valeur="enclosed"; library->addAttribute(LIB::Name("default_wire_load_mode"), LIB::Attribute::String, valeur); + valeur="1", unit="ns"; library->addAttribute(LIB::Name("time_unit"), LIB::Attribute::Unit, valeur, unit); + valeur="1", unit="pf"; library->addAttribute(LIB::Name("capacitive_load_unit"), LIB::Attribute::Unit, valeur, unit); + + // WireLoads + library->addWireLoad(LIB::Name("medium")); + LIB::WireLoad* wireLoad = library->getWireLoad(LIB::Name("medium")); + valeur="200"; wireLoad->addAttribute(LIB::Name("slope"), LIB::Attribute::Double, valeur); + valeur="1"; unit="200"; wireLoad->addAttribute(LIB::Name("fanout_length"), LIB::Attribute::Pair, valeur, unit); + + // WireLoadSelection + library->addWireLoadSelection(LIB::Name("medium")); + LIB::WireLoadSelection* wireLoadSelection = library->getWireLoadSelection(); + wireLoadSelection->addWireLoadArea(0, 500, LIB::Name("small")); + + // Cells + library->addCell(LIB::Name("inv")); + LIB::Cell* cell = library->getCell(LIB::Name("inv")); + valeur="1"; cell->addAttribute(LIB::Name("area"), LIB::Attribute::Double, valeur); + valeur="inv"; cell->addAttribute(LIB::Name("cell_footprint"), LIB::Attribute::String, valeur); + + LIB::Pin* pin; + + // Pins + cell->addPin(LIB::Name("e")); + pin = cell->getPin(LIB::Name("e")); + valeur="0.008"; pin->addAttribute(LIB::Name("capacitance"), LIB::Attribute::Double, valeur); + valeur="input"; pin->addAttribute(LIB::Name("direction"), LIB::Attribute::String, valeur); + + cell->addPin(LIB::Name("s")); + pin = cell->getPin(LIB::Name("s")); + valeur="i'"; pin->addAttribute(LIB::Name("function"), LIB::Attribute::String, valeur); + valeur="output"; pin->addAttribute(LIB::Name("direction"), LIB::Attribute::String, valeur); + + // Timing + LIB::Timing * timing; + pin->addTiming(); + timing = pin->getTiming().back(); + valeur="negative_unate"; timing->addAttribute(LIB::Name("timing_sense"), LIB::Attribute::String, valeur); + valeur="e"; timing->addAttribute(LIB::Name("related_pin"), LIB::Attribute::String, valeur); + valeur="0.101"; timing->addAttribute(LIB::Name("intrinsic_rise"), LIB::Attribute::Double, valeur); + + + // Write + valeur="test.lib"; library->writeToFile(valeur); + + return 0; +} + diff --git a/vlsisapd/examples/liberty/cplusplus/parseLiberty.cpp b/vlsisapd/examples/liberty/cplusplus/parseLiberty.cpp new file mode 100644 index 00000000..59a1bf94 --- /dev/null +++ b/vlsisapd/examples/liberty/cplusplus/parseLiberty.cpp @@ -0,0 +1,21 @@ +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Library.h" + +int main ( int argc, char * argv[] ) { + LIB::Library* library = LIB::Library::readFromFile("./sxlib.lib"); + + if ( library ) { + library->print(); + } else { + cerr << "library is NULL" << endl; + } + +// library->writeToFile("./mySxlib.lib"); + + return 0; +} + diff --git a/vlsisapd/examples/liberty/sxlib.lib b/vlsisapd/examples/liberty/sxlib.lib new file mode 100644 index 00000000..079af9c0 --- /dev/null +++ b/vlsisapd/examples/liberty/sxlib.lib @@ -0,0 +1,5019 @@ +/* --------------------------------------------- */ +/* written by Franck LE DU and Franck Wajsburt */ +/* */ +/* DEF_SXLIB modified : Sep 27, 1999 */ +/* */ +/* This file is obtained from */ +/* the technolocal parameters contained in the */ +/* VHDL generic data included in the .vbe files. */ +/* This file should not be edited directly. */ +/* */ +/* NOTE FOR NEW REVISION THAT ALL NON ZERO VALUE */ +/* MUST BE UPDATED TO THE NEW TECHNOLOGY AND ALL */ +/* ZERO VALUE SHOULD REMAIN ZERO (CHANGE */ +/* DEFAULT_WIRE_LOAD_RESISTANCE MAY HAVE NO */ +/* EFFECT SINCE ALL USEFUL PARAMETER REQUIRED TO */ +/* TAKE RESISTANCE INTO ACCOUNT ARE NOT DEFINED */ +/* IN THIS FILE */ +/* --------------------------------------------- */ + +library (sxlib) { + + date : "Thu Dec 21 11:24:55 MET 2000"; + revision : 1.2; + + /* --------------------------------------------- */ + /* Set of default values required for Synopsys */ + /* technology library generation */ + /* --------------------------------------------- */ + + /* --------------------------------------------- */ + /* default values intended to represent a */ + /* typical na2_x1 cell */ + /* --------------------------------------------- */ + + default_inout_pin_cap : 0.011; /* pf= + */ + default_inout_pin_fall_res : 2.850; /* kOhms */ + default_inout_pin_rise_res : 3.720; /* kOhms */ + default_input_pin_cap : 0.011; /* pf= + */ + default_intrinsic_fall : 0.059; /* ns */ + default_intrinsic_rise : 0.059; /* ns */ + default_output_pin_cap : 0; /* must be 0 */ + default_output_pin_fall_res : 2.850; /* kOhms */ + default_output_pin_rise_res : 3.720; /* kOhms */ + default_slope_fall : 0.1; /* worst case meaning propagation */ + /* time is delayed of .1 the */ + /* transition time of the previous*/ + /* gate */ + default_slope_rise : 0.1; /* idem */ + default_fanout_load : 0.011; /* max of input capacities in pF */ + default_max_fanout : 0.078; /* max output capacitance in pF */ + /* computed in order to a inv_x1 */ + /* be able to drive 10 inv_x1 */ + + /* --------------------------------------------- */ + /* default_wire_load_capacitance in pf/lambda */ + /* is capacitance-per-unit-length value of */ + /* the routing wire */ + /* --------------------------------------------- */ + + default_wire_load_capacitance : 0.00015;/* pf/lambda */ + default_wire_load_resistance : 0; /* must be 0 */ + default_wire_load_area : 0; /* must be 0 */ + default_wire_load_mode : enclosed;/* top/segmented/enclosed */ + + /* --------------------------------------------- */ + /* all these parameters are neglected since */ + /* we choose to only time design with worst case */ + /* operating conditions (must be 0) */ + /* --------------------------------------------- */ + + k_process_drive_fall : 0.0; + k_process_drive_rise : 0.0; + k_process_intrinsic_fall : 0.0; + k_process_intrinsic_rise : 0.0; + k_process_pin_cap : 0.0; + k_process_slope_fall : 0.0; + k_process_slope_rise : 0.0; + k_process_wire_cap : 0.0; + k_process_wire_res : 0.0; + k_temp_drive_fall : 0.0; + k_temp_drive_rise : 0.0; + k_temp_intrinsic_fall : 0.0; + k_temp_intrinsic_rise : 0.0; + k_temp_pin_cap : 0.0; + k_temp_slope_fall : 0.0; + k_temp_slope_rise : 0.0; + k_temp_wire_cap : 0.0; + k_temp_wire_res : 0.0; + k_volt_drive_fall : 0.0; + k_volt_drive_rise : 0.0; + k_volt_intrinsic_fall : 0.0; + k_volt_intrinsic_rise : 0.0; + k_volt_pin_cap : 0.0; + k_volt_slope_fall : 0.0; + k_volt_slope_rise : 0.0; + k_volt_wire_cap : 0.0; + k_volt_wire_res : 0.0; + + /* -------------------------------------------- */ + /* values given as information (unused for */ + /* timing design computation) */ + /* -------------------------------------------- */ + + time_unit : "1ns"; + voltage_unit : "1V"; + current_unit : "1uA"; + pulling_resistance_unit : "1kohm"; + capacitive_load_unit (1,pf); + + /* -------------------------------------------- */ + /* Operating conditions */ + /* -------------------------------------------- */ + + nom_process : 1.5; + nom_temperature : 70.0; + nom_voltage : 3.0; + + in_place_swap_mode : match_footprint; + + /* -------------------------------------------- */ + /* slope and fanout_length are expressed */ + /* in lambda. it represents the average wire */ + /* length from the driver output to one of the */ + /* following input. It means it needs 50 */ + /* lambdas of wire to connect 2 cells whatever */ + /* in small case */ + /* -------------------------------------------- */ + + wire_load("small") { + resistance : 0 ; /* must be 0 */ + capacitance : 0.00015 ; /* pf/lambda */ + area : 0 ; /* must be 0 */ + slope : 100; /* lambda */ + fanout_length(1,100) ; /* first parameter must be 1, second in lambda */ + } + wire_load("medium") { + resistance : 0 ; /* must be 0 */ + capacitance : 0.00015 ; /* pf/lambda */ + area : 0 ; /* must be 0 */ + slope : 200; /* lambda */ + fanout_length(1,200) ; /* first parameter must be 1, second in lambda */ + } + wire_load("big") { + resistance : 0 ; /* must be 0 */ + capacitance : 0.00015 ; /* pf/lambda */ + area : 0 ; /* must be 0 */ + slope : 400; /* lambda */ + fanout_length(1,400) ; /* first parameter must be 1, second in lambda */ + } + + wire_load_selection(medium) { + wire_load_from_area(0,500,"small"); /* less about 200 gates */ + wire_load_from_area(500,1500,"medium"); /* less about 500 gates */ + wire_load_from_area(1500,3000,"big"); /* less about 1000 gates */ + } + default_wire_load_selection : medium + + /*---------------------------------------------- */ + /* Combinationnal cells part 1 */ + /*---------------------------------------------- */ + + cell (inv_x1) { + area : 1.0 /* pitchs */ + cell_footprint : "inv"; + pin(i) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(nq) { + direction : output; + max_fanout : 0.078; + function : "i'"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.101; + intrinsic_fall : 0.139; + rise_resistance : 3.720; + fall_resistance : 3.640; + related_pin : "i"; + } + } + } + cell (inv_x2) { + area : 1.0 /* pitchs */ + cell_footprint : "inv"; + pin(i) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(nq) { + direction : output; + max_fanout : 0.120; + function : "i'"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.069; + intrinsic_fall : 0.163; + rise_resistance : 2.420; + fall_resistance : 1.620; + related_pin : "i"; + } + } + } + cell (inv_x4) { + area : 1.3 /* pitchs */ + cell_footprint : "inv"; + pin(i) { + direction : input; + capacitance : 0.026; + fanout_load : 0.026; + } + pin(nq) { + direction : output; + max_fanout : 0.275; + function : "i'"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.071; + intrinsic_fall : 0.143; + rise_resistance : 1.060; + fall_resistance : 0.810; + related_pin : "i"; + } + } + } + cell (inv_x8) { + area : 2.3 /* pitchs */ + cell_footprint : "inv"; + pin(i) { + direction : input; + capacitance : 0.054; + fanout_load : 0.054; + } + pin(nq) { + direction : output; + max_fanout : 0.647; + function : "i'"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.086; + intrinsic_fall : 0.133; + rise_resistance : 0.450; + fall_resistance : 0.400; + related_pin : "i"; + } + } + } + cell (an12_x1) { + area : 1.7 /* pitchs */ + cell_footprint : "an12"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.080; + function : "i0' * i1"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.200; + intrinsic_fall : 0.168; + rise_resistance : 3.210; + fall_resistance : 3.640; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.285; + intrinsic_fall : 0.405; + rise_resistance : 3.210; + fall_resistance : 3.640; + related_pin : "i1"; + } + } + } + cell (an12_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "an12"; + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "i0' * i1"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.461; + intrinsic_fall : 0.471; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.269; + intrinsic_fall : 0.518; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (on12_x1) { + area : 1.7 /* pitchs */ + cell_footprint : "on12"; + pin(i0) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.078; + function : "i0' + i1"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.111; + intrinsic_fall : 0.234; + rise_resistance : 3.720; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.314; + intrinsic_fall : 0.291; + rise_resistance : 3.720; + fall_resistance : 2.850; + related_pin : "i1"; + } + } + } + cell (on12_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "on12"; + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "i0' + i1"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.474; + intrinsic_fall : 0.499; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.491; + intrinsic_fall : 0.394; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (na2_x1) { + area : 1.3 /* pitchs */ + cell_footprint : "na2"; + pin(i0) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(nq) { + direction : output; + max_fanout : 0.078; + function : "(i0' + i1')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.059; + intrinsic_fall : 0.288; + rise_resistance : 3.720; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.111; + intrinsic_fall : 0.234; + rise_resistance : 3.720; + fall_resistance : 2.850; + related_pin : "i1"; + } + } + } + cell (na2_x4) { + area : 2.3 /* pitchs */ + cell_footprint : "na2"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "(i0' + i1')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.412; + intrinsic_fall : 0.552; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.353; + intrinsic_fall : 0.601; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (no2_x1) { + area : 1.3 /* pitchs */ + cell_footprint : "no2"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(nq) { + direction : output; + max_fanout : 0.080; + function : "(i0' * i1')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.298; + intrinsic_fall : 0.121; + rise_resistance : 3.210; + fall_resistance : 3.640; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.193; + intrinsic_fall : 0.161; + rise_resistance : 3.210; + fall_resistance : 3.640; + related_pin : "i1"; + } + } + } + cell (no2_x4) { + area : 2.3 /* pitchs */ + cell_footprint : "no2"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "(i0' * i1')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.618; + intrinsic_fall : 0.447; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.522; + intrinsic_fall : 0.504; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (na3_x1) { + area : 1.7 /* pitchs */ + cell_footprint : "na3"; + pin(i0) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(nq) { + direction : output; + max_fanout : 0.071; + function : "(i0' + i1' + i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.119; + intrinsic_fall : 0.363; + rise_resistance : 3.720; + fall_resistance : 4.120; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.171; + intrinsic_fall : 0.316; + rise_resistance : 3.720; + fall_resistance : 4.120; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.193; + intrinsic_fall : 0.265; + rise_resistance : 3.720; + fall_resistance : 4.120; + related_pin : "i2"; + } + } + } + cell (na3_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "na3"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i2) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "(i0' + i1' + i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.556; + intrinsic_fall : 0.601; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.460; + intrinsic_fall : 0.691; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.519; + intrinsic_fall : 0.647; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (nao22_x1) { + area : 2.0 /* pitchs */ + cell_footprint : "nao22"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(nq) { + direction : output; + max_fanout : 0.091; + function : "((i0' * i1') + i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.294; + intrinsic_fall : 0.226; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.218; + intrinsic_fall : 0.287; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.165; + intrinsic_fall : 0.238; + rise_resistance : 1.790; + fall_resistance : 2.850; + related_pin : "i2"; + } + } + } + cell (nao22_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "nao22"; + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0' * i1') + i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.732; + intrinsic_fall : 0.650; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.664; + intrinsic_fall : 0.723; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.596; + intrinsic_fall : 0.636; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (nmx2_x1) { + area : 2.3 /* pitchs */ + cell_footprint : "nmx2"; + pin(cmd) { + direction : input; + capacitance : 0.021; + fanout_load : 0.021; + } + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.091; + function : "((cmd + i0') * (cmd' + i1'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.218; + intrinsic_fall : 0.287; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "cmd"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.217; + intrinsic_fall : 0.256; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.217; + intrinsic_fall : 0.256; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + } + } + cell (nmx2_x4) { + area : 4.0 /* pitchs */ + cell_footprint : "nmx2"; + pin(cmd) { + direction : input; + capacitance : 0.017; + fanout_load : 0.017; + } + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((cmd + i0') * (cmd' + i1'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.632; + intrinsic_fall : 0.708; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.610; + intrinsic_fall : 0.653; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.610; + intrinsic_fall : 0.653; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (no3_x1) { + area : 1.7 /* pitchs */ + cell_footprint : "no3"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i2) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(nq) { + direction : output; + max_fanout : 0.062; + function : "(i0' * i1' * i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.318; + intrinsic_fall : 0.246; + rise_resistance : 4.690; + fall_resistance : 3.640; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.215; + intrinsic_fall : 0.243; + rise_resistance : 4.690; + fall_resistance : 3.640; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.407; + intrinsic_fall : 0.192; + rise_resistance : 4.690; + fall_resistance : 3.640; + related_pin : "i2"; + } + } + } + cell (no3_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "no3"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "(i0' * i1' * i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.722; + intrinsic_fall : 0.561; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.638; + intrinsic_fall : 0.623; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.545; + intrinsic_fall : 0.640; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (noa22_x1) { + area : 2.0 /* pitchs */ + cell_footprint : "noa22"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(nq) { + direction : output; + max_fanout : 0.091; + function : "((i0' + i1') * i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.151; + intrinsic_fall : 0.327; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.218; + intrinsic_fall : 0.287; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.218; + intrinsic_fall : 0.241; + rise_resistance : 3.210; + fall_resistance : 1.620; + related_pin : "i2"; + } + } + } + cell (noa22_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "noa22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0' + i1') * i2')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.550; + intrinsic_fall : 0.740; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.643; + intrinsic_fall : 0.709; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.610; + intrinsic_fall : 0.646; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (na4_x1) { + area : 2.0 /* pitchs */ + cell_footprint : "na4"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i3) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(nq) { + direction : output; + max_fanout : 0.054; + function : "(i0' + i1' + i2' + i3')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.179; + intrinsic_fall : 0.438; + rise_resistance : 3.720; + fall_resistance : 5.400; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.237; + intrinsic_fall : 0.395; + rise_resistance : 3.720; + fall_resistance : 5.400; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.269; + intrinsic_fall : 0.350; + rise_resistance : 3.720; + fall_resistance : 5.400; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.282; + intrinsic_fall : 0.302; + rise_resistance : 3.720; + fall_resistance : 5.400; + related_pin : "i3"; + } + } + } + cell (na4_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "na4"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i3) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "(i0' + i1' + i2' + i3')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.578; + intrinsic_fall : 0.771; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.643; + intrinsic_fall : 0.731; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.681; + intrinsic_fall : 0.689; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.703; + intrinsic_fall : 0.644; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + } + } + cell (nao2o22_x1) { + area : 2.3 /* pitchs */ + cell_footprint : "nao2o22"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.091; + function : "((i0' * i1') + (i2' * i3'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.294; + intrinsic_fall : 0.226; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.218; + intrinsic_fall : 0.287; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.237; + intrinsic_fall : 0.307; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.174; + intrinsic_fall : 0.382; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i3"; + } + } + } + cell (nao2o22_x4) { + area : 3.7 /* pitchs */ + cell_footprint : "nao2o22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i3) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0' * i1') + (i2' * i3'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.734; + intrinsic_fall : 0.644; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.666; + intrinsic_fall : 0.717; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.664; + intrinsic_fall : 0.721; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.607; + intrinsic_fall : 0.807; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + } + } + cell (no4_x1) { + area : 2.0 /* pitchs */ + cell_footprint : "no4"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i2) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i3) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(nq) { + direction : output; + max_fanout : 0.047; + function : "(i0' * i1' * i2' * i3')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.330; + intrinsic_fall : 0.340; + rise_resistance : 6.190; + fall_resistance : 3.640; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.230; + intrinsic_fall : 0.320; + rise_resistance : 6.190; + fall_resistance : 3.640; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.419; + intrinsic_fall : 0.333; + rise_resistance : 6.190; + fall_resistance : 3.640; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.499; + intrinsic_fall : 0.271; + rise_resistance : 6.190; + fall_resistance : 3.640; + related_pin : "i3"; + } + } + } + cell (no4_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "no4"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i2) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i3) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "(i0' * i1' * i2' * i3')"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.656; + intrinsic_fall : 0.777; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.564; + intrinsic_fall : 0.768; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.739; + intrinsic_fall : 0.761; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.816; + intrinsic_fall : 0.693; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + } + } + cell (noa2a22_x1) { + area : 2.3 /* pitchs */ + cell_footprint : "noa2a22"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.091; + function : "((i0' + i1') * (i2' + i3'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.151; + intrinsic_fall : 0.327; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.218; + intrinsic_fall : 0.287; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.284; + intrinsic_fall : 0.289; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.372; + intrinsic_fall : 0.256; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i3"; + } + } + } + cell (noa2a22_x4) { + area : 3.7 /* pitchs */ + cell_footprint : "noa2a22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i3) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0' + i1') * (i2' + i3'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.562; + intrinsic_fall : 0.745; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.646; + intrinsic_fall : 0.714; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.701; + intrinsic_fall : 0.703; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.805; + intrinsic_fall : 0.677; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + } + } + cell (nmx3_x1) { + area : 4.0 /* pitchs */ + cell_footprint : "nmx3"; + pin(cmd0) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(cmd1) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(nq) { + direction : output; + max_fanout : 0.030; + function : "((cmd0+i0')*(cmd0'+((cmd1'+i1')*(cmd1+i2'))))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.356; + intrinsic_fall : 0.495; + rise_resistance : 9.760; + fall_resistance : 7.420; + related_pin : "cmd0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.414; + intrinsic_fall : 0.566; + rise_resistance : 9.760; + fall_resistance : 7.420; + related_pin : "cmd1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.315; + intrinsic_fall : 0.441; + rise_resistance : 6.680; + fall_resistance : 5.140; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.429; + intrinsic_fall : 0.582; + rise_resistance : 9.760; + fall_resistance : 7.420; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.429; + intrinsic_fall : 0.582; + rise_resistance : 9.760; + fall_resistance : 7.420; + related_pin : "i2"; + } + } + } + cell (nmx3_x4) { + area : 5.0 /* pitchs */ + cell_footprint : "nmx3"; + pin(cmd0) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(cmd1) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((cmd0+i0')*(cmd0'+((cmd1'+i1')*(cmd1+i2'))))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.790; + intrinsic_fall : 0.936; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.866; + intrinsic_fall : 1.048; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.748; + intrinsic_fall : 0.900; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.869; + intrinsic_fall : 1.053; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.869; + intrinsic_fall : 1.053; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (noa2ao222_x1) { + area : 2.3 /* pitchs */ + cell_footprint : "noa2ao222"; + pin(i0) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i3) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i4) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(nq) { + direction : output; + max_fanout : 0.055; + function : "((i0'+i1')*((i2'*i3')+i4'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.348; + intrinsic_fall : 0.422; + rise_resistance : 5.260; + fall_resistance : 3.210; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.440; + intrinsic_fall : 0.378; + rise_resistance : 5.260; + fall_resistance : 3.210; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.186; + intrinsic_fall : 0.473; + rise_resistance : 5.260; + fall_resistance : 3.210; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.256; + intrinsic_fall : 0.459; + rise_resistance : 5.260; + fall_resistance : 3.210; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.240; + intrinsic_fall : 0.309; + rise_resistance : 3.750; + fall_resistance : 3.210; + related_pin : "i4"; + } + } + } + cell (noa2ao222_x4) { + area : 4.0 /* pitchs */ + cell_footprint : "noa2ao222"; + pin(i0) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i3) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i4) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0'+i1')*((i2'*i3')+i4'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.684; + intrinsic_fall : 0.801; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.780; + intrinsic_fall : 0.758; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.638; + intrinsic_fall : 0.809; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.732; + intrinsic_fall : 0.795; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.718; + intrinsic_fall : 0.664; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + } + } + cell (noa2a2a23_x1) { + area : 3.3 /* pitchs */ + cell_footprint : "noa2a2a23"; + pin(i0) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i4) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i5) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.062; + function : "((i0'+i1')*(i2'+i3')*(i4'+i5'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.525; + intrinsic_fall : 0.425; + rise_resistance : 4.690; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.643; + intrinsic_fall : 0.388; + rise_resistance : 4.690; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.307; + intrinsic_fall : 0.479; + rise_resistance : 4.690; + fall_resistance : 2.850; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.398; + intrinsic_fall : 0.438; + rise_resistance : 4.690; + fall_resistance : 2.850; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.250; + intrinsic_fall : 0.416; + rise_resistance : 4.690; + fall_resistance : 2.850; + related_pin : "i4"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.178; + intrinsic_fall : 0.464; + rise_resistance : 4.690; + fall_resistance : 2.850; + related_pin : "i5"; + } + } + } + cell (noa2a2a23_x4) { + area : 4.3 /* pitchs */ + cell_footprint : "noa2a2a23"; + pin(i0) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i4) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i5) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0'+i1')*(i2'+i3')*(i4'+i5'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.834; + intrinsic_fall : 0.814; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.955; + intrinsic_fall : 0.778; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.620; + intrinsic_fall : 0.873; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.716; + intrinsic_fall : 0.833; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.574; + intrinsic_fall : 0.819; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.496; + intrinsic_fall : 0.865; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i5"; + } + } + } + cell (noa3ao322_x1) { + area : 3.0 /* pitchs */ + cell_footprint : "noa3ao322"; + pin(i0) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i1) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i2) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i3) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i4) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i5) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i6) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(nq) { + direction : output; + max_fanout : 0.043; + function : "((i0'+i1'+i2')*(((i3'*i4')*i5')+i6'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.396; + intrinsic_fall : 0.616; + rise_resistance : 6.700; + fall_resistance : 3.370; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.486; + intrinsic_fall : 0.552; + rise_resistance : 6.700; + fall_resistance : 3.370; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.546; + intrinsic_fall : 0.488; + rise_resistance : 6.700; + fall_resistance : 3.370; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.196; + intrinsic_fall : 0.599; + rise_resistance : 6.700; + fall_resistance : 3.210; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.264; + intrinsic_fall : 0.608; + rise_resistance : 6.700; + fall_resistance : 3.210; + related_pin : "i4"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.328; + intrinsic_fall : 0.581; + rise_resistance : 6.700; + fall_resistance : 3.210; + related_pin : "i5"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.246; + intrinsic_fall : 0.311; + rise_resistance : 3.690; + fall_resistance : 3.210; + related_pin : "i6"; + } + } + } + cell (noa3ao322_x4) { + area : 4.3 /* pitchs */ + cell_footprint : "noa3ao322"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i3) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i4) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i5) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i6) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0'+i1'+i2')*(((i3'*i4')*i5')+i6'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.819; + intrinsic_fall : 0.987; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.914; + intrinsic_fall : 0.931; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.990; + intrinsic_fall : 0.874; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.729; + intrinsic_fall : 0.926; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.821; + intrinsic_fall : 0.924; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.907; + intrinsic_fall : 0.900; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i5"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.738; + intrinsic_fall : 0.718; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i6"; + } + } + } + cell (noa2a2a2a24_x1) { + area : 4.7 /* pitchs */ + cell_footprint : "noa2a2a2a24"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i3) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i4) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i5) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i6) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i7) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.047; + function : "((i0'+i1')*(i2'+i3')*(i4'+i5')*(i6'+i7'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.649; + intrinsic_fall : 0.606; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.775; + intrinsic_fall : 0.562; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.550; + intrinsic_fall : 0.662; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.667; + intrinsic_fall : 0.616; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.419; + intrinsic_fall : 0.613; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i4"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.329; + intrinsic_fall : 0.662; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i5"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.270; + intrinsic_fall : 0.535; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i6"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.200; + intrinsic_fall : 0.591; + rise_resistance : 6.190; + fall_resistance : 2.850; + related_pin : "i7"; + } + } + } + cell (noa2a2a2a24_x4) { + area : 5.7 /* pitchs */ + cell_footprint : "noa2a2a2a24"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i4) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i5) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i6) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i7) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "((i0'+i1')*(i2'+i3')*(i4'+i5')*(i6'+i7'))"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.966; + intrinsic_fall : 1.049; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 1.097; + intrinsic_fall : 1.005; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.867; + intrinsic_fall : 1.106; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.990; + intrinsic_fall : 1.061; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.748; + intrinsic_fall : 1.061; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.649; + intrinsic_fall : 1.109; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i5"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.606; + intrinsic_fall : 0.999; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i6"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.525; + intrinsic_fall : 1.052; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i7"; + } + } + } + cell (buf_x2) { + area : 1.3 /* pitchs */ + cell_footprint : "buf"; + pin(i) { + direction : input; + capacitance : 0.006; + fanout_load : 0.006; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "i"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.409; + intrinsic_fall : 0.391; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i"; + } + } + } + cell (buf_x4) { + area : 1.7 /* pitchs */ + cell_footprint : "buf"; + pin(i) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "i"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.379; + intrinsic_fall : 0.409; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i"; + } + } + } + cell (buf_x8) { + area : 2.7 /* pitchs */ + cell_footprint : "buf"; + pin(i) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(q) { + direction : output; + max_fanout : 0.647; + function : "i"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.343; + intrinsic_fall : 0.396; + rise_resistance : 0.450; + fall_resistance : 0.400; + related_pin : "i"; + } + } + } + cell (a2_x2) { + area : 1.7 /* pitchs */ + cell_footprint : "a2"; + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0 * i1)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.261; + intrinsic_fall : 0.388; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.203; + intrinsic_fall : 0.434; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + } + } + cell (a2_x4) { + area : 2.0 /* pitchs */ + cell_footprint : "a2"; + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0 * i1)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.338; + intrinsic_fall : 0.476; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.269; + intrinsic_fall : 0.518; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (o2_x2) { + area : 1.7 /* pitchs */ + cell_footprint : "o2"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0 + i1)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.406; + intrinsic_fall : 0.310; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.335; + intrinsic_fall : 0.364; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + } + } + cell (o2_x4) { + area : 2.0 /* pitchs */ + cell_footprint : "o2"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0 + i1)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.491; + intrinsic_fall : 0.394; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.427; + intrinsic_fall : 0.464; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (a3_x2) { + area : 2.0 /* pitchs */ + cell_footprint : "a3"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i2) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0 * i1 * i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.395; + intrinsic_fall : 0.435; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.353; + intrinsic_fall : 0.479; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.290; + intrinsic_fall : 0.521; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + } + } + cell (a3_x4) { + area : 2.3 /* pitchs */ + cell_footprint : "a3"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0 * i1 * i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.478; + intrinsic_fall : 0.514; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.428; + intrinsic_fall : 0.554; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.356; + intrinsic_fall : 0.592; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (ao22_x2) { + area : 2.0 /* pitchs */ + cell_footprint : "ao22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "((i0 + i1) * i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.558; + intrinsic_fall : 0.447; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.493; + intrinsic_fall : 0.526; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.420; + intrinsic_fall : 0.425; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + } + } + cell (ao22_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "ao22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "((i0 + i1) * i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.674; + intrinsic_fall : 0.552; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.615; + intrinsic_fall : 0.647; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.526; + intrinsic_fall : 0.505; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (mx2_x2) { + area : 3.0 /* pitchs */ + cell_footprint : "mx2"; + pin(cmd) { + direction : input; + capacitance : 0.017; + fanout_load : 0.017; + } + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(cmd' * i0)+(cmd * i1)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.484; + intrinsic_fall : 0.522; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "cmd"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.451; + intrinsic_fall : 0.469; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.451; + intrinsic_fall : 0.469; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + } + } + cell (mx2_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "mx2"; + pin(cmd) { + direction : input; + capacitance : 0.017; + fanout_load : 0.017; + } + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(cmd' * i0)+(cmd * i1)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.615; + intrinsic_fall : 0.647; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.564; + intrinsic_fall : 0.576; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.564; + intrinsic_fall : 0.576; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (o3_x2) { + area : 2.0 /* pitchs */ + cell_footprint : "o3"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0 + i1 + i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.494; + intrinsic_fall : 0.407; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.430; + intrinsic_fall : 0.482; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.360; + intrinsic_fall : 0.506; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + } + } + cell (o3_x4) { + area : 2.3 /* pitchs */ + cell_footprint : "o3"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0 + i1 + i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.569; + intrinsic_fall : 0.501; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.510; + intrinsic_fall : 0.585; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.447; + intrinsic_fall : 0.622; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (oa22_x2) { + area : 2.0 /* pitchs */ + cell_footprint : "oa22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "((i0 * i1) + i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.390; + intrinsic_fall : 0.555; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.488; + intrinsic_fall : 0.525; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.438; + intrinsic_fall : 0.454; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + } + } + cell (oa22_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "oa22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "((i0 * i1) + i2)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.511; + intrinsic_fall : 0.677; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.615; + intrinsic_fall : 0.650; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.523; + intrinsic_fall : 0.571; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (a4_x2) { + area : 2.3 /* pitchs */ + cell_footprint : "a4"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i3) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0 * i1 * i2 * i3)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.374; + intrinsic_fall : 0.578; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.441; + intrinsic_fall : 0.539; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.482; + intrinsic_fall : 0.498; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.506; + intrinsic_fall : 0.455; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + } + } + cell (a4_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "a4"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i3) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0 * i1 * i2 * i3)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.505; + intrinsic_fall : 0.650; + rise_resistance : 0.890; + fall_resistance : 0.540; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.578; + intrinsic_fall : 0.614; + rise_resistance : 0.890; + fall_resistance : 0.540; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.627; + intrinsic_fall : 0.576; + rise_resistance : 0.890; + fall_resistance : 0.540; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.661; + intrinsic_fall : 0.538; + rise_resistance : 0.890; + fall_resistance : 0.540; + related_pin : "i3"; + } + } + } + cell (ao2o22_x2) { + area : 3.0 /* pitchs */ + cell_footprint : "ao2o22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i3) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "((i0 + i1) * (i2 + i3))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.572; + intrinsic_fall : 0.451; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.508; + intrinsic_fall : 0.542; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.432; + intrinsic_fall : 0.627; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.488; + intrinsic_fall : 0.526; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + } + } + cell (ao2o22_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "ao2o22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i3) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "((i0 + i1) * (i2 + i3))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.696; + intrinsic_fall : 0.569; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.637; + intrinsic_fall : 0.666; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.554; + intrinsic_fall : 0.744; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.606; + intrinsic_fall : 0.639; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + } + } + cell (o4_x2) { + area : 2.3 /* pitchs */ + cell_footprint : "o4"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i2) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i3) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0 + i1 + i2 + i3)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.508; + intrinsic_fall : 0.601; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.446; + intrinsic_fall : 0.631; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.567; + intrinsic_fall : 0.531; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.378; + intrinsic_fall : 0.626; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + } + } + cell (o4_x4) { + area : 2.7 /* pitchs */ + cell_footprint : "o4"; + pin(i0) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i1) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i2) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(i3) { + direction : input; + capacitance : 0.012; + fanout_load : 0.012; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0 + i1 + i2 + i3)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.574; + intrinsic_fall : 0.638; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.492; + intrinsic_fall : 0.650; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.649; + intrinsic_fall : 0.611; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.721; + intrinsic_fall : 0.536; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + } + } + cell (oa2a22_x2) { + area : 3.0 /* pitchs */ + cell_footprint : "oa2a22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i3) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "((i0 * i1) + (i2 * i3))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.403; + intrinsic_fall : 0.564; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.495; + intrinsic_fall : 0.534; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.646; + intrinsic_fall : 0.487; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.537; + intrinsic_fall : 0.512; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + } + } + cell (oa2a22_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "oa2a22"; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i3) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "((i0 * i1) + (i2 * i3))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.519; + intrinsic_fall : 0.696; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.624; + intrinsic_fall : 0.669; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.763; + intrinsic_fall : 0.596; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.644; + intrinsic_fall : 0.619; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + } + } + cell (mx3_x2) { + area : 4.3 /* pitchs */ + cell_footprint : "mx3"; + pin(cmd0) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(cmd1) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(cmd0'*i0)+(cmd0*((cmd1*i1)+(cmd1'*i2)))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.573; + intrinsic_fall : 0.680; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "cmd0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.664; + intrinsic_fall : 0.817; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "cmd1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.538; + intrinsic_fall : 0.658; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.654; + intrinsic_fall : 0.808; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.654; + intrinsic_fall : 0.808; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + } + } + cell (mx3_x4) { + area : 4.7 /* pitchs */ + cell_footprint : "mx3"; + pin(cmd0) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(cmd1) { + direction : input; + capacitance : 0.015; + fanout_load : 0.015; + } + pin(i0) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i1) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(i2) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(cmd0'*i0)+(cmd0*((cmd1*i1)+(cmd1'*i2)))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.683; + intrinsic_fall : 0.779; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.792; + intrinsic_fall : 0.967; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.640; + intrinsic_fall : 0.774; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.770; + intrinsic_fall : 0.948; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.770; + intrinsic_fall : 0.948; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + } + } + cell (oa2ao222_x2) { + area : 3.3 /* pitchs */ + cell_footprint : "oa2ao222"; + pin(i0) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i3) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i4) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0*i1)+(i4*(i2+i3))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.495; + intrinsic_fall : 0.581; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.598; + intrinsic_fall : 0.539; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.464; + intrinsic_fall : 0.604; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.556; + intrinsic_fall : 0.578; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.558; + intrinsic_fall : 0.453; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i4"; + } + } + } + cell (oa2ao222_x4) { + area : 3.7 /* pitchs */ + cell_footprint : "oa2ao222"; + pin(i0) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i1) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i2) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i3) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(i4) { + direction : input; + capacitance : 0.011; + fanout_load : 0.011; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0*i1)+(i4*(i2+i3))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.553; + intrinsic_fall : 0.657; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.662; + intrinsic_fall : 0.616; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.552; + intrinsic_fall : 0.693; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.640; + intrinsic_fall : 0.660; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.656; + intrinsic_fall : 0.529; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + } + } + cell (oa2a2a23_x2) { + area : 4.0 /* pitchs */ + cell_footprint : "oa2a2a23"; + pin(i0) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i4) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i5) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "((i0*i1)+(i2*i3))+(i4*i5)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.653; + intrinsic_fall : 0.578; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.775; + intrinsic_fall : 0.542; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.441; + intrinsic_fall : 0.639; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.540; + intrinsic_fall : 0.600; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.402; + intrinsic_fall : 0.591; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i4"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.321; + intrinsic_fall : 0.636; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i5"; + } + } + } + cell (oa2a2a23_x4) { + area : 4.3 /* pitchs */ + cell_footprint : "oa2a2a23"; + pin(i0) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i1) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i4) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i5) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "((i0*i1)+(i2*i3))+(i4*i5)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.699; + intrinsic_fall : 0.648; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.822; + intrinsic_fall : 0.613; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.493; + intrinsic_fall : 0.715; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.594; + intrinsic_fall : 0.677; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.464; + intrinsic_fall : 0.673; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.379; + intrinsic_fall : 0.714; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i5"; + } + } + } + cell (oa3ao322_x2) { + area : 3.7 /* pitchs */ + cell_footprint : "oa3ao322"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i3) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i4) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i5) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i6) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0*i1*i2)+(i6*((i3+i4)+i5))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.638; + intrinsic_fall : 0.820; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.735; + intrinsic_fall : 0.764; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.806; + intrinsic_fall : 0.707; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.560; + intrinsic_fall : 0.765; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.649; + intrinsic_fall : 0.760; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i4"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.734; + intrinsic_fall : 0.734; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i5"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.563; + intrinsic_fall : 0.540; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i6"; + } + } + } + cell (oa3ao322_x4) { + area : 4.0 /* pitchs */ + cell_footprint : "oa3ao322"; + pin(i0) { + direction : input; + capacitance : 0.010; + fanout_load : 0.010; + } + pin(i1) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i2) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i3) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i4) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i5) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(i6) { + direction : input; + capacitance : 0.009; + fanout_load : 0.009; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0*i1*i2)+(i6*((i3+i4)+i5))"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.717; + intrinsic_fall : 0.946; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.818; + intrinsic_fall : 0.890; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.894; + intrinsic_fall : 0.834; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.673; + intrinsic_fall : 0.898; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.758; + intrinsic_fall : 0.896; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.839; + intrinsic_fall : 0.865; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i5"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.684; + intrinsic_fall : 0.651; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i6"; + } + } + } + cell (oa2a2a2a24_x2) { + area : 5.0 /* pitchs */ + cell_footprint : "oa2a2a2a24"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i4) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i5) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i6) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i7) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(q) { + direction : output; + max_fanout : 0.163; + function : "(i0*i1)+(i2*i3)+(i4*i5)+(i6*i7)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.780; + intrinsic_fall : 0.797; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.909; + intrinsic_fall : 0.753; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.682; + intrinsic_fall : 0.856; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.803; + intrinsic_fall : 0.810; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.565; + intrinsic_fall : 0.813; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i4"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.467; + intrinsic_fall : 0.861; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i5"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.426; + intrinsic_fall : 0.748; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i6"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.346; + intrinsic_fall : 0.800; + rise_resistance : 1.790; + fall_resistance : 1.620; + related_pin : "i7"; + } + } + } + cell (oa2a2a2a24_x4) { + area : 5.3 /* pitchs */ + cell_footprint : "oa2a2a2a24"; + pin(i0) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i1) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i2) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i3) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i4) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i5) { + direction : input; + capacitance : 0.013; + fanout_load : 0.013; + } + pin(i6) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(i7) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0*i1)+(i2*i3)+(i4*i5)+(i6*i7)"; + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.823; + intrinsic_fall : 0.879; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.955; + intrinsic_fall : 0.835; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.726; + intrinsic_fall : 0.940; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i2"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.851; + intrinsic_fall : 0.895; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i3"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.619; + intrinsic_fall : 0.902; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i4"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.515; + intrinsic_fall : 0.949; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i5"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.487; + intrinsic_fall : 0.845; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i6"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.399; + intrinsic_fall : 0.895; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i7"; + } + } + } + cell (nxr2_x1) { + area : 3.0 /* pitchs */ + cell_footprint : "nxr2"; + pin(i0) { + direction : input; + capacitance : 0.021; + fanout_load : 0.021; + } + pin(i1) { + direction : input; + capacitance : 0.022; + fanout_load : 0.022; + } + pin(nq) { + direction : output; + max_fanout : 0.091; + function : "(i0' ^ i1)"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.288; + intrinsic_fall : 0.293; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.156; + intrinsic_fall : 0.327; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.366; + intrinsic_fall : 0.389; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.395; + intrinsic_fall : 0.503; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + } + } + cell (nxr2_x4) { + area : 4.0 /* pitchs */ + cell_footprint : "nxr2"; + pin(i0) { + direction : input; + capacitance : 0.020; + fanout_load : 0.020; + } + pin(i1) { + direction : input; + capacitance : 0.021; + fanout_load : 0.021; + } + pin(nq) { + direction : output; + max_fanout : 0.327; + function : "(i0' ^ i1)"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.522; + intrinsic_fall : 0.553; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.553; + intrinsic_fall : 0.542; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.469; + intrinsic_fall : 0.481; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.568; + intrinsic_fall : 0.453; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + cell (xr2_x1) { + area : 3.0 /* pitchs */ + cell_footprint : "xr2"; + pin(i0) { + direction : input; + capacitance : 0.021; + fanout_load : 0.021; + } + pin(i1) { + direction : input; + capacitance : 0.022; + fanout_load : 0.022; + } + pin(q) { + direction : output; + max_fanout : 0.091; + function : "(i0 ^ i1)"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.292; + intrinsic_fall : 0.293; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.377; + intrinsic_fall : 0.261; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.366; + intrinsic_fall : 0.389; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.405; + intrinsic_fall : 0.388; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i1"; + } + } + } + cell (xr2_x4) { + area : 4.0 /* pitchs */ + cell_footprint : "xr2"; + pin(i0) { + direction : input; + capacitance : 0.020; + fanout_load : 0.020; + } + pin(i1) { + direction : input; + capacitance : 0.021; + fanout_load : 0.021; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "(i0 ^ i1)"; + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.521; + intrinsic_fall : 0.560; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.541; + intrinsic_fall : 0.657; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.476; + intrinsic_fall : 0.480; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i0"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.357; + intrinsic_fall : 0.539; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i1"; + } + } + } + /* --------------------------------------------- */ + /* combinationnal cells part 2: Three-State */ + /* --------------------------------------------- */ + + cell (nts_x1) { + area : 2.0 /* pitchs */ + cell_footprint : "nts"; + pin(i) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(cmd) { + direction : input; + capacitance : 0.014; + fanout_load : 0.014; + } + pin(nq) { + direction : output; + max_fanout : 0.091; + function : "i'"; + three_state : "cmd'"; + timing() { + intrinsic_rise : 0.249; + intrinsic_fall : 0.041; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "cmd"; + } + timing() { + timing_type : three_state_disable; + intrinsic_rise : 0.249; + intrinsic_fall : 0.041; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "cmd"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.169; + intrinsic_fall : 0.201; + rise_resistance : 3.210; + fall_resistance : 2.850; + related_pin : "i"; + } + } + } + cell (nts_x2) { + area : 2.7 /* pitchs */ + cell_footprint : "nts"; + pin(i) { + direction : input; + capacitance : 0.028; + fanout_load : 0.028; + } + pin(cmd) { + direction : input; + capacitance : 0.018; + fanout_load : 0.018; + } + pin(nq) { + direction : output; + max_fanout : 0.182; + function : "i'"; + three_state : "cmd'"; + timing() { + intrinsic_rise : 0.330; + intrinsic_fall : 0.033; + rise_resistance : 1.600; + fall_resistance : 1.430; + related_pin : "cmd"; + } + timing() { + timing_type : three_state_disable; + intrinsic_rise : 0.330; + intrinsic_fall : 0.033; + rise_resistance : 1.600; + fall_resistance : 1.430; + related_pin : "cmd"; + } + timing() { + timing_sense : negative_unate; + intrinsic_rise : 0.167; + intrinsic_fall : 0.201; + rise_resistance : 1.600; + fall_resistance : 1.430; + related_pin : "i"; + } + } + } + cell (ts_x4) { + area : 3.3 /* pitchs */ + cell_footprint : "ts"; + pin(i) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(cmd) { + direction : input; + capacitance : 0.019; + fanout_load : 0.019; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "i"; + three_state : "cmd'"; + timing() { + intrinsic_rise : 0.492; + intrinsic_fall : 0.409; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd"; + } + timing() { + timing_type : three_state_disable; + intrinsic_rise : 0.492; + intrinsic_fall : 0.409; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "cmd"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.475; + intrinsic_fall : 0.444; + rise_resistance : 0.890; + fall_resistance : 0.810; + related_pin : "i"; + } + } + } + cell (ts_x8) { + area : 4.3 /* pitchs */ + cell_footprint : "ts"; + pin(i) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + pin(cmd) { + direction : input; + capacitance : 0.019; + fanout_load : 0.019; + } + pin(q) { + direction : output; + max_fanout : 0.647; + function : "i"; + three_state : "cmd'"; + timing() { + intrinsic_rise : 0.626; + intrinsic_fall : 0.466; + rise_resistance : 0.450; + fall_resistance : 0.400; + related_pin : "cmd"; + } + timing() { + timing_type : three_state_disable; + intrinsic_rise : 0.626; + intrinsic_fall : 0.466; + rise_resistance : 0.450; + fall_resistance : 0.400; + related_pin : "cmd"; + } + timing() { + timing_sense : positive_unate; + intrinsic_rise : 0.613; + intrinsic_fall : 0.569; + rise_resistance : 0.450; + fall_resistance : 0.400; + related_pin : "i"; + } + } + } + + + /* --------------------------------------------- */ + /* Pull-Up, Pull-Down Cells */ + /* --------------------------------------------- */ + + cell (one_x0) { + area : 1.0 /* pitchs */ + cell_footprint : "one"; + pin(q) { + direction : output ; + max_fanout : 7.82796; + function : "1"; + driver_type : pull_up ; + } + } + + cell (zero_x0) { + area : 1.0 /* pitchs */ + cell_footprint : "zero"; + pin(nq) { + direction : output ; + max_fanout : 7.82796; + function : "0"; + driver_type : pull_down ; + } + } + + /* --------------------------------------------- */ + /* Sequential cells part 1 : Flip-Flops */ + /* --------------------------------------------- */ + + cell (sff1_x4) { + area : 6.0 /* pitchs */ + cell_footprint : "sff1"; + pin(i) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + timing() { + timing_type : setup_rising; + intrinsic_rise : 0.476; + intrinsic_fall : 0.585; + related_pin : "ck"; + } + timing() { + timing_type : hold_rising; + intrinsic_rise : 0.000; + intrinsic_fall : 0.000; + related_pin : "ck"; + } + } + pin(ck) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + ff("IQ","IQN") { + next_state : "i"; + clocked_on : "ck"; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "IQ"; + timing() { + timing_type : rising_edge; + intrinsic_rise : 0.500; + intrinsic_fall : 0.500; + rise_resistance : 0.890; + fall_resistance : 0.890; + related_pin : "ck"; + } + } + } + cell (sff2_x4) { + area : 8.0 /* pitchs */ + cell_footprint : "sff2"; + dont_use : false; + pin(i0) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + timing() { + timing_type : setup_rising; + intrinsic_rise : 0.666; + intrinsic_fall : 0.764; + related_pin : "ck"; + } + timing() { + timing_type : hold_rising; + intrinsic_rise : 0.000; + intrinsic_fall : 0.000; + related_pin : "ck"; + } + } + pin(i1) { + direction : input; + capacitance : 0.007; + fanout_load : 0.007; + timing() { + timing_type : setup_rising; + intrinsic_rise : 0.666; + intrinsic_fall : 0.764; + related_pin : "ck"; + } + timing() { + timing_type : hold_rising; + intrinsic_rise : 0.000; + intrinsic_fall : 0.000; + related_pin : "ck"; + } + } + pin(cmd) { + direction : input; + capacitance : 0.016; + fanout_load : 0.016; + timing() { + timing_type : setup_rising; + intrinsic_rise : 0.770; + intrinsic_fall : 0.833; + related_pin : "ck"; + } + timing() { + timing_type : hold_rising; + intrinsic_rise : 0.000; + intrinsic_fall : 0.000; + related_pin : "ck"; + } + } + pin(ck) { + direction : input; + capacitance : 0.008; + fanout_load : 0.008; + } + ff("IQ","IQN") { + next_state : "(cmd * i1) + (cmd' * i0)"; + clocked_on : "ck"; + } + pin(q) { + direction : output; + max_fanout : 0.327; + function : "IQ"; + timing() { + timing_type : rising_edge; + intrinsic_rise : 0.500; + intrinsic_fall : 0.500; + rise_resistance : 0.890; + fall_resistance : 0.890; + related_pin : "ck"; + } + } + test_cell() { + ff("IQ","IQN") { + next_state : "i0"; + clocked_on : "ck"; + } + pin(i0,ck) { + direction : input; + } + pin(i1) { + direction : input; + signal_type : test_scan_in; + } + pin(cmd) { + direction : input; + signal_type : test_scan_enable; + } + pin(q) { + direction : output; + function : "IQ"; + signal_type : test_scan_out; + } + } + } +} diff --git a/vlsisapd/src/CMakeLists.txt b/vlsisapd/src/CMakeLists.txt index cbcb357f..1edf89f1 100644 --- a/vlsisapd/src/CMakeLists.txt +++ b/vlsisapd/src/CMakeLists.txt @@ -8,3 +8,4 @@ IF(IS_DIRECTORY ${VLSISAPD_SOURCE_DIR}/src/dtr) ENDIF(IS_DIRECTORY ${VLSISAPD_SOURCE_DIR}/src/dtr) ADD_SUBDIRECTORY(bookshelf) ADD_SUBDIRECTORY(configuration) +ADD_SUBDIRECTORY(liberty) diff --git a/vlsisapd/src/liberty/CMakeLists.txt b/vlsisapd/src/liberty/CMakeLists.txt new file mode 100644 index 00000000..4b7537b5 --- /dev/null +++ b/vlsisapd/src/liberty/CMakeLists.txt @@ -0,0 +1 @@ +ADD_SUBDIRECTORY(src) diff --git a/vlsisapd/src/liberty/src/Attribute.cpp b/vlsisapd/src/liberty/src/Attribute.cpp new file mode 100644 index 00000000..318170a3 --- /dev/null +++ b/vlsisapd/src/liberty/src/Attribute.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Attribute.h" + +namespace LIB { +Attribute::Attribute(const Name name, Type type, const std::string& value, const std::string& unit, const std::string& value2) : _name (name), _type(type), _value(value), _unit(unit), _value2(value2) {}; + +bool Attribute::valueAsBool() const { + if ( _type != Bool ) + cerr << "[ERROR] Accessing parameter " << _name.getString() << " (type mismatch)." << endl; + + istringstream s ( _value ); + bool b; + s >> boolalpha >> b; + return b; +} + +int Attribute::valueAsInt() const { + if ( _type != Int ) + cerr << "[ERROR] Accessing parameter " << _name.getString() << " (type mismatch)." << endl; + + istringstream s ( _value ); + int i; + s >> i; + return i; +} + +double Attribute::valueAsDouble() const { + if ( (_type != Double) & (_type != Pair) ) + cerr << "[ERROR] Accessing parameter " << _name.getString() << " (type mismatch)." << endl; + + std::istringstream s ( _value ); + double d; + s >> d; + return d; +} + +double Attribute::secondValueAsDouble() const { + if ( _type != Pair ) + cerr << "[ERROR] Accessing parameter " << _name.getString() << " (type mismatch)." << endl; + + double d; + if(!_value2.empty()) + { + std::istringstream s ( _value2 ); + s >> d; + } else { + d = 0; + } + return d; +} + +string Attribute::typeToString(Attribute::Type type) { + switch(type) { + case Unknown: return "unknown"; + case String: return "string"; + case Bool: return "bool"; + case Int: return "int"; + case Double: return "double"; + case Unit: return "unit"; + case Pair: return "pair"; + } + return "unsupported"; +} + +bool Attribute::write(ofstream &file) { + if( (_type == Attribute::String) | (_type == Attribute::Double) ) { + if( (_name.getString() == "cell_footprint") | (_name.getString() == "function") | (_name.getString() == "related_pin") | (_name.getString() == "clocked_on") | (_name.getString() == "next_state")) + file << _name.getString() << " : \"" << _value << "\";" << endl; + else + file << _name.getString() << " : " << _value << ";" << endl; + } else if(_type == Attribute::Unit) { + if( (_name.getString() == "capacitive_load_unit")) + file << _name.getString() << "(" << _value << "," << _unit << ");" << endl; + else + file << _name.getString() << " : \"" << _value << _unit << "\";" << endl; + } else if(_type == Attribute::Pair) { + file << _name.getString() << "(" << _value << "," << _value2 << ");" << endl; + } + + return true; +} +} // namespace diff --git a/vlsisapd/src/liberty/src/CMakeLists.txt b/vlsisapd/src/liberty/src/CMakeLists.txt new file mode 100644 index 00000000..30cfe9ca --- /dev/null +++ b/vlsisapd/src/liberty/src/CMakeLists.txt @@ -0,0 +1,63 @@ + + include_directories ( ${VLSISAPD_SOURCE_DIR}/src/liberty/src + ${PYTHON_INCLUDE_PATH} + ${Boost_INCLUDE_DIRS} + ) + + set ( includes vlsisapd/liberty/Attribute.h + vlsisapd/liberty/Cell.h + vlsisapd/liberty/FlipFlop.h + vlsisapd/liberty/Library.h + vlsisapd/liberty/Name.h + vlsisapd/liberty/Pin.h + vlsisapd/liberty/Timing.h + vlsisapd/liberty/WireLoad.h + vlsisapd/liberty/WireLoadArea.h + vlsisapd/liberty/WireLoadSelection.h + ) + set ( cpps Attribute.cpp + Cell.cpp + FlipFlop.cpp + Library.cpp + Name.cpp + Pin.cpp + Timing.cpp + WireLoad.cpp + WireLoadArea.cpp + WireLoadSelection.cpp + ) + set ( LibertyParserScanner ${VLSISAPD_SOURCE_DIR}/src/liberty/src/LibertyParserScanner.ll ) + set ( LibertyParserGrammar ${VLSISAPD_SOURCE_DIR}/src/liberty/src/LibertyParserGrammar.yy ) + set ( LibertyParserScannerCpp LibertyParserScanner.cpp ) + set ( LibertyParserGrammarCpp LibertyParserGrammar.cpp ) + add_custom_target ( LibertyParser echo "Creating Liberty parser" ) + add_custom_command ( SOURCE ${LibertyParserScanner} + COMMAND ${FLEX_EXECUTABLE} + ARGS -PLiberty_ -o${LibertyParserScannerCpp} ${LibertyParserScanner} + TARGET LibertyParser + OUTPUTS ${LibertyParserScannerCpp} + ) + add_custom_command ( SOURCE ${LibertyParserGrammar} + COMMAND ${BISON_EXECUTABLE} + ARGS -d -v -p Liberty_ -y ${LibertyParserGrammar} -o ${LibertyParserGrammarCpp} + TARGET LibertyParser + DEPENDS ${LibertyParserScannerCpp} + OUTPUTS ${LibertyParserGrammarCpp} + ) + set ( liberty_parser_cpps ${LibertyParserScannerCpp} + ${LibertyParserGrammarCpp} + ) + set_source_files_properties ( ${LibertyParserScannerCpp} GENERATED ) + set_source_files_properties ( ${LibertyParserGrammarCpp} GENERATED ) + + + add_library ( liberty ${cpps} + ${liberty_parser_cpps} + ) + target_link_libraries ( liberty ${HURRICANE_PYTHON_LIBRARIES} + ${Boost_LIBRARIES} + ${PYTHON_LIBRARIES} + ) + + install ( TARGETS liberty DESTINATION lib${LIB_SUFFIX} ) + install ( FILES ${includes} DESTINATION include/vlsisapd/liberty ) diff --git a/vlsisapd/src/liberty/src/Cell.cpp b/vlsisapd/src/liberty/src/Cell.cpp new file mode 100644 index 00000000..d2ab5068 --- /dev/null +++ b/vlsisapd/src/liberty/src/Cell.cpp @@ -0,0 +1,103 @@ +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/Cell.h" +#include "vlsisapd/liberty/Pin.h" +#include "vlsisapd/liberty/FlipFlop.h" + +namespace LIB { +Cell::Cell(Name name): _name(name), _attributes(), _pins(), _ff(NULL), _test_cell(NULL) {}; + +Pin* Cell::getPin(Name pinName) { + Pin* pin = NULL; + map::iterator it = _pins.find(pinName); + if (it == _pins.end()) { + cerr << "[ERROR] Cell " << _name.getString() << " has no pin named " << pinName.getString() << endl; + exit(1); + } + pin= (*it).second; + return pin; +} + +void Cell::addAttribute(Name attrName, Attribute::Type attrType, string& attrValue) { + Attribute* attr = new Attribute(attrName, attrType, attrValue); + map::iterator it = _attributes.find(attrName); + if (it != _attributes.end()) { + cerr << "[ERROR] Cannot define two Cells's attributes with the same name: " << attrName.getString() << endl; + exit(1); + } + _attributes[attrName] = attr; +} + +void Cell::addPin(Name pinName) { + Pin* pin = new Pin(pinName); + map::iterator it = _pins.find(pinName); + if (it != _pins.end()) { + cerr << "[ERROR] Cannot define two Cells's pins with the same name: " << _name.getString() << " -> " << pinName.getString() << endl; + exit(1); + } + _pins[pinName] = pin; +} + +void Cell::addFF(Name noninverting, Name inverting) { + FlipFlop* flipflop = new FlipFlop(noninverting, inverting); + _ff = flipflop; +} + +void Cell::setTestCell(Cell *cell) { + _test_cell = cell; +} + +void Cell::print() { + cout << "| Cell name= " << _name.getString() << endl; + + // Cell's attributes + cout << "| Attributes :" << endl; + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + cout << "| name= " << (*it).first.getString() + << ", type= " << (*it).second->typeToString((*it).second->getType()) + << ", value= " << (*it).second->valueAsString() << endl; + } + // Cell's pins + for(map::const_iterator it=_pins.begin() ; it!=_pins.end() ; ++it) { + (*it).second->print(); + } + // FF + if(_ff) + _ff->print(); + // test_cell + if(_test_cell) + _test_cell->print(); +} + +bool Cell::write(ofstream &file, bool test) { + if(_name.getString()=="test_cell") { + if(test==false) + return true; + else + file << " test_cell () {" << endl; + } else { + file << " cell (" << _name.getString() << ") {" << endl; + } + // Cell's attributes + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + file << " "; + (*it).second->write(file); + } + // Cell's pin + for(map::const_iterator it=_pins.begin() ; it!=_pins.end() ; ++it) { + (*it).second->write(file); + } + // FF + if(_ff) + _ff->write(file); + // test_cell + if(_test_cell) + _test_cell->write(file, true); + file << " }" << endl; + return true; +} +} // namespace diff --git a/vlsisapd/src/liberty/src/FlipFlop.cpp b/vlsisapd/src/liberty/src/FlipFlop.cpp new file mode 100644 index 00000000..4e6b9dad --- /dev/null +++ b/vlsisapd/src/liberty/src/FlipFlop.cpp @@ -0,0 +1,44 @@ +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/FlipFlop.h" + +namespace LIB { +FlipFlop::FlipFlop(Name noninverting, Name inverting): _noninverting(noninverting), _inverting(inverting), _attributes() {}; + +void FlipFlop::addAttribute(Name attrName, Attribute::Type attrType, string& attrValue) { + Attribute* attr = new Attribute(attrName, attrType, attrValue); + map::iterator it = _attributes.find(attrName); + if (it != _attributes.end()) { + cerr << "[ERROR] Cannot define FlipFlop with several attributes with the same name: " << attrName.getString() << endl; + exit(1); + } + _attributes[attrName] = attr; +} + +void FlipFlop::print() { + cout << "| FF noninverting= " << _noninverting.getString() << ", inverting= " << _inverting.getString() << endl; + + // FlipFlop's attributes + cout << "| Attributes :" << endl; + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + cout << "| name= " << (*it).first.getString() + << ", type= " << (*it).second->typeToString((*it).second->getType()) + << ", value= " << (*it).second->valueAsString() << endl; + } +} + +bool FlipFlop::write(ofstream &file) { + file << " ff(\"" << _noninverting.getString() << "\",\"" << _inverting.getString() << "\") {" << endl; + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + file << " "; + (*it).second->write(file); + } + file << " }" << endl; + return true; +} + +} // namespace diff --git a/vlsisapd/src/liberty/src/LibertyParserGrammar.yy b/vlsisapd/src/liberty/src/LibertyParserGrammar.yy new file mode 100644 index 00000000..27f55e20 --- /dev/null +++ b/vlsisapd/src/liberty/src/LibertyParserGrammar.yy @@ -0,0 +1,489 @@ +%{ +#include +#include +#include +using namespace std; +#include +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Library.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/Timing.h" +using namespace LIB; + +int Liberty_error ( const char* message ); +extern int Liberty_lex (); +extern FILE* Liberty_in; +extern int Liberty_lineno; + +static Library* library = NULL; +Name currentWireLoad = ""; +Name currentCell = ""; +vector listPins; +static Timing* currentTiming = NULL; + +string intToString(int d) { + ostringstream oss; + oss << d; + return oss.str(); +} + +string doubleToString(double d) { + ostringstream oss; + oss << d; + return oss.str(); +} + +%} + +%union { + double _value; + const char* _text; +} + +%token LIBRARY +%token DATE REVISION +%token DEFAULT_INOUT_PIN_CAP DEFAULT_INOUT_PIN_FALL_RES DEFAULT_INOUT_PIN_RISE_RES DEFAULT_INPUT_PIN_CAP DEFAULT_INTRINSIC_FALL DEFAULT_INTRINSIC_RISE DEFAULT_OUTPUT_PIN_CAP DEFAULT_OUTPUT_PIN_FALL_RES DEFAULT_OUTPUT_PIN_RISE_RES DEFAULT_SLOPE_FALL DEFAULT_SLOPE_RISE DEFAULT_FANOUT_LOAD DEFAULT_MAX_FANOUT DEFAULT_WIRE_LOAD_CAPACITANCE DEFAULT_WIRE_LOAD_RESISTANCE DEFAULT_WIRE_LOAD_AREA DEFAULT_WIRE_LOAD_MODE +%token K_PROCESS_DRIVE_FALL K_PROCESS_DRIVE_RISE K_PROCESS_INTRINSIC_FALL K_PROCESS_INTRINSIC_RISE K_PROCESS_PIN_CAP K_PROCESS_SLOPE_FALL K_PROCESS_SLOPE_RISE K_PROCESS_WIRE_CAP K_PROCESS_WIRE_RES K_TEMP_DRIVE_FALL K_TEMP_DRIVE_RISE K_TEMP_INTRINSIC_FALL K_TEMP_INTRINSIC_RISE K_TEMP_PIN_CAP K_TEMP_SLOPE_FALL K_TEMP_SLOPE_RISE K_TEMP_WIRE_CAP K_TEMP_WIRE_RES K_VOLT_DRIVE_FALL K_VOLT_DRIVE_RISE K_VOLT_INTRINSIC_FALL K_VOLT_INTRINSIC_RISE K_VOLT_PIN_CAP K_VOLT_SLOPE_FALL K_VOLT_SLOPE_RISE K_VOLT_WIRE_CAP K_VOLT_WIRE_RES +%token TIME_UNIT VOLTAGE_UNIT CURRENT_UNIT PULLING_RESISTANCE_UNIT CAPACITIVE_LOAD_UNIT +%token NOM_PROCESS NOM_TEMPERATURE NOM_VOLTAGE IN_PLACE_SWAP_MODE + +// wire_load +%token WIRE_LOAD +%token RESISTANCE CAPACITANCE AREA SLOPE FANOUT_LENGTH +%token WIRE_LOAD_SELECTION WIRE_LOAD_FROM_AREA +%token DEFAULT_WIRE_LOAD_SELECTION + +// cell +%token CELL +%token CELL_FOOTPRINT DONT_USE // AREA already done +// cell::pin +%token PIN +%token DIRECTION +%token FANOUT_LOAD // CAPACITANCE already done +%token MAX_FANOUT FUNCTION THREE_STATE +%token DRIVER_TYPE +// cell::pin::timing +%token TIMING +%token TIMING_SENSE TIMING_TYPE INTRINSIC_RISE INTRINSIC_FALL RISE_RESISTANCE FALL_RESISTANCE RELATED_PIN +// cell::ff +%token FF NEXT_STATE CLOCKED_ON +// text_cell +%token TEST_CELL SIGNAL_TYPE + +// values +%token INTEGER FLOAT +%token STRING_NAME STRING_DATE STRING_UNIT STRING_FUNCTION STRING_FF + +%type<_value> INTEGER FLOAT +%type<_text> STRING_NAME STRING_DATE STRING_UNIT STRING_FUNCTION STRING_FF + +%debug + +%% + +file + : library_header '{' library_content '}' + ; + +library_header + : LIBRARY '(' STRING_NAME ')' { library = new Library ( Name($3) ); } + ; + +library_content + : // empty + | library_item library_content + ; + +library_item + : DATE ':' '"' STRING_DATE '"' ';' { /*cerr << " ° Date is : " << $4 << endl;*/ } + | REVISION ':' FLOAT ';' { /*cerr << " ° Revision is : " << $3 << endl;*/ } + | library_default + | library_wire_load + | library_wire_load_selection + | library_cell + ; + +library_default + : DEFAULT_INOUT_PIN_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_inout_pin_cap"), Attribute::Double, value); } + | DEFAULT_INOUT_PIN_FALL_RES ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_inout_pin_fall_res"), Attribute::Double, value); } + | DEFAULT_INOUT_PIN_RISE_RES ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_inout_pin_rise_res"), Attribute::Double, value); } + | DEFAULT_INPUT_PIN_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_input_pin_cap"), Attribute::Double, value); } + | DEFAULT_INTRINSIC_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_intrinsic_fall"), Attribute::Double, value); } + | DEFAULT_INTRINSIC_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_intrinsic_rise"), Attribute::Double, value); } + | DEFAULT_OUTPUT_PIN_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_output_pin_cap"), Attribute::Double, value); } + | DEFAULT_OUTPUT_PIN_FALL_RES ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_output_pin_fall_res"), Attribute::Double, value); } + | DEFAULT_OUTPUT_PIN_RISE_RES ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_output_pin_rise_res"), Attribute::Double, value); } + | DEFAULT_SLOPE_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_slope_fall"), Attribute::Double, value); } + | DEFAULT_SLOPE_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_slope_rise"), Attribute::Double, value); } + | DEFAULT_FANOUT_LOAD ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_fanout_load"), Attribute::Double, value); } + | DEFAULT_MAX_FANOUT ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_max_fanout"), Attribute::Double, value); } + | DEFAULT_WIRE_LOAD_CAPACITANCE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_wire_load_capacitance"), Attribute::Double, value); } + | DEFAULT_WIRE_LOAD_RESISTANCE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_wire_load_resistance"), Attribute::Double, value); } + | DEFAULT_WIRE_LOAD_AREA ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("default_wire_load_area"), Attribute::Double, value); } + | K_PROCESS_DRIVE_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_drive_fall"), Attribute::Double, value); } + | K_PROCESS_DRIVE_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_drive_rise"), Attribute::Double, value); } + | K_PROCESS_INTRINSIC_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_intrinsic_fall"), Attribute::Double, value); } + | K_PROCESS_INTRINSIC_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_intrinsic_rise"), Attribute::Double, value); } + | K_PROCESS_PIN_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_pin_cap"), Attribute::Double, value); } + | K_PROCESS_SLOPE_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_slope_fall"), Attribute::Double, value); } + | K_PROCESS_SLOPE_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_slope_rise"), Attribute::Double, value); } + | K_PROCESS_WIRE_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_wire_cap"), Attribute::Double, value); } + | K_PROCESS_WIRE_RES ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_process_wire_res"), Attribute::Double, value); } + | K_TEMP_DRIVE_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_drive_fall"), Attribute::Double, value); } + | K_TEMP_DRIVE_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_drive_rise"), Attribute::Double, value); } + | K_TEMP_INTRINSIC_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_intrinsic_fall"), Attribute::Double, value); } + | K_TEMP_INTRINSIC_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_intrinsic_rise"), Attribute::Double, value); } + | K_TEMP_PIN_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_pin_cap"), Attribute::Double, value); } + | K_TEMP_SLOPE_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_slope_fall"), Attribute::Double, value); } + | K_TEMP_SLOPE_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_slope_rise"), Attribute::Double, value); } + | K_TEMP_WIRE_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_wire_cap"), Attribute::Double, value); } + | K_TEMP_WIRE_RES ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_temp_wire_res"), Attribute::Double, value); } + | K_VOLT_DRIVE_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_drive_fall"), Attribute::Double, value); } + | K_VOLT_DRIVE_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_drive_rise"), Attribute::Double, value); } + | K_VOLT_INTRINSIC_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_intrinsic_fall"), Attribute::Double, value); } + | K_VOLT_INTRINSIC_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_intrinsic_rise"), Attribute::Double, value); } + | K_VOLT_PIN_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_pin_cap"), Attribute::Double, value); } + | K_VOLT_SLOPE_FALL ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_slop_fall"), Attribute::Double, value); } + | K_VOLT_SLOPE_RISE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_slop_rise"), Attribute::Double, value); } + | K_VOLT_WIRE_CAP ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_wire_cap"), Attribute::Double, value); } + | K_VOLT_WIRE_RES ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("k_volt_wire_res"), Attribute::Double, value); } + | NOM_PROCESS ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("nom_process"), Attribute::Double, value); } + | NOM_TEMPERATURE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("nom_temperature"), Attribute::Double, value); } + | NOM_VOLTAGE ':' FLOAT ';' { string value=doubleToString($3); library->addAttribute(Name("nom_voltage"), Attribute::Double, value); } + | DEFAULT_WIRE_LOAD_SELECTION ':' STRING_NAME { string value=$3; library->addAttribute(Name("default_wire_load_selection"), Attribute::String, value); } + | DEFAULT_WIRE_LOAD_MODE ':' STRING_NAME ';' { + string value=$3; + if ( (value != "top") & (value != "segmented") & (value != "enclosed") ) { + cerr << "[Liberty PARSE ERROR] Invalid value for default_wire_load_mode parameter. Valid values are top, segmented and enclosed." << endl; + exit(1); + } + library->addAttribute(Name("default_wire_load_mode"), Attribute::String, value); + } + | TIME_UNIT ':' '"' STRING_UNIT '"' ';' { + string chaine=$4; + boost::regex expression("([0-1]+)([pn]s)"); + boost::cmatch match; + string value, unit; + if(boost::regex_match(chaine.c_str(), match, expression)) { + value=match[1]; + unit=match[2]; + } else { + cerr << "[Liberty PARSE ERROR] Invalid value for time_unit parameter. Valid values are 1ps, 10ps, 100ps, and 1ns." << endl; + exit(1); + } + library->addAttribute(Name("time_unit"), Attribute::Unit, value, unit); + } + | VOLTAGE_UNIT ':' '"' STRING_UNIT '"' ';' { + string chaine=$4; + boost::regex expression("([0-1]+)([m]?V)"); + boost::cmatch match; + string value, unit; + if(boost::regex_match(chaine.c_str(), match, expression)) { + value=match[1]; + unit=match[2]; + } else { + cerr << "[Liberty PARSE ERROR] Invalid value for voltage_unit parameter. Valid values are 1mV, 10mV, 100mV, and 1V." << endl; + exit(1); + } + library->addAttribute(Name("voltage_unit"), Attribute::Unit, value, unit); + } + | CURRENT_UNIT ':' '"' STRING_UNIT '"' ';' { + string chaine=$4; + boost::regex expression("([0-1]+)([um]?A)"); + boost::cmatch match; + string value, unit; + if(boost::regex_match(chaine.c_str(), match, expression)) { + value=match[1]; + unit=match[2]; + } else { + cerr << "[Liberty PARSE ERROR] Invalid value for current_unit parameter. Valid values are 1uA, 10uA, 100uA, 1mA, 10mA, 100mA, and 1A." << endl; + exit(1); + } + library->addAttribute(Name("current_unit"), Attribute::Unit, value, unit); + } + | PULLING_RESISTANCE_UNIT ':' '"' STRING_UNIT '"' ';' { + string chaine=$4; + boost::regex expression("([0-1]+)([k]?ohm)"); + boost::cmatch match; + string value, unit; + if(boost::regex_match(chaine.c_str(), match, expression)) { + value=match[1]; + unit=match[2]; + } else { + cerr << "[Liberty PARSE ERROR] Invalid value for pulling_resistance_unit parameter. Valid values are 1ohm, 10ohm, 100ohm, and 1kohm." << endl; + exit(1); + } + library->addAttribute(Name("pulling_resistance_unit"), Attribute::Unit, value, unit); + } + | IN_PLACE_SWAP_MODE ':' STRING_NAME ';' { + string value=$3; + if ( (value != "match_footprint") & (value != "no_swapping") ) { + cerr << "[Liberty PARSE ERROR] Invalid value for pulling_resistance_unit parameter. Valid values are match_footprint and no_swapping." << endl; + exit(1); + } + library->addAttribute(Name("in_place_swap_mode"), Attribute::String, value); + } + | CAPACITIVE_LOAD_UNIT '(' FLOAT ',' STRING_NAME ')' ';' { string value=doubleToString($3), unit=$5; library->addAttribute(Name("capacitive_load_unit"), Attribute::Unit, value, unit); } + ; + +library_wire_load + : wire_header '{' wire_content '}' + ; + +wire_header + : WIRE_LOAD '(' '"' STRING_NAME '"' ')' { currentWireLoad=Name($4); library->addWireLoad(currentWireLoad); } + ; + +wire_content + : // empty + | wire_item wire_content + ; + +wire_item + : RESISTANCE ':' FLOAT ';' { string value=doubleToString($3); library->getWireLoad(currentWireLoad)->addAttribute(Name("resistance"), Attribute::Double, value); } + | CAPACITANCE ':' FLOAT ';' { string value=doubleToString($3); library->getWireLoad(currentWireLoad)->addAttribute(Name("capacitance"), Attribute::Double, value); } + | AREA ':' FLOAT ';' { string value=doubleToString($3); library->getWireLoad(currentWireLoad)->addAttribute(Name("area"), Attribute::Double, value); } + | SLOPE ':' FLOAT ';' { string value=doubleToString($3); library->getWireLoad(currentWireLoad)->addAttribute(Name("slope"), Attribute::Double, value); } + | FANOUT_LENGTH '(' FLOAT ',' FLOAT ')' ';' { string value1=doubleToString($3), value2=doubleToString($5); library->getWireLoad(currentWireLoad)->addAttribute(Name("fanout_length"), Attribute::Pair, value1, value2); } + ; + +library_wire_load_selection + : wire_selection_header '{' wire_selection_content '}' + ; + +wire_selection_header + : WIRE_LOAD_SELECTION '(' STRING_NAME ')' { library->addWireLoadSelection(Name($3)); } + ; + +wire_selection_content + : // empty + | wire_selection_item wire_selection_content + ; + +wire_selection_item + : WIRE_LOAD_FROM_AREA '(' FLOAT ',' FLOAT ',' '"' STRING_NAME '"' ')' ';' + { + double value1=$3, value2=$5; + string name=$8; + library->getWireLoadSelection()->addWireLoadArea(value1, value2, Name(name)); + } + ; + +library_cell + : cell_header '{' cell_content '}' + ; + +cell_header + : CELL '(' STRING_NAME ')' { currentCell = Name($3); library->addCell(currentCell); } + ; + +cell_content + : // empty + | cell_item cell_content + ; + +cell_item + : AREA ':' FLOAT { /* TODO ; a la fin optionnel ? pour tous en fait ... */string value=doubleToString($3); library->getCell(currentCell)->addAttribute(Name("area"), Attribute::Double, value); } + | CELL_FOOTPRINT ':' '"' STRING_NAME '"' ';' { string value=$4; library->getCell(currentCell)->addAttribute(Name("cell_footprint"), Attribute::String, value); } + | DONT_USE ':' STRING_NAME ';' { string value=$3; library->getCell(currentCell)->addAttribute(Name("dont_use"), Attribute::String, value); } + | test_cell_header '{' cell_content '}' + | pin_header '{' pin_content '}' { listPins.clear(); } + | ff_header '{' ff_content '}' + ; + +test_cell_header + : TEST_CELL '(' ')' + { + Name oldCell = currentCell; + currentCell = Name("test_cell"); + library->addCell(currentCell); + library->getCell(oldCell)->setTestCell(library->getCell(currentCell)); + } + ; + +pin_header + : PIN '(' pin_list ')' + ; + +pin_list + : STRING_NAME { listPins.push_back(Name($1)); library->getCell(currentCell)->addPin(Name($1)); } + | pin_list ',' STRING_NAME { listPins.push_back(Name($3)); library->getCell(currentCell)->addPin(Name($3)); } + ; + +pin_content + : // empty + | pin_item pin_content + ; + +pin_item + : CAPACITANCE ':' FLOAT ';' + { + string value=doubleToString($3); + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("capacitance"), Attribute::Double, value); + } + | FANOUT_LOAD ':' FLOAT ';' + { + string value=doubleToString($3); + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("fanout_load"), Attribute::Double, value); + } + | MAX_FANOUT ':' FLOAT ';' + { + string value=doubleToString($3); + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("max_fanout"), Attribute::Double, value); + } + | THREE_STATE ':' '"' STRING_FUNCTION '"' ';' + { + string value=$4; + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("three_state"), Attribute::String, value); + } + | DRIVER_TYPE ':' STRING_NAME ';' + { + string value=$3; + if ( (value != "pull_up") & (value != "pull_down") ) { + cerr << "[Liberty PARSE ERROR] Invalid value for driver_type parameter. Valid values are pull_up and pull_down." << endl; + exit(1); + } + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("driver_type"), Attribute::String, value); + } + | FUNCTION ':' '"' STRING_FUNCTION '"' ';' + { + string value=$4; + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("function"), Attribute::String, value); + } + | FUNCTION ':' '"' STRING_NAME '"' ';' + { + /* STRING_NAME matched in case of a buffer */ + string value=$4; + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("function"), Attribute::String, value); + } + | FUNCTION ':' '"' FLOAT '"' ';' + { + /* FLOAT matched in case of one and zero */ + string value=doubleToString($4); + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("function"), Attribute::String, value); + } + | DIRECTION ':' STRING_NAME ';' + { + string value=$3; + if ( (value != "input") & (value != "output") ) { + cerr << "[Liberty PARSE ERROR] Invalid value for direction parameter. Valid values are input and output." << endl; + exit(1); + } + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("direction"), Attribute::String, value); + } + | SIGNAL_TYPE ':' STRING_NAME ';' { + string value=$3; + if ( (value != "test_scan_in") & (value != "test_scan_in_inverted") & (value != "test_scan_out") & (value != "test_scan_out_inverted") & (value != "test_scan_enable") & (value != "test_scan_enable_inverted") & (value != "test_scan_clock") & (value != "test_scan_clock_a") & (value != "test_scan_clock_b") & (value != "test_clock") ) { + cerr << "[Liberty PARSE ERROR] Invalid value for signal_type parameter. Valid values are test_scan_in, test_scan_in_inverted, test_scan_out, test_scan_out_inverted, test_scan_enable, test_scan_enable_inverted, test_scan_clock, test_scan_clock_a, test_scan_clock_b and test_clock." << endl; + exit(1); + } + Cell* cell = library->getCell(currentCell); + for (size_t i = 0 ; i < listPins.size() ; i++) + cell->getPin(listPins[i])->addAttribute(Name("signal_type"), Attribute::String, value); + } + | timing_header '{' timing_content '}' + ; + +timing_header + : TIMING '(' ')' + { + library->getCell(currentCell)->getPin(listPins.back())->addTiming(); + currentTiming=library->getCell(currentCell)->getPin(listPins.back())->getTiming().back(); + // only for 1 pin, not available for pins' list + if(listPins.size()>1) + cerr << "[Warning] timing information for a list of pins, not available." << endl; + } + ; + +timing_content + : // empty + | timing_item timing_content + ; + +timing_item + : INTRINSIC_RISE ':' FLOAT ';' { string value=doubleToString($3); currentTiming->addAttribute(Name("intrinsic_rise"), Attribute::Double, value); } + | INTRINSIC_FALL ':' FLOAT ';' { string value=doubleToString($3); currentTiming->addAttribute(Name("intrinsic_fall"), Attribute::Double, value); } + | RISE_RESISTANCE ':' FLOAT ';' { string value=doubleToString($3); currentTiming->addAttribute(Name("rise_resistance"), Attribute::Double, value); } + | FALL_RESISTANCE ':' FLOAT ';' { string value=doubleToString($3); currentTiming->addAttribute(Name("fall_resistance"), Attribute::Double, value); } + | TIMING_SENSE ':' STRING_NAME ';' { string value=$3; currentTiming->addAttribute(Name("timing_sense"), Attribute::String, value); } + | TIMING_TYPE ':' STRING_NAME ';' { string value=$3; currentTiming->addAttribute(Name("timing_type"), Attribute::String, value); } + | RELATED_PIN ':' '"' STRING_NAME '"' ';' { string value=$4; currentTiming->addAttribute(Name("related_pin"), Attribute::String, value); } + ; + +ff_header + : FF '(' STRING_FF ')' + { + string chaine=$3; + boost::regex expression("\"?([A-Z]+)\"?,\"?([A-Z]+)\"?"); + boost::cmatch match; + string value1, value2; + if(boost::regex_match(chaine.c_str(), match, expression)) { + value1=match[1]; + value2=match[2]; + } else { + cerr << "[Liberty PARSE ERROR] Invalid syntax for ff group." << endl; + exit(1); + } + library->getCell(currentCell)->addFF(Name(value1), Name(value2)); + } + ; + +ff_content + : // empty + | ff_item ff_content + ; + +ff_item + : NEXT_STATE ':' '"' STRING_FUNCTION '"' ';' { string value=$4; library->getCell(currentCell)->getFF()->addAttribute(Name("next_state"), Attribute::String, value); } + | NEXT_STATE ':' '"' STRING_NAME '"' ';' { string value=$4; library->getCell(currentCell)->getFF()->addAttribute(Name("next_state"), Attribute::String, value); /* STRING_NAME matched in case of a buffer */ } + | CLOCKED_ON ':' '"' STRING_NAME '"' ';' { string value=$4; library->getCell(currentCell)->getFF()->addAttribute(Name("clocked_on"), Attribute::String, value); } + ; + +%% + +int Liberty_error ( const char* message ) +// *************************************** +{ + cerr << endl << "libertyParser(): " << message << " at line " << Liberty_lineno << endl << endl; + return 1; +} + +void read ( std::string fileName ) +// ******************************* +{ + const char* fileC = fileName.c_str (); + Liberty_in = fopen ( fileC, "r" ); + if ( !Liberty_in ) { + cerr << "libertyParser(): no file found with the name " << fileC << "."; + } + yyparse (); +} + +namespace LIB{ +Library* Library::readFromFile ( std::string fileName ) +// **************************************************** +{ + read ( fileName ); + return library; +} +} // namespace diff --git a/vlsisapd/src/liberty/src/LibertyParserScanner.ll b/vlsisapd/src/liberty/src/LibertyParserScanner.ll new file mode 100644 index 00000000..ad9095d6 --- /dev/null +++ b/vlsisapd/src/liberty/src/LibertyParserScanner.ll @@ -0,0 +1,175 @@ + +%{ + +#include +#include + +#include "LibertyParserGrammar.hpp" + +static double floatToken; +static std::string nameToken; + +extern int yylineno; + +%} + +%x COMM + +SPACE [ \t] +UPPER_CASE_LETTER [A-Z] +LOWER_CASE_LETTER [a-z] +DIGIT [0-9] +OPERATION [\*\+\^] + +INTEGER {DIGIT}+ +FLOAT {DIGIT}+(\.{DIGIT}+)* +LETTER {UPPER_CASE_LETTER}|{LOWER_CASE_LETTER} +ALPHA_NUM {LETTER}+{DIGIT}* + +STRING_NAME {ALPHA_NUM}+(_{ALPHA_NUM})* + +HOUR {DIGIT}+:{DIGIT}+:{DIGIT}+ +STRING_DATE {LETTER}+{SPACE}+{LETTER}+{SPACE}+{DIGIT}+{SPACE}+{HOUR}{SPACE}+MET{SPACE}+{DIGIT}+ + +STRING_UNIT {DIGIT}+{LETTER}+ + +OPERATION_SPACED {SPACE}*{OPERATION}{SPACE}* +FUNCTION1 {ALPHA_NUM}'? +FUNCTION2 (\()?{FUNCTION1}{OPERATION_SPACED}{FUNCTION1}(\))? +FUNCTION3_1 (\()?{FUNCTION1}{OPERATION_SPACED}{FUNCTION1}{OPERATION_SPACED}*{FUNCTION1}(\))? +FUNCTION3_2 (\()?{FUNCTION2}{OPERATION_SPACED}{FUNCTION1}(\))? +FUNCTION3_3 (\()?{FUNCTION1}{OPERATION_SPACED}{FUNCTION2}(\))? +FUNCTION3 {FUNCTION3_1}|{FUNCTION3_2}|{FUNCTION3_3} +FUNCTION4_1 (\()?{FUNCTION1}{OPERATION_SPACED}{FUNCTION3}(\))? +FUNCTION4_2 (\()?{FUNCTION2}{OPERATION_SPACED}{FUNCTION2}(\))? +FUNCTION4_3 (\()?(\()?{FUNCTION2}{OPERATION_SPACED}{FUNCTION1}(\))?{OPERATION_SPACED}{FUNCTION1}(\))? +FUNCTION4 {FUNCTION4_1}|{FUNCTION4_2}|{FUNCTION4_3} +FUNCTION5 (\()?{FUNCTION2}{OPERATION_SPACED}{FUNCTION3}(\))? +FUNCTION6 (\()?{FUNCTION2}{OPERATION_SPACED}{FUNCTION2}(\))?{OPERATION_SPACED}{FUNCTION2}(\))? +FUNCTION7 (\()?{FUNCTION3}{OPERATION_SPACED}{FUNCTION4}(\))? +FUNCTION8 (\()?{FUNCTION4}{OPERATION_SPACED}{FUNCTION4}(\))? +FUNCTION_MUX3 (\()?{FUNCTION2}{OPERATION_SPACED}(\()?{FUNCTION1}{OPERATION_SPACED}{FUNCTION4}(\))?(\))? +FUNCTION_MUX {FUNCTION_MUX3} +STRING_FUNCTION {FUNCTION1}|{FUNCTION2}|{FUNCTION3}|{FUNCTION4}|{FUNCTION5}|{FUNCTION6}|{FUNCTION7}|{FUNCTION8}|{FUNCTION_MUX} + +STRING_FF [\"]?{UPPER_CASE_LETTER}+[\"]?,[\"]?{UPPER_CASE_LETTER}+[\"]? + + +%% + +{SPACE} { /* spaces : skip them */ } +\n { yylineno++; /* end of line */ } + +[ \t]+ +"/*" { BEGIN(COMM); } +. +"*/" { BEGIN(INITIAL); } +\n { yylineno++; } +\\\n { yylineno++; } + +library { return LIBRARY; } + +date { return DATE; } +revision { return REVISION; } + +default_inout_pin_cap { return DEFAULT_INOUT_PIN_CAP; } +default_inout_pin_fall_res { return DEFAULT_INOUT_PIN_FALL_RES; } +default_inout_pin_rise_res { return DEFAULT_INOUT_PIN_RISE_RES; } +default_input_pin_cap { return DEFAULT_INPUT_PIN_CAP; } +default_intrinsic_fall { return DEFAULT_INTRINSIC_FALL; } +default_intrinsic_rise { return DEFAULT_INTRINSIC_RISE; } +default_output_pin_cap { return DEFAULT_OUTPUT_PIN_CAP; } +default_output_pin_fall_res { return DEFAULT_OUTPUT_PIN_FALL_RES; } +default_output_pin_rise_res { return DEFAULT_OUTPUT_PIN_RISE_RES; } +default_slope_fall { return DEFAULT_SLOPE_FALL; } +default_slope_rise { return DEFAULT_SLOPE_RISE; } +default_fanout_load { return DEFAULT_FANOUT_LOAD; } +default_max_fanout { return DEFAULT_MAX_FANOUT; } +default_wire_load_capacitance { return DEFAULT_WIRE_LOAD_CAPACITANCE; } +default_wire_load_resistance { return DEFAULT_WIRE_LOAD_RESISTANCE; } +default_wire_load_area { return DEFAULT_WIRE_LOAD_AREA; } +default_wire_load_mode { return DEFAULT_WIRE_LOAD_MODE; } +k_process_drive_fall { return K_PROCESS_DRIVE_FALL; } +k_process_drive_rise { return K_PROCESS_DRIVE_RISE; } +k_process_intrinsic_fall { return K_PROCESS_INTRINSIC_FALL; } +k_process_intrinsic_rise { return K_PROCESS_INTRINSIC_RISE; } +k_process_pin_cap { return K_PROCESS_PIN_CAP; } +k_process_slope_fall { return K_PROCESS_SLOPE_FALL; } +k_process_slope_rise { return K_PROCESS_SLOPE_RISE; } +k_process_wire_cap { return K_PROCESS_WIRE_CAP; } +k_process_wire_res { return K_PROCESS_WIRE_RES; } +k_temp_drive_fall { return K_TEMP_DRIVE_FALL; } +k_temp_drive_rise { return K_TEMP_DRIVE_RISE; } +k_temp_intrinsic_fall { return K_TEMP_INTRINSIC_FALL; } +k_temp_intrinsic_rise { return K_TEMP_INTRINSIC_RISE; } +k_temp_pin_cap { return K_TEMP_PIN_CAP; } +k_temp_slope_fall { return K_TEMP_SLOPE_FALL; } +k_temp_slope_rise { return K_TEMP_SLOPE_RISE; } +k_temp_wire_cap { return K_TEMP_WIRE_CAP; } +k_temp_wire_res { return K_TEMP_WIRE_RES; } +k_volt_drive_fall { return K_VOLT_DRIVE_FALL; } +k_volt_drive_rise { return K_VOLT_DRIVE_RISE; } +k_volt_intrinsic_fall { return K_VOLT_INTRINSIC_FALL; } +k_volt_intrinsic_rise { return K_VOLT_INTRINSIC_RISE; } +k_volt_pin_cap { return K_VOLT_PIN_CAP; } +k_volt_slope_fall { return K_VOLT_SLOPE_FALL; } +k_volt_slope_rise { return K_VOLT_SLOPE_RISE; } +k_volt_wire_cap { return K_VOLT_WIRE_CAP; } +k_volt_wire_res { return K_VOLT_WIRE_RES; } +time_unit { return TIME_UNIT; } +voltage_unit { return VOLTAGE_UNIT; } +current_unit { return CURRENT_UNIT; } +pulling_resistance_unit { return PULLING_RESISTANCE_UNIT; } +capacitive_load_unit { return CAPACITIVE_LOAD_UNIT; } +nom_process { return NOM_PROCESS; } +nom_temperature { return NOM_TEMPERATURE; } +nom_voltage { return NOM_VOLTAGE; } +in_place_swap_mode { return IN_PLACE_SWAP_MODE; } + +wire_load { return WIRE_LOAD; } +resistance { return RESISTANCE; } +capacitance { return CAPACITANCE; } +area { return AREA; } +slope { return SLOPE; } +fanout_length { return FANOUT_LENGTH; } +wire_load_selection { return WIRE_LOAD_SELECTION; } +wire_load_from_area { return WIRE_LOAD_FROM_AREA; } +default_wire_load_selection { return DEFAULT_WIRE_LOAD_SELECTION; } + +cell { return CELL; } +cell_footprint { return CELL_FOOTPRINT; } +dont_use { return DONT_USE; } +pin { return PIN; } +direction { return DIRECTION; } +capacitance { return CAPACITANCE; } +fanout_load { return FANOUT_LOAD; } +max_fanout { return MAX_FANOUT; } +function { return FUNCTION; } +three_state { return THREE_STATE; } +driver_type { return DRIVER_TYPE; } +timing { return TIMING; } +timing_sense { return TIMING_SENSE; } +timing_type { return TIMING_TYPE; } +intrinsic_rise { return INTRINSIC_RISE; } +intrinsic_fall { return INTRINSIC_FALL; } +rise_resistance { return RISE_RESISTANCE; } +fall_resistance { return FALL_RESISTANCE; } +related_pin { return RELATED_PIN; } +ff { return FF; } +next_state { return NEXT_STATE; } +clocked_on { return CLOCKED_ON; } +test_cell { return TEST_CELL; } +signal_type { return SIGNAL_TYPE; } + +{FLOAT} { floatToken = atof(yytext); Liberty_lval._value = floatToken; return FLOAT; } +{STRING_NAME} { nameToken = yytext; Liberty_lval._text = nameToken.c_str(); return STRING_NAME; } +{STRING_DATE} { nameToken = yytext; Liberty_lval._text = nameToken.c_str(); return STRING_DATE; } +{STRING_UNIT} { nameToken = yytext; Liberty_lval._text = nameToken.c_str(); return STRING_UNIT; } +{STRING_FUNCTION} { nameToken = yytext; Liberty_lval._text = nameToken.c_str(); return STRING_FUNCTION; } +{STRING_FF} { nameToken = yytext; Liberty_lval._text = nameToken.c_str(); return STRING_FF; } + +. { /* std::cerr << "autre :" << yytext << std::endl;*/ return *yytext; /* else */ } + +%% + +int yywrap () { return 1; } diff --git a/vlsisapd/src/liberty/src/Library.cpp b/vlsisapd/src/liberty/src/Library.cpp new file mode 100644 index 00000000..5527adc3 --- /dev/null +++ b/vlsisapd/src/liberty/src/Library.cpp @@ -0,0 +1,137 @@ +#include +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/WireLoad.h" +#include "vlsisapd/liberty/WireLoadSelection.h" +#include "vlsisapd/liberty/Cell.h" +#include "vlsisapd/liberty/Library.h" + +namespace LIB { +Library::Library(Name name): _name(name), _attributes(), _wires_load(), _wire_load_selection(NULL), _cells() {}; + +Cell* Library::getCell(Name cellName) { + Cell* cell = NULL; + map::iterator it = _cells.find(cellName); + if (it == _cells.end()) { + cerr << "[ERROR] No cell named " << cellName.getString() << endl; + exit(1); + } + cell= (*it).second; + return cell; +} + +WireLoad* Library::getWireLoad(Name wireLoadName) { + WireLoad* wire = NULL; + map::iterator it = _wires_load.find(wireLoadName); + if (it == _wires_load.end()) { + cerr << "[ERROR] No wire_load named " << wireLoadName.getString() << endl; + exit(1); + } + wire= (*it).second; + return wire; +} + +void Library::addAttribute(Name attrName, Attribute::Type attrType, string& attrValue, const string& attrUnit) { + Attribute* attr = new Attribute(attrName, attrType, attrValue, attrUnit); + map::iterator it = _attributes.find(attrName); + if (it != _attributes.end()) { + cerr << "[ERROR] Cannot define two Libraries's attributes with the same name: " << attrName.getString() << endl; + exit(1); + } + _attributes[attrName] = attr; +} + +void Library::addWireLoad(Name wireLoadName) { + WireLoad* wire = new WireLoad(wireLoadName); + map::iterator it = _wires_load.find(wireLoadName); + if (it != _wires_load.end()) { + cerr << "[ERROR] Cannot define two Libraries's wire_load with the same name: " << wireLoadName.getString() << endl; + exit(1); + } + _wires_load[wireLoadName] = wire; +} + +void Library::addWireLoadSelection(Name wireLoadSelectionName) { + WireLoadSelection* wire = new WireLoadSelection(wireLoadSelectionName); + _wire_load_selection = wire; +} + +void Library::addCell(Name cellName) { + Cell* cell = new Cell(cellName); + map::iterator it = _cells.find(cellName); + if (it != _cells.end()) { + cerr << "[ERROR] Cannot define two Libraries's cells with the same name: " << cellName.getString() << endl; + exit(1); + } + _cells[cellName] = cell; +} + +void Library::print() { + cout << "+-----------------------------+" << endl + << "| Library name= " << _name.getString() << endl; + + // Library's attributes + cout << "| Attributes :" << endl; + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + cout << "| name= " << (*it).first.getString() + << ", type= " << (*it).second->typeToString((*it).second->getType()) + << ", value= " << (*it).second->valueAsString(); + string unit = (*it).second->getUnit(); + if(!unit.empty()) + cout << ", unit= " << unit; + cout << endl; + } + // WireLoad + for(map::const_iterator it=_wires_load.begin() ; it!=_wires_load.end() ; ++it) { + (*it).second->print(); + } + // WireLoadSelection + _wire_load_selection->print(); + // Cell + for(map::const_iterator it=_cells.begin() ; it!=_cells.end() ; ++it) { + (*it).second->print(); + } + cout << "+-----------------------------+" << endl; +}; + +bool Library::writeToFile(string filename) { + time_t curtime = time(0); + tm now = *localtime(&curtime); + char date[BUFSIZ]={0}; + const char format[]="%y-%m-%d %H:%M:%S"; + if (!strftime(date, sizeof(date)-1, format, &now)>0) + cerr << "[Liberty DRIVE ERROR]: cannot build current date." << endl; + + ofstream file; + file.open(filename.c_str(), ios::out); + // Header + file << "/* Generated by vlsisapd driver */" << endl + << "/* date : " << date << " */" << endl; + file << "library (" << _name.getString() << ") {" << endl; + + // Library's attributes + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + file << " "; + (*it).second->write(file); + } + // For each WireLoad : write wireload + for(map::const_iterator it=_wires_load.begin() ; it!=_wires_load.end() ; ++it) { + (*it).second->write(file); + } + // write wireloadselection + _wire_load_selection->write(file); + // for each Cell : write cell + for(map::const_iterator it=_cells.begin() ; it!=_cells.end() ; ++it) { + (*it).second->write(file); + } + // Footer + file << "}" << endl; + + file.close(); + return true; +} +} // namespace diff --git a/vlsisapd/src/liberty/src/Name.cpp b/vlsisapd/src/liberty/src/Name.cpp new file mode 100644 index 00000000..09a2977b --- /dev/null +++ b/vlsisapd/src/liberty/src/Name.cpp @@ -0,0 +1,59 @@ +using namespace std; + +#include "vlsisapd/liberty/Name.h" + +namespace LIB { +unsigned long Name::_globalId = 0; +map Name::_dict; + +Name::Name() : _str(NULL) { + map::iterator it = _dict.find(""); + if (it != _dict.end()) { + _id = (*it).second; + _str = &((*it).first); + } else { + _id = _globalId++; + it = _dict.insert(_dict.begin(), make_pair("", _id)); + _str = &((*it).first); + } +} + +Name::Name(string str) : _str(NULL) { + map::iterator it = _dict.find(str); + if (it != _dict.end()) { + _id = (*it).second; + _str = &((*it).first); + } else { + _id = _globalId++; + it = _dict.insert(_dict.begin(), make_pair(str, _id)); + _str = &((*it).first); + } +} + +Name::Name(const char* c) : _str(NULL) { + string str(c); + map::iterator it = _dict.find(str); + if (it != _dict.end()) { + _id = (*it).second; + _str = &((*it).first); + } else { + _id = _globalId++; + it = _dict.insert(_dict.begin(), make_pair(str, _id)); + _str = &((*it).first); + } +} + +bool Name::operator==(const Name& n) { + return (_id == n._id); +} + +bool Name::operator==(const string& str) { + Name n(str); + return (_id == n._id); +} +bool Name::operator<(const Name& n) const { + //return (_id < n._id); // does not assert determinism in driving since hurricane do not care about name's ID --> need an alphabetical check on string + return (*_str < n.getString()); +} +} // namespace + diff --git a/vlsisapd/src/liberty/src/Pin.cpp b/vlsisapd/src/liberty/src/Pin.cpp new file mode 100644 index 00000000..53df4f59 --- /dev/null +++ b/vlsisapd/src/liberty/src/Pin.cpp @@ -0,0 +1,57 @@ +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/Pin.h" + +namespace LIB { +Pin::Pin(Name name): _name(name), _attributes(), _timings() {}; + +void Pin::addAttribute(Name attrName, Attribute::Type attrType, string& attrValue) { + Attribute* attr = new Attribute(attrName, attrType, attrValue); + map::iterator it = _attributes.find(attrName); + if (it != _attributes.end()) { + cerr << "[ERROR] Cannot define Pin " << _name.getString() << " with several attributes with the same name: " << attrName.getString() << endl; + exit(1); + } + _attributes[attrName] = attr; +} + +void Pin::addTiming() { + Timing* timing = new Timing(); + _timings.push_back(timing); +} + +void Pin::print() { + cout << "| Pin name= " << _name.getString() << endl; + + // Pin's attributes + cout << "| Attributes :" << endl; + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + cout << "| name= " << (*it).first.getString() + << ", type= " << (*it).second->typeToString((*it).second->getType()) + << ", value= " << (*it).second->valueAsString() << endl; + } + // Timing + for (size_t i = 0 ; i < _timings.size() ; i++) { + _timings[i]->print(); + } +} + +bool Pin::write(ofstream &file) { + file << " pin(" << _name.getString() << ") {" << endl; + //Pin's attributes + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + file << " "; + (*it).second->write(file); + } + // Timing + for (size_t i = 0 ; i < _timings.size() ; i++) + _timings[i]->write(file); + file << " }" << endl; + return true; +} + +} // namespace diff --git a/vlsisapd/src/liberty/src/Timing.cpp b/vlsisapd/src/liberty/src/Timing.cpp new file mode 100644 index 00000000..0d73fae3 --- /dev/null +++ b/vlsisapd/src/liberty/src/Timing.cpp @@ -0,0 +1,43 @@ +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/Timing.h" + +namespace LIB { +Timing::Timing(): _attributes() {}; + +void Timing::addAttribute(Name attrName, Attribute::Type attrType, string& attrValue) { + Attribute* attr = new Attribute(attrName, attrType, attrValue); + map::iterator it = _attributes.find(attrName); + if (it != _attributes.end()) { + cerr << "[ERROR] Cannot define Timing with several attributes with the same name : " << attrName.getString() << endl; + exit(1); + } + _attributes[attrName] = attr; +} + +void Timing::print() { + // Timing's attributes + cout << "| Timing's attributes :" << endl; + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + cout << "| name= " << (*it).first.getString() + << ", type= " << (*it).second->typeToString((*it).second->getType()) + << ", value= " << (*it).second->valueAsString() << endl; + } +} + +bool Timing::write(ofstream &file) { + file << " timing() {" << endl; + // Timing's attributes + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + file << " "; + (*it).second->write(file); + } + file << " }" << endl; + return true; +} + +} // namespace diff --git a/vlsisapd/src/liberty/src/WireLoad.cpp b/vlsisapd/src/liberty/src/WireLoad.cpp new file mode 100644 index 00000000..780d7394 --- /dev/null +++ b/vlsisapd/src/liberty/src/WireLoad.cpp @@ -0,0 +1,49 @@ +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/WireLoad.h" + +namespace LIB { +WireLoad::WireLoad(Name name): _name(name), _attributes() {}; + +void WireLoad::addAttribute(Name attrName, Attribute::Type attrType, string& attrValue, const string& attrValue2) { + Attribute* attr = new Attribute(attrName, attrType, attrValue, "", attrValue2); + map::iterator it = _attributes.find(attrName); + if (it != _attributes.end()) { + cerr << "[ERROR] Cannot define WireLoad with several attributes with the same name : " << attrName.getString() << endl; + exit(1); + } + _attributes[attrName] = attr; +} + +void WireLoad::print() { + // WireLoad's attributes + cout << "| Wireload : " << _name.getString() << endl; + cout << "| Attributes :" << endl; + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it) { + cout << "| name= " << (*it).first.getString() + << ", type= " << (*it).second->typeToString((*it).second->getType()) + << ", value= " << (*it).second->valueAsString(); + string value2=(*it).second->secondValueAsString(); + if(!value2.empty()) + cout << ", value2= " << value2; + cout << endl; + } +} + +bool WireLoad::write(ofstream &file) { + file << " wire_load(\"" << _name.getString() << "\") {" << endl; + + for(map::const_iterator it=_attributes.begin() ; it!=_attributes.end() ; ++it ) { + file << " "; + (*it).second->write(file); + } + + file << "}" << endl; + + return true; +} +} // namespace diff --git a/vlsisapd/src/liberty/src/WireLoadArea.cpp b/vlsisapd/src/liberty/src/WireLoadArea.cpp new file mode 100644 index 00000000..0d315de9 --- /dev/null +++ b/vlsisapd/src/liberty/src/WireLoadArea.cpp @@ -0,0 +1,14 @@ +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/WireLoadArea.h" + +namespace LIB { +WireLoadArea::WireLoadArea(double min, double max, Name name): _min(min), _max(max), _name(name) {}; + +bool WireLoadArea::write(std::ofstream &file) { + file << "wire_load_from_area(" << _min << "," << _max << ",\"" << _name.getString() << "\");" << std::endl; + return true; +} + +} // namespace diff --git a/vlsisapd/src/liberty/src/WireLoadSelection.cpp b/vlsisapd/src/liberty/src/WireLoadSelection.cpp new file mode 100644 index 00000000..60d601bf --- /dev/null +++ b/vlsisapd/src/liberty/src/WireLoadSelection.cpp @@ -0,0 +1,38 @@ +#include +#include +using namespace std; + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/WireLoadSelection.h" + +namespace LIB { +WireLoadSelection::WireLoadSelection(Name name): _name(name), _wires_load_area() {}; + +void WireLoadSelection::addWireLoadArea(double min, double max, Name name) { + WireLoadArea * area = new WireLoadArea(min, max, name); + _wires_load_area.push_back(area); +} + +void WireLoadSelection::print() { + cout << "| WireLoadSection name= " << _name.getString() << endl; + for(size_t i = 0 ; i < _wires_load_area.size() ; i++) { + cout << "| wire_load_from_area name= " << _wires_load_area[i]->getName().getString() + << ", min= " << _wires_load_area[i]->getMin() + << ", max= " << _wires_load_area[i]->getMax() + << endl; + } +} + +bool WireLoadSelection::write(ofstream& file) { + file << " wire_load_selection(" << _name.getString() << ") {" << endl; + + for(size_t i = 0 ; i < _wires_load_area.size() ; i++) { + file << " "; + _wires_load_area[i]->write(file); + } + + file << "}" << endl; + + return true; +} +} // namespace diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/Attribute.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/Attribute.h new file mode 100644 index 00000000..a38f9524 --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/Attribute.h @@ -0,0 +1,50 @@ +#ifndef __LIB_ATTRIBUTE_H__ +#define __LIB_ATTRIBUTE_H__ + +#include +#include +#include "Name.h" + +namespace LIB { +class Attribute { + public: + enum Type { Unknown = 0 + , String = 1 + , Bool = 2 + , Int = 3 + , Double = 4 + , Unit = 5 + , Pair = 6 + }; + + public: + Attribute(const Name name, Type type, const std::string& value, const std::string& unit="", const std::string& value2=""); + + inline const Name getName() const; + inline const Type getType() const; + inline const std::string& getUnit() const; + + inline const std::string& valueAsString() const; + inline const std::string& secondValueAsString() const; + bool valueAsBool() const; + int valueAsInt() const; + double valueAsDouble() const; + double secondValueAsDouble() const; + std::string typeToString(Type type); + bool write(std::ofstream &file); + + private: + Name _name; + Type _type; + std::string _value; + std::string _unit; + std::string _value2; +}; + +inline const std::string& Attribute::getUnit() const { return _unit; } +inline const Name Attribute::getName() const { return _name; } +inline const Attribute::Type Attribute::getType() const { return _type; } +inline const std::string& Attribute::valueAsString() const { return _value; } +inline const std::string& Attribute::secondValueAsString() const { return _value2; } +} // namespace +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/Cell.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/Cell.h new file mode 100644 index 00000000..af6f676d --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/Cell.h @@ -0,0 +1,41 @@ +#ifndef __LIB_CELL_H__ +#define __LIB_CELL_H__ + +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/Pin.h" +#include "vlsisapd/liberty/FlipFlop.h" + +namespace LIB { + +class Cell { + public: + Cell(Name name); + + inline Name getName(); + Pin* getPin(Name pinName); + inline FlipFlop* getFF(); + + void addAttribute(Name attrName, Attribute::Type attrType, std::string& attrValue); + void addPin(Name pinName); + void addFF(Name noninverting, Name inverting); + void setTestCell(Cell *cell); + + void print(); + bool write(std::ofstream &file, bool test=false); + + private: + Name _name; + std::map _attributes; + std::map _pins; + FlipFlop* _ff; + Cell* _test_cell; +}; + +inline Name Cell::getName() { return _name; }; +inline FlipFlop* Cell::getFF() { return _ff; }; + +} // namespace LIB +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/FlipFlop.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/FlipFlop.h new file mode 100644 index 00000000..a93e7320 --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/FlipFlop.h @@ -0,0 +1,27 @@ +#ifndef __LIB_FLIP_FLOP_H__ +#define __LIB_FLIP_FLOP_H__ + +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" + +namespace LIB { + +class FlipFlop { + public: + FlipFlop(Name noninverting, Name inverting); + + void addAttribute(Name attrName, Attribute::Type attrType, std::string& attrValue); + + void print(); + bool write(std::ofstream &file); + + private: + Name _noninverting; + Name _inverting; + std::map _attributes; +}; + +} // namespace LIB +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/Library.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/Library.h new file mode 100644 index 00000000..e9f3e334 --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/Library.h @@ -0,0 +1,43 @@ +#ifndef __LIB_LIBRARY_H__ +#define __LIB_LIBRARY_H__ + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/WireLoad.h" +#include "vlsisapd/liberty/WireLoadSelection.h" +#include "vlsisapd/liberty/Cell.h" + +namespace LIB { + +class Library { + public: + Library(Name name); + + inline Name getName(); + Cell* getCell(Name cellName); + WireLoad* getWireLoad(Name wireLoadName); + inline WireLoadSelection* getWireLoadSelection(); + + void addAttribute(Name attrName, Attribute::Type attrType, std::string& attrValue, const std::string& attrUnit=""); + void addWireLoad(Name wireLoadName); + void addWireLoadSelection(Name wireLoadSelectionName); + void addCell(Name cellName); + + void print(); + + static Library* readFromFile(std::string); + bool writeToFile ( std::string fileName ); + + private: + Name _name; + std::map _attributes; + std::map _wires_load; + WireLoadSelection* _wire_load_selection; + std::map _cells; +}; + +inline Name Library::getName() { return _name; }; +inline WireLoadSelection* Library::getWireLoadSelection() { return _wire_load_selection; }; + +} // namespace LIB +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/Name.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/Name.h new file mode 100644 index 00000000..b36238a6 --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/Name.h @@ -0,0 +1,46 @@ +/* + * Name.h + * openChams + * + * Created by damien dupuis on 18/12/09. + * Copyright 2009 UPMC / LIP6. All rights reserved. + * + */ + +#ifndef __LIB_NAME_H__ +#define __LIB_NAME_H__ + +#include +#include + +namespace LIB { +class Name { + public: + Name(); + Name(std::string); + Name(const char*); + + bool operator==(const Name&); + bool operator==(const std::string&); + bool operator<(const Name&) const; + + inline const std::string& getString() const; + + private: + unsigned long _id; + const std::string *_str; + + static std::map _dict; + static unsigned long _globalId; +}; + +inline const std::string& Name::getString() const{ + if (!_str) { + //throw LIBException("[ERROR] Name object has no string"); + } + return *_str; +} + +} // namespace +#endif + diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/Pin.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/Pin.h new file mode 100644 index 00000000..1dc4c008 --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/Pin.h @@ -0,0 +1,36 @@ +#ifndef __LIB_PIN_H__ +#define __LIB_PIN_H__ + +#include +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" +#include "vlsisapd/liberty/Timing.h" + +namespace LIB { + +class Pin { + public: + Pin(Name name); + + inline Name getName(); + inline std::vector getTiming(); + + void addAttribute(Name attrName, Attribute::Type attrType, std::string& attrValue); + void addTiming(); + + void print(); + bool write(std::ofstream &file); + + private: + Name _name; + std::map _attributes; + std::vector _timings; +}; + +inline Name Pin::getName() { return _name; }; +inline std::vector Pin::getTiming() { return _timings; }; + +} // namespace LIB +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/Timing.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/Timing.h new file mode 100644 index 00000000..64a88a46 --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/Timing.h @@ -0,0 +1,25 @@ +#ifndef __LIB_TIMING_H__ +#define __LIB_TIMING_H__ + +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" + +namespace LIB { + +class Timing { + public: + Timing(); + + void addAttribute(Name attrName, Attribute::Type attrType, std::string& attrValue); + + void print(); + bool write(std::ofstream &file); + + private: + std::map _attributes; +}; + +} // namespace LIB +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoad.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoad.h new file mode 100644 index 00000000..b69ad8cd --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoad.h @@ -0,0 +1,28 @@ +#ifndef __LIB_WIRE_LOAD_H__ +#define __LIB_WIRE_LOAD_H__ + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/Attribute.h" + +namespace LIB { + +class WireLoad { + public: + WireLoad(Name name); + + inline Name getName(); + + void addAttribute(Name attrName, Attribute::Type attrType, std::string& attrValue, const std::string& attrValue2 = ""); + + void print(); + bool write(std::ofstream &file); + + private: + Name _name; + std::map _attributes; +}; + +inline Name WireLoad::getName() { return _name; }; + +} // namespace LIB +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoadArea.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoadArea.h new file mode 100644 index 00000000..628d9fbf --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoadArea.h @@ -0,0 +1,31 @@ +#ifndef __LIB_WIRE_LOAD_AREA_H__ +#define __LIB_WIRE_LOAD_AREA_H__ + +#include + +#include "vlsisapd/liberty/Name.h" + +namespace LIB { + +class WireLoadArea { + public: + WireLoadArea(double min, double max, Name name); + + inline double getMin(); + inline double getMax(); + inline Name getName(); + + bool write(std::ofstream &file); + + private: + double _min; + double _max; + Name _name; +}; + +inline double WireLoadArea::getMin() { return _min; }; +inline double WireLoadArea::getMax() { return _max; }; +inline Name WireLoadArea::getName() { return _name; }; + +} // namespace +#endif diff --git a/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoadSelection.h b/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoadSelection.h new file mode 100644 index 00000000..622a3236 --- /dev/null +++ b/vlsisapd/src/liberty/src/vlsisapd/liberty/WireLoadSelection.h @@ -0,0 +1,26 @@ +#ifndef __LIB_WIRE_LOAD_SELECTION_H__ +#define __LIB_WIRE_LOAD_SELECTION_H__ + +#include +#include + +#include "vlsisapd/liberty/Name.h" +#include "vlsisapd/liberty/WireLoadArea.h" + +namespace LIB { + +class WireLoadSelection { + public: + WireLoadSelection(Name name); + + void addWireLoadArea(double min, double max, Name name); + void print(); + bool write(std::ofstream& file); + + private: + Name _name; + std::vector _wires_load_area; +}; + +} // namespace +#endif