luke
/
OpenSTA
mirror of https://github.com/The-OpenROAD-Project/OpenSTA.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
OpenSTA/liberty/LibertyBuilder.cc

764 lines
25 KiB
C++
Raw Blame History

// OpenSTA, Static Timing Analyzer
// Copyright (c) 2025, Parallax Software, Inc.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software.
//
// Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
//
// This notice may not be removed or altered from any source distribution.
#include "LibertyBuilder.hh"
#include "PortDirection.hh"
#include "TimingRole.hh"
#include "FuncExpr.hh"
#include "TimingArc.hh"
#include "TimingModel.hh"
#include "TableModel.hh"
#include "InternalPower.hh"
#include "LeakagePower.hh"
#include "Sequential.hh"
#include "Liberty.hh"
namespace sta {
using std::string;
void
LibertyBuilder::init(Debug *debug,
Report *report)
{
debug_ = debug;
report_ = report;
}
LibertyCell *
LibertyBuilder::makeCell(LibertyLibrary *library,
const char *name,
const char *filename)
{
LibertyCell *cell = new LibertyCell(library, name, filename);
library->addCell(cell);
return cell;
}
LibertyPort *
LibertyBuilder::makePort(LibertyCell *cell,
const char *port_name)
{
LibertyPort *port = new LibertyPort(cell, port_name, false, nullptr,
-1, -1, false, nullptr);
cell->addPort(port);
return port;
}
LibertyPort *
LibertyBuilder::makeBusPort(LibertyCell *cell,
const char *bus_name,
int from_index,
int to_index,
BusDcl *bus_dcl)
{
LibertyPort *port = new LibertyPort(cell, bus_name, true, bus_dcl,
from_index, to_index,
false, new ConcretePortSeq);
cell->addPort(port);
makeBusPortBits(cell->library(), cell, port, bus_name, from_index, to_index);
return port;
}
void
LibertyBuilder::makeBusPortBits(ConcreteLibrary *library,
LibertyCell *cell,
ConcretePort *bus_port,
const char *bus_name,
int from_index,
int to_index)
{
if (from_index < to_index) {
for (int index = from_index; index <= to_index; index++)
makeBusPortBit(library, cell, bus_port, bus_name, index);
}
else {
for (int index = from_index; index >= to_index; index--)
makeBusPortBit(library, cell, bus_port, bus_name, index);
}
}
void
LibertyBuilder::makeBusPortBit(ConcreteLibrary *library,
LibertyCell *cell,
ConcretePort *bus_port,
const char *bus_name,
int bit_index)
{
string bit_name;
stringPrint(bit_name, "%s%c%d%c",
bus_name,
library->busBrktLeft(),
bit_index,
library->busBrktRight());
LibertyPort *port = makePort(cell, bit_name.c_str(), bit_index);
bus_port->addPortBit(port);
cell->addPortBit(port);
}
LibertyPort *
LibertyBuilder::makePort(LibertyCell *cell,
const char *bit_name,
int bit_index)
{
LibertyPort *port = new LibertyPort(cell, bit_name, false, nullptr,
bit_index, bit_index, false, nullptr);
return port;
}
LibertyPort *
LibertyBuilder::makeBundlePort(LibertyCell *cell,
const char *name,
ConcretePortSeq *members)
{
LibertyPort *port = new LibertyPort(cell, name, false, nullptr, -1, -1, true, members);
cell->addPort(port);
return port;
}
////////////////////////////////////////////////////////////////
TimingArcSet *
LibertyBuilder::makeTimingArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
LibertyPort *related_out,
TimingArcAttrsPtr attrs,
int /* line */)
{
FuncExpr *to_func = to_port->function();
Sequential *seq = (to_func && to_func->port())
? cell->outputPortSequential(to_func->port())
: nullptr;
TimingType timing_type = attrs->timingType();
// Register/latch timing group missing timing_type.
if (attrs->timingType() == TimingType::combinational
&& seq) {
if (seq->clock() && seq->clock()->hasPort(from_port)) {
switch (seq->clock()->portTimingSense(from_port)) {
case TimingSense::positive_unate:
timing_type = TimingType::rising_edge;
break;
case TimingSense::negative_unate:
timing_type = TimingType::rising_edge;
break;
default:
break;
}
}
else if (seq->clear() && seq->clear()->hasPort(from_port)) {
timing_type = TimingType::clear;
if (attrs->timingSense() == TimingSense::unknown) {
// Missing timing_sense also.
TimingSense timing_sense = seq->clear()->portTimingSense(from_port);
attrs->setTimingSense(timing_sense);
}
}
else if (seq->preset() && seq->preset()->hasPort(from_port)) {
timing_type = TimingType::preset;
if (attrs->timingSense() == TimingSense::unknown) {
// Missing timing_sense also.
TimingSense timing_sense = seq->preset()->portTimingSense(from_port);
attrs->setTimingSense(timing_sense);
}
}
}
switch (timing_type) {
case TimingType::combinational:
if (seq
&& seq->isLatch()
&& seq->data()->hasPort(from_port))
// Latch D->Q timing arcs.
return makeLatchDtoQArcs(cell, from_port, to_port,
seq->data()->portTimingSense(from_port), attrs);
else
return makeCombinationalArcs(cell, from_port, to_port, true, true, attrs);
case TimingType::combinational_fall:
return makeCombinationalArcs(cell, from_port, to_port, false, true, attrs);
case TimingType::combinational_rise:
return makeCombinationalArcs(cell, from_port, to_port, true, false, attrs);
case TimingType::setup_rising:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::rise(), TimingRole::setup(),
attrs);
case TimingType::setup_falling:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::fall(), TimingRole::setup(),
attrs);
case TimingType::hold_rising:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::rise(), TimingRole::hold(),
attrs);
case TimingType::hold_falling:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::fall(), TimingRole::hold(),
attrs);
case TimingType::rising_edge:
return makeRegLatchArcs(cell, from_port, to_port, RiseFall::rise(), attrs);
case TimingType::falling_edge:
return makeRegLatchArcs(cell, from_port, to_port, RiseFall::fall(), attrs);
case TimingType::preset:
return makePresetClrArcs(cell, from_port, to_port, RiseFall::rise(), attrs);
case TimingType::clear:
return makePresetClrArcs(cell, from_port, to_port, RiseFall::fall(), attrs);
case TimingType::recovery_rising:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::rise(),TimingRole::recovery(),
attrs);
case TimingType::recovery_falling:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::fall(),TimingRole::recovery(),
attrs);
case TimingType::removal_rising:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::rise(), TimingRole::removal(),
attrs);
case TimingType::removal_falling:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::fall(), TimingRole::removal(),
attrs);
case TimingType::three_state_disable:
return makeTristateDisableArcs(cell, from_port, to_port, true, true, attrs);
case TimingType::three_state_disable_fall:
return makeTristateDisableArcs(cell, from_port, to_port, false, true, attrs);
case TimingType::three_state_disable_rise:
return makeTristateDisableArcs(cell, from_port, to_port, true, false, attrs);
case TimingType::three_state_enable:
return makeTristateEnableArcs(cell, from_port, to_port, true, true, attrs);
case TimingType::three_state_enable_fall:
return makeTristateEnableArcs(cell, from_port, to_port, false, true, attrs);
case TimingType::three_state_enable_rise:
return makeTristateEnableArcs(cell, from_port, to_port, true, false, attrs);
case TimingType::skew_falling:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::fall(), TimingRole::skew(),
attrs);
case TimingType::skew_rising:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::rise(), TimingRole::skew(),
attrs);
case TimingType::non_seq_setup_rising:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::rise(),
TimingRole::nonSeqSetup(), attrs);
case TimingType::non_seq_setup_falling:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::fall(),
TimingRole::nonSeqSetup(), attrs);
case TimingType::non_seq_hold_rising:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::rise(),
TimingRole::nonSeqHold(),
attrs);
case TimingType::non_seq_hold_falling:
return makeFromTransitionArcs(cell, from_port, to_port, related_out,
RiseFall::fall(),
TimingRole::nonSeqHold(),
attrs);
case TimingType::min_clock_tree_path:
return makeClockTreePathArcs(cell, to_port, TimingRole::clockTreePathMin(),
MinMax::min(), attrs);
case TimingType::max_clock_tree_path:
return makeClockTreePathArcs(cell, to_port, TimingRole::clockTreePathMax(),
MinMax::max(), attrs);
case TimingType::min_pulse_width:
return makeMinPulseWidthArcs(cell, from_port, to_port, related_out,
TimingRole::width(), attrs);
case TimingType::minimum_period:
case TimingType::nochange_high_high:
case TimingType::nochange_high_low:
case TimingType::nochange_low_high:
case TimingType::nochange_low_low:
case TimingType::retaining_time:
case TimingType::unknown:
return nullptr;
}
// Prevent warnings from lame compilers.
return nullptr;
}
TimingArcSet *
LibertyBuilder::makeCombinationalArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
bool to_rise,
bool to_fall,
TimingArcAttrsPtr attrs)
{
FuncExpr *func = to_port->function();
FuncExpr *enable = to_port->tristateEnable();
TimingArcSet *arc_set = makeTimingArcSet(cell, from_port, to_port,
TimingRole::combinational(), attrs);
TimingSense sense = attrs->timingSense();
if (sense == TimingSense::unknown) {
// Timing sense not specified - find it from function.
if (func && func->hasPort(from_port))
sense = func->portTimingSense(from_port);
// Check tristate enable.
else if (to_port->direction()->isAnyTristate()
&& enable
&& enable->hasPort(from_port))
sense = TimingSense::non_unate;
// Don't warn for functions that reference ff/latch/lut internal ports.
//else if (func->port() && !func->port()->direction()->isInternal())
// report_->fileWarn(172, cell->filename(), line,
// "timing sense cannot be inferred because pin function does not reference related pin %s.",
// from_port->name());
}
TimingModel *model;
const RiseFall *to_rf;
switch (sense) {
case TimingSense::positive_unate:
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, RiseFall::rise(), to_rf, model);
}
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, RiseFall::fall(), to_rf, model);
}
break;
case TimingSense::negative_unate:
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, RiseFall::rise(), to_rf, model);
}
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, RiseFall::fall(), to_rf, model);
}
break;
case TimingSense::non_unate:
case TimingSense::unknown:
case TimingSense::none:
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model) {
makeTimingArc(arc_set, RiseFall::fall(), to_rf, model);
makeTimingArc(arc_set, RiseFall::rise(), to_rf, model);
}
}
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model) {
makeTimingArc(arc_set, RiseFall::rise(), to_rf, model);
makeTimingArc(arc_set, RiseFall::fall(), to_rf, model);
}
}
break;
}
return arc_set;
}
TimingArcSet *
LibertyBuilder::makeLatchDtoQArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
TimingSense sense,
TimingArcAttrsPtr attrs)
{
TimingArcSet *arc_set = makeTimingArcSet(cell, from_port, to_port,
TimingRole::latchDtoQ(), attrs);
TimingModel *model;
const RiseFall *to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model) {
const RiseFall *from_rf = (sense == TimingSense::negative_unate)
? to_rf->opposite()
: to_rf;
makeTimingArc(arc_set, from_rf, to_rf, model);
}
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model) {
const RiseFall *from_rf = (sense == TimingSense::negative_unate)
? to_rf->opposite()
: to_rf;
makeTimingArc(arc_set, from_rf, to_rf, model);
}
return arc_set;
}
TimingArcSet *
LibertyBuilder::makeRegLatchArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
const RiseFall *from_rf,
TimingArcAttrsPtr attrs)
{
FuncExpr *to_func = to_port->function();
FuncExprPortIterator port_iter(to_func);
while (port_iter.hasNext()) {
LibertyPort *func_port = port_iter.next();
Sequential *seq = cell->outputPortSequential(func_port);
if (seq) {
if (seq->clock() && seq->clock()->hasPort(from_port)) {
const TimingRole *role = seq->isRegister() ?
TimingRole::regClkToQ() : TimingRole::latchEnToQ();
return makeFromTransitionArcs(cell, from_port, to_port, nullptr,
from_rf, role, attrs);
}
else if (seq->isLatch()
&& seq->data()
&& seq->data()->hasPort(from_port))
return makeFromTransitionArcs(cell, from_port, to_port, nullptr,
from_rf, TimingRole::latchDtoQ(), attrs);
else if ((seq->clear() && seq->clear()->hasPort(from_port))
|| (seq->preset() && seq->preset()->hasPort(from_port)))
return makeFromTransitionArcs(cell, from_port, to_port, nullptr,
from_rf, TimingRole::regSetClr(), attrs);
}
}
// No associated ff/latch - assume register clk->q.
cell->setHasInferedRegTimingArcs(true);
return makeFromTransitionArcs(cell, from_port, to_port, nullptr,
from_rf, TimingRole::regClkToQ(), attrs);
}
TimingArcSet *
LibertyBuilder::makeFromTransitionArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
LibertyPort *related_out,
const RiseFall *from_rf,
const TimingRole *role,
TimingArcAttrsPtr attrs)
{
TimingArcSet *arc_set = makeTimingArcSet(cell, from_port, to_port,
related_out, role, attrs);
for (auto to_rf : RiseFall::range()) {
TimingModel *model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, from_rf, to_rf, model);
}
return arc_set;
}
TimingArcSet *
LibertyBuilder::makePresetClrArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
const RiseFall *to_rf,
TimingArcAttrsPtr attrs)
{
TimingArcSet *arc_set = nullptr;
TimingModel *model = attrs->model(to_rf);
if (model) {
arc_set = makeTimingArcSet(cell, from_port, to_port,
TimingRole::regSetClr(), attrs);
const RiseFall *opp_rf = to_rf->opposite();
switch (attrs->timingSense()) {
case TimingSense::positive_unate:
makeTimingArc(arc_set, to_rf, to_rf, model);
break;
case TimingSense::negative_unate:
makeTimingArc(arc_set, opp_rf, to_rf, model);
break;
case TimingSense::non_unate:
case TimingSense::unknown:
makeTimingArc(arc_set, to_rf, to_rf, model);
makeTimingArc(arc_set, opp_rf, to_rf, model);
break;
case TimingSense::none:
break;
}
}
return arc_set;
}
// To rise/fall for Z transitions is as follows:
// 0Z, Z1 rise
// 1Z, Z0 fall
TimingArcSet *
LibertyBuilder::makeTristateEnableArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
bool to_rise,
bool to_fall,
TimingArcAttrsPtr attrs)
{
TimingArcSet *arc_set = makeTimingArcSet(cell, from_port, to_port,
TimingRole::tristateEnable(), attrs);
FuncExpr *tristate_enable = to_port->tristateEnable();
TimingSense sense = attrs->timingSense();
if (sense == TimingSense::unknown && tristate_enable)
sense = tristate_enable->portTimingSense(from_port);
TimingModel *model;
const RiseFall *to_rf;
switch (sense) {
case TimingSense::positive_unate:
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::rise(), Transition::trZ1(), model);
}
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::rise(), Transition::trZ0(), model);
}
break;
case TimingSense::negative_unate:
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::fall(), Transition::trZ1(), model);
}
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::fall(), Transition::trZ0(), model);
}
break;
case TimingSense::non_unate:
case TimingSense::unknown:
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model) {
makeTimingArc(arc_set, Transition::rise(), Transition::trZ1(), model);
makeTimingArc(arc_set, Transition::fall(), Transition::trZ1(), model);
}
}
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model) {
makeTimingArc(arc_set, Transition::rise(), Transition::trZ0(), model);
makeTimingArc(arc_set, Transition::fall(), Transition::trZ0(), model);
}
}
break;
case TimingSense::none:
break;
}
return arc_set;
}
TimingArcSet *
LibertyBuilder::makeTristateDisableArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
bool to_rise,
bool to_fall,
TimingArcAttrsPtr attrs)
{
TimingArcSet *arc_set = makeTimingArcSet(cell, from_port, to_port,
TimingRole::tristateDisable(),
attrs);
TimingSense sense = attrs->timingSense();
FuncExpr *tristate_enable = to_port->tristateEnable();
if (sense == TimingSense::unknown && tristate_enable)
sense = timingSenseOpposite(tristate_enable->portTimingSense(from_port));
TimingModel *model;
const RiseFall *to_rf;
switch (sense) {
case TimingSense::positive_unate:
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::rise(), Transition::tr0Z(), model);
}
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::rise(), Transition::tr1Z(), model);
}
break;
case TimingSense::negative_unate:
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::fall(), Transition::tr0Z(), model);
}
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model)
makeTimingArc(arc_set, Transition::fall(), Transition::tr1Z(), model);
}
break;
case TimingSense::non_unate:
case TimingSense::unknown:
if (to_rise) {
to_rf = RiseFall::rise();
model = attrs->model(to_rf);
if (model) {
makeTimingArc(arc_set, Transition::fall(), Transition::tr0Z(), model);
makeTimingArc(arc_set, Transition::rise(), Transition::tr0Z(), model);
}
}
if (to_fall) {
to_rf = RiseFall::fall();
model = attrs->model(to_rf);
if (model) {
makeTimingArc(arc_set, Transition::fall(), Transition::tr1Z(), model);
makeTimingArc(arc_set, Transition::rise(), Transition::tr1Z(), model);
}
}
break;
case TimingSense::none:
break;
}
return arc_set;
}
TimingArcSet *
LibertyBuilder::makeClockTreePathArcs(LibertyCell *cell,
LibertyPort *to_port,
const TimingRole *role,
const MinMax *min_max,
TimingArcAttrsPtr attrs)
{
TimingArcSet *arc_set = makeTimingArcSet(cell, nullptr, to_port, role, attrs);
for (auto to_rf : RiseFall::range()) {
TimingModel *model = attrs->model(to_rf);
if (model) {
const GateTableModel *gate_model = dynamic_cast<GateTableModel *>(model);
const RiseFall *opp_rf = to_rf->opposite();
switch (attrs->timingSense()) {
case TimingSense::positive_unate:
makeTimingArc(arc_set, to_rf, to_rf, model);
to_port->setClkTreeDelay(gate_model->delayModel(), to_rf, to_rf, min_max);
break;
case TimingSense::negative_unate:
makeTimingArc(arc_set, opp_rf, to_rf, model);
to_port->setClkTreeDelay(gate_model->delayModel(), opp_rf, to_rf, min_max);
break;
case TimingSense::non_unate:
case TimingSense::unknown:
makeTimingArc(arc_set, to_rf, to_rf, model);
makeTimingArc(arc_set, opp_rf, to_rf, model);
to_port->setClkTreeDelay(gate_model->delayModel(), to_rf, to_rf, min_max);
to_port->setClkTreeDelay(gate_model->delayModel(), opp_rf, to_rf, min_max);
break;
case TimingSense::none:
break;
}
}
}
return arc_set;
}
TimingArcSet *
LibertyBuilder::makeMinPulseWidthArcs(LibertyCell *cell,
LibertyPort *from_port,
LibertyPort *to_port,
LibertyPort *related_out,
const TimingRole *role,
TimingArcAttrsPtr attrs)
{
if (from_port == nullptr)
from_port = to_port;
TimingArcSet *arc_set = makeTimingArcSet(cell, from_port, to_port, related_out,
role, attrs);
for (const RiseFall *from_rf : RiseFall::range()) {
TimingModel *model = attrs->model(from_rf);
if (model)
makeTimingArc(arc_set, from_rf, from_rf->opposite(), model);
}
return arc_set;
}
////////////////////////////////////////////////////////////////
TimingArcSet *
LibertyBuilder::makeTimingArcSet(LibertyCell *cell,
LibertyPort *from,
LibertyPort *to,
const TimingRole *role,
TimingArcAttrsPtr attrs)
{
return new TimingArcSet(cell, from, to, nullptr, role, attrs);
}
TimingArcSet *
LibertyBuilder::makeTimingArcSet(LibertyCell *cell,
LibertyPort *from,
LibertyPort *to,
LibertyPort *related_out,
const TimingRole *role,
TimingArcAttrsPtr attrs)
{
return new TimingArcSet(cell, from, to, related_out, role, attrs);
}
TimingArc *
LibertyBuilder::makeTimingArc(TimingArcSet *set,
const RiseFall *from_rf,
const RiseFall *to_rf,
TimingModel *model)
{
return new TimingArc(set, from_rf->asTransition(),
to_rf->asTransition(), model);
}
TimingArc *
LibertyBuilder::makeTimingArc(TimingArcSet *set,
const Transition *from_rf,
const Transition *to_rf,
TimingModel *model)
{
return new TimingArc(set, from_rf, to_rf, model);
}
////////////////////////////////////////////////////////////////
InternalPower *
LibertyBuilder::makeInternalPower(LibertyCell *cell,
LibertyPort *port,
LibertyPort *related_port,
InternalPowerAttrs *attrs)
{
return new InternalPower(cell, port, related_port, attrs);
}
LeakagePower *
LibertyBuilder::makeLeakagePower(LibertyCell *cell,
LeakagePowerAttrs *attrs)
{
return new LeakagePower(cell, attrs);
}
} // namespace
Reference in New Issue View Git Blame Copy Permalink