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

967 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 "Sim.hh"
// https://davidkebo.com/cudd
#include "cudd.h"
#include "Error.hh"
#include "Mutex.hh"
#include "Debug.hh"
#include "Report.hh"
#include "Stats.hh"
#include "FuncExpr.hh"
#include "TimingRole.hh"
#include "TimingArc.hh"
#include "Liberty.hh"
#include "PortDirection.hh"
#include "Sequential.hh"
#include "Network.hh"
#include "Sdc.hh"
#include "Graph.hh"
namespace sta {
static LogicValue
logicNot(LogicValue value);
static const Pin *
findDrvrPin(const Pin *pin,
Network *network);
Sim::Sim(StaState *sta) :
StaState(sta),
observer_(nullptr),
valid_(false),
incremental_(false),
const_func_pins_(network_),
const_func_pins_valid_(false),
invalid_insts_(network_),
invalid_drvr_pins_(network_),
invalid_load_pins_(network_),
instances_with_const_pins_(network_),
instances_to_annotate_(network_),
bdd_(sta)
{
}
Sim::~Sim()
{
delete observer_;
}
TimingSense
Sim::functionSense(const FuncExpr *expr,
const Pin *input_pin,
const Instance *inst)
{
debugPrint(debug_, "sim", 4, "find sense pin %s %s",
network_->pathName(input_pin),
expr->to_string().c_str());
bool increasing, decreasing;
{
LockGuard lock(bdd_lock_);
DdNode *bdd = funcBddSim(expr, inst);
DdManager *cudd_mgr = bdd_.cuddMgr();
LibertyPort *input_port = network_->libertyPort(input_pin);
DdNode *input_node = bdd_.ensureNode(input_port);
unsigned int input_index = Cudd_NodeReadIndex(input_node);
increasing = (Cudd_Increasing(cudd_mgr, bdd, input_index)
== Cudd_ReadOne(cudd_mgr));
decreasing = (Cudd_Decreasing(cudd_mgr, bdd, input_index)
== Cudd_ReadOne(cudd_mgr));
Cudd_RecursiveDeref(cudd_mgr, bdd);
bdd_.clearVarMap();
}
TimingSense sense;
if (increasing && decreasing)
sense = TimingSense::none;
else if (increasing)
sense = TimingSense::positive_unate;
else if (decreasing)
sense = TimingSense::negative_unate;
else
sense = TimingSense::non_unate;
debugPrint(debug_, "sim", 4, " %s", to_string(sense));
return sense;
}
LogicValue
Sim::evalExpr(const FuncExpr *expr,
const Instance *inst)
{
LockGuard lock(bdd_lock_);
DdNode *bdd = funcBddSim(expr, inst);
LogicValue value = LogicValue::unknown;
DdManager *cudd_mgr = bdd_.cuddMgr();
if (bdd == Cudd_ReadLogicZero(cudd_mgr))
value = LogicValue::zero;
else if (bdd == Cudd_ReadOne(cudd_mgr))
value = LogicValue::one;
if (bdd) {
Cudd_RecursiveDeref(bdd_.cuddMgr(), bdd);
bdd_.clearVarMap();
}
return value;
}
// BDD with instance pin values substituted.
DdNode *
Sim::funcBddSim(const FuncExpr *expr,
const Instance *inst)
{
DdNode *bdd = bdd_.funcBdd(expr);
DdManager *cudd_mgr = bdd_.cuddMgr();
InstancePinIterator *pin_iter = network_->pinIterator(inst);
while (pin_iter->hasNext()) {
const Pin *pin = pin_iter->next();
const LibertyPort *port = network_->libertyPort(pin);
DdNode *port_node = bdd_.findNode(port);
if (port_node) {
LogicValue value = logicValue(pin);
int var_index = Cudd_NodeReadIndex(port_node);
switch (value) {
case LogicValue::zero:
bdd = Cudd_bddCompose(cudd_mgr, bdd, Cudd_ReadLogicZero(cudd_mgr), var_index);
Cudd_Ref(bdd);
break;
case LogicValue::one:
bdd = Cudd_bddCompose(cudd_mgr, bdd, Cudd_ReadOne(cudd_mgr), var_index);
Cudd_Ref(bdd);
break;
default:
break;
}
}
}
delete pin_iter;
return bdd;
}
static LogicValue
logicNot(LogicValue value)
{
static LogicValue logic_not[5] = {LogicValue::one, LogicValue::zero,
LogicValue::unknown, LogicValue::unknown,
LogicValue::unknown};
return logic_not[int(value)];
}
void
Sim::clear()
{
valid_ = false;
incremental_ = false;
const_func_pins_.clear();
const_func_pins_valid_ = false;
instances_with_const_pins_.clear();
instances_to_annotate_.clear();
invalid_insts_.clear();
invalid_drvr_pins_.clear();
invalid_load_pins_.clear();
}
void
Sim::setObserver(SimObserver *observer)
{
delete observer_;
observer_ = observer;
}
void
Sim::ensureConstantsPropagated()
{
if (!valid_) {
Stats stats(debug_, report_);
ensureConstantFuncPins();
instances_to_annotate_.clear();
if (incremental_) {
seedInvalidConstants();
propagateToInvalidLoads();
propagateFromInvalidDrvrsToLoads();
}
else {
clearSimValues();
seedConstants();
}
invalid_insts_.clear();
propagateConstants(false);
annotateGraphEdges();
valid_ = true;
incremental_ = true;
stats.report("Propagate constants");
}
}
void
Sim::findLogicConstants()
{
clear();
ensureConstantFuncPins();
setConstFuncPins();
enqueueConstantPinInputs();
propagateConstants(true);
valid_ = true;
}
void
Sim::seedInvalidConstants()
{
for (const Instance *inst : invalid_insts_)
eval_queue_.push(inst);
}
void
Sim::propagateToInvalidLoads()
{
for (const Pin *load_pin : invalid_load_pins_) {
const Net *net = network_->net(load_pin);
if (net && network_->isGround(net))
setPinValue(load_pin, LogicValue::zero);
else if (net && network_->isPower(net))
setPinValue(load_pin, LogicValue::one);
else {
const Pin *drvr_pin = findDrvrPin(load_pin, network_);
if (drvr_pin)
propagateDrvrToLoad(drvr_pin, load_pin);
}
}
invalid_load_pins_.clear();
}
void
Sim::propagateFromInvalidDrvrsToLoads()
{
for (const Pin *drvr_pin : invalid_drvr_pins_) {
LogicValue value = const_func_pins_.hasKey(drvr_pin)
? pinConstFuncValue(drvr_pin)
: logicValue(drvr_pin);
PinConnectedPinIterator *load_iter=network_->connectedPinIterator(drvr_pin);
while (load_iter->hasNext()) {
const Pin *load_pin = load_iter->next();
if (load_pin != drvr_pin
&& network_->isLoad(load_pin))
setPinValue(load_pin, value);
}
delete load_iter;
}
invalid_drvr_pins_.clear();
}
void
Sim::propagateDrvrToLoad(const Pin *drvr_pin,
const Pin *load_pin)
{
LogicValue value = logicValue(drvr_pin);
setPinValue(load_pin, value);
}
void
Sim::constantsInvalid()
{
valid_ = false;
incremental_ = false;
}
void
Sim::ensureConstantFuncPins()
{
if (!const_func_pins_valid_) {
LeafInstanceIterator *inst_iter = network_->leafInstanceIterator();
while (inst_iter->hasNext()) {
Instance *inst = inst_iter->next();
InstancePinIterator *pin_iter = network_->pinIterator(inst);
while (pin_iter->hasNext()) {
const Pin *pin = pin_iter->next();
recordConstPinFunc(pin);
}
delete pin_iter;
}
delete inst_iter;
const_func_pins_valid_ = true;
}
}
void
Sim::recordConstPinFunc(const Pin *pin)
{
LibertyPort *port = network_->libertyPort(pin);
if (port) {
FuncExpr *expr = port->function();
if (expr
// Tristate outputs do not force the output to be constant.
&& port->tristateEnable() == nullptr
&& (expr->op() == FuncExpr::op_zero
|| expr->op() == FuncExpr::op_one))
const_func_pins_.insert(pin);
}
}
void
Sim::deleteInstanceBefore(const Instance *inst)
{
instances_with_const_pins_.erase(inst);
invalid_insts_.erase(inst);
}
void
Sim::makePinAfter(const Pin *pin)
{
// Incrementally update const_func_pins_.
recordConstPinFunc(pin);
}
void
Sim::deletePinBefore(const Pin *pin)
{
// Incrementally update const_func_pins_.
const_func_pins_.erase(pin);
invalid_load_pins_.erase(pin);
invalid_drvr_pins_.erase(pin);
invalid_insts_.insert(network_->instance(pin));
}
void
Sim::connectPinAfter(const Pin *pin)
{
if (incremental_) {
recordConstPinFunc(pin);
if (network_->isLoad(pin))
invalid_load_pins_.insert(pin);
if (network_->isDriver(pin))
invalid_drvr_pins_.insert(pin);
valid_ = false;
}
}
void
Sim::disconnectPinBefore(const Pin *pin)
{
if (incremental_) {
if (network_->isLoad(pin)) {
invalid_load_pins_.insert(pin);
removePropagatedValue(pin);
}
if (network_->isDriver(pin))
invalid_drvr_pins_.insert(pin);
}
}
void
Sim::pinSetFuncAfter(const Pin *pin)
{
if (incremental_) {
Instance *inst = network_->instance(pin);
if (instances_with_const_pins_.hasKey(inst))
invalid_insts_.insert(inst);
valid_ = false;
}
// Incrementally update const_func_pins_.
const_func_pins_.erase(pin);
recordConstPinFunc(pin);
}
void
Sim::seedConstants()
{
// Propagate constants from inputs tied hi/low in the network.
enqueueConstantPinInputs();
// Propagate set_LogicValue::zero, set_LogicValue::one, set_logic_dc constants.
setConstraintConstPins(sdc_->logicValues());
// Propagate set_case_analysis constants.
setConstraintConstPins(sdc_->caseLogicValues());
// Propagate 0/1 constant functions.
setConstFuncPins();
}
void
Sim::propagateConstants(bool thru_sequentials)
{
while (!eval_queue_.empty()) {
const Instance *inst = eval_queue_.front();
eval_queue_.pop();
evalInstance(inst, thru_sequentials);
}
}
void
Sim::setConstraintConstPins(LogicValueMap &value_map)
{
for (const auto [pin, value] : value_map) {
debugPrint(debug_, "sim", 2, "case pin %s = %c",
network_->pathName(pin),
logicValueString(value));
if (network_->isHierarchical(pin)) {
// Set the logic value on pins inside the instance of a hierarchical pin.
bool pin_is_output = network_->direction(pin)->isAnyOutput();
PinConnectedPinIterator *pin_iter=network_->connectedPinIterator(pin);
while (pin_iter->hasNext()) {
const Pin *pin1 = pin_iter->next();
if (network_->isLeaf(pin1)
&& network_->direction(pin1)->isAnyInput()
&& ((pin_is_output && !network_->isInside(pin1, pin))
|| (!pin_is_output && network_->isInside(pin1, pin))))
setPinValue(pin1, value);
}
delete pin_iter;
}
else
setPinValue(pin, value);
}
}
// Propagate constants from outputs with constant functions
// (tie high and tie low cell instances).
void
Sim::setConstFuncPins()
{
for (const Pin *pin : const_func_pins_) {
LogicValue value = pinConstFuncValue(pin);
setPinValue(pin, value);
debugPrint(debug_, "sim", 2, "func pin %s = %c",
network_->pathName(pin),
logicValueString(value));
}
}
LogicValue
Sim::pinConstFuncValue(const Pin *pin)
{
LibertyPort *port = network_->libertyPort(pin);
if (port) {
FuncExpr *expr = port->function();
if (expr->op() == FuncExpr::op_zero)
return LogicValue::zero;
else if (expr->op() == FuncExpr::op_one)
return LogicValue::one;
}
return LogicValue::unknown;
}
void
Sim::enqueueConstantPinInputs()
{
ConstantPinIterator *const_iter = network_->constantPinIterator();
while (const_iter->hasNext()) {
LogicValue value;
const Pin *pin;
const_iter->next(pin, value);
debugPrint(debug_, "sim", 2, "network constant pin %s = %c",
network_->pathName(pin),
logicValueString(value));
setPinValue(pin, value);
}
delete const_iter;
}
void
Sim::removePropagatedValue(const Pin *pin)
{
Instance *inst = network_->instance(pin);
if (instances_with_const_pins_.hasKey(inst)) {
invalid_insts_.insert(inst);
valid_ = false;
LogicValue constraint_value;
bool exists;
sdc_->caseLogicValue(pin, constraint_value, exists);
if (!exists) {
sdc_->logicValue(pin, constraint_value, exists);
if (!exists) {
debugPrint(debug_, "sim", 2, "pin %s remove prop constant",
network_->pathName(pin));
Vertex *vertex, *bidirect_drvr_vertex;
graph_->pinVertices(pin, vertex, bidirect_drvr_vertex);
if (vertex)
setSimValue(vertex, LogicValue::unknown);
if (bidirect_drvr_vertex)
setSimValue(bidirect_drvr_vertex, LogicValue::unknown);
}
}
}
}
void
Sim::setPinValue(const Pin *pin,
LogicValue value)
{
LogicValue constraint_value;
bool exists;
sdc_->caseLogicValue(pin, constraint_value, exists);
if (!exists)
sdc_->logicValue(pin, constraint_value, exists);
if (exists
&& value != constraint_value) {
if (value != LogicValue::unknown)
report_->warn(1521, "propagated logic value %c differs from constraint value of %c on pin %s.",
logicValueString(value),
logicValueString(constraint_value),
sdc_network_->pathName(pin));
}
else {
debugPrint(debug_, "sim", 3, "pin %s = %c",
network_->pathName(pin),
logicValueString(value));
Vertex *vertex, *bidirect_drvr_vertex;
graph_->pinVertices(pin, vertex, bidirect_drvr_vertex);
// Set vertex constant flags.
bool value_changed = false;
if (vertex) {
value_changed |= value != vertex->simValue();
setSimValue(vertex, value);
}
if (bidirect_drvr_vertex) {
value_changed |= value != bidirect_drvr_vertex->simValue();
setSimValue(bidirect_drvr_vertex, value);
}
if (value_changed) {
Instance *inst = network_->instance(pin);
if (logicValueZeroOne(value))
instances_with_const_pins_.insert(inst);
instances_to_annotate_.insert(inst);
if (network_->isLeaf(inst)
&& network_->direction(pin)->isAnyInput()) {
if (eval_queue_.empty()
|| (eval_queue_.back() != inst))
eval_queue_.push(inst);
}
else if (network_->isDriver(pin)) {
// Enqueue instances with input pins connected to net.
PinConnectedPinIterator *pin_iter=network_->connectedPinIterator(pin);
while (pin_iter->hasNext()) {
const Pin *pin1 = pin_iter->next();
if (pin1 != pin
&& network_->isLoad(pin1))
setPinValue(pin1, value);
}
delete pin_iter;
}
}
}
}
void
Sim::evalInstance(const Instance *inst,
bool thru_sequentials)
{
debugPrint(debug_, "sim", 2, "eval %s", network_->pathName(inst));
InstancePinIterator *pin_iter = network_->pinIterator(inst);
while (pin_iter->hasNext()) {
Pin *pin = pin_iter->next();
LibertyPort *port = network_->libertyPort(pin);
if (port) {
PortDirection *dir = port->direction();
if (dir->isAnyOutput()) {
LogicValue value = LogicValue::unknown;
FuncExpr *expr = port->function();
LibertyCell *cell = port->libertyCell();
if (expr) {
FuncExpr *tri_en_expr = port->tristateEnable();
if (tri_en_expr) {
if (evalExpr(tri_en_expr, inst) == LogicValue::one) {
value = evalExpr(expr, inst);
debugPrint(debug_, "sim", 2, " %s tri_en=1 %s = %c",
port->name(),
expr->to_string().c_str(),
logicValueString(value));
}
}
else {
LibertyPort *expr_port = expr->port();
Sequential *sequential = (thru_sequentials && expr_port)
? cell->outputPortSequential(expr_port)
: nullptr;
if (sequential) {
value = evalExpr(sequential->data(), inst);
if (expr_port == sequential->outputInv())
value = logicNot(value);
debugPrint(debug_, "sim", 2, " %s seq %s = %c",
port->name(),
expr->to_string().c_str(),
logicValueString(value));
}
else {
value = evalExpr(expr, inst);
debugPrint(debug_, "sim", 2, " %s %s = %c",
port->name(),
expr->to_string().c_str(),
logicValueString(value));
}
}
}
else if (port->isClockGateOut()) {
value = clockGateOutValue(inst);
debugPrint(debug_, "sim", 2, " %s gated_clk = %c",
port->name(),
logicValueString(value));
}
if (value != logicValue(pin))
setPinValue(pin, value);
}
}
}
delete pin_iter;
}
LogicValue
Sim::clockGateOutValue(const Instance *inst)
{
LibertyCell *cell = network_->libertyCell(inst);
LibertyCellPortIterator port_iter(cell);
while (port_iter.hasNext()) {
LibertyPort *port = port_iter.next();
if (port->isClockGateClock()
|| port->isClockGateEnable()) {
Pin *gclk_pin = network_->findPin(inst, port);
if (gclk_pin) {
Vertex *gclk_vertex = graph_->pinLoadVertex(gclk_pin);
if (gclk_vertex->simValue() == LogicValue::zero)
return LogicValue::zero;
}
}
}
return LogicValue::unknown;
}
void
Sim::setSimValue(Vertex *vertex,
LogicValue value)
{
if (value != vertex->simValue()) {
vertex->setSimValue(value);
if (observer_)
observer_->valueChangeAfter(vertex);
}
}
TimingSense
Sim::functionSense(const Instance *inst,
const Pin *from_pin,
const Pin *to_pin)
{
if (logicZeroOne(from_pin))
return TimingSense::none;
else {
LibertyPort *from_port = network_->libertyPort(from_pin);
LibertyPort *to_port = network_->libertyPort(to_pin);
if (to_port) {
const FuncExpr *func = to_port->function();
if (func) {
PortDirection *to_dir = to_port->direction();
if (to_dir->isAnyTristate()) {
FuncExpr *tri_func = to_port->tristateEnable();
if (tri_func) {
if (func->hasPort(from_port)) {
// from_pin is an input to the to_pin function.
LogicValue tri_enable = evalExpr(tri_func, inst);
if (tri_enable == LogicValue::zero)
// Tristate is disabled.
return TimingSense::none;
else
return functionSense(func, from_pin, inst);
}
}
else {
// Missing tristate enable function.
if (func->hasPort(from_port))
// from_pin is an input to the to_pin function.
return functionSense(func, from_pin, inst);
}
}
else {
if (func->hasPort(from_port))
// from_pin is an input to the to_pin function.
return functionSense(func, from_pin, inst);
}
}
}
return TimingSense::unknown;
}
}
LogicValue
Sim::logicValue(const Pin *pin) const
{
Vertex *vertex = graph_->pinLoadVertex(pin);
if (vertex)
return vertex->simValue();
else {
if (network_->isHierarchical(pin)) {
const Pin *drvr_pin = findDrvrPin(pin, network_);
if (drvr_pin)
return logicValue(drvr_pin);
}
return LogicValue::unknown;
}
}
static const Pin *
findDrvrPin(const Pin *pin,
Network *network)
{
PinSet *drvrs = network->drivers(pin);
if (drvrs) {
PinSet::Iterator drvr_iter(drvrs);
if (drvr_iter.hasNext())
return drvr_iter.next();
}
return nullptr;
}
bool
logicValueZeroOne(LogicValue value)
{
return value == LogicValue::zero || value == LogicValue::one;
}
bool
Sim::logicZeroOne(const Pin *pin) const
{
return logicValueZeroOne(logicValue(pin));
}
bool
Sim::logicZeroOne(const Vertex *vertex) const
{
return logicValueZeroOne(vertex->simValue());
}
void
Sim::clearSimValues()
{
for (const Instance *inst : instances_with_const_pins_) {
// Clear sim values on all pins before evaling functions.
clearInstSimValues(inst);
annotateVertexEdges(inst, false);
}
instances_with_const_pins_.clear();
}
void
Sim::clearInstSimValues(const Instance *inst)
{
debugPrint(debug_, "sim", 4, "clear %s",
network_->pathName(inst));
InstancePinIterator *pin_iter = network_->pinIterator(inst);
while (pin_iter->hasNext()) {
Pin *pin = pin_iter->next();
Vertex *vertex, *bidirect_drvr_vertex;
graph_->pinVertices(pin, vertex, bidirect_drvr_vertex);
if (vertex)
setSimValue(vertex, LogicValue::unknown);
if (bidirect_drvr_vertex)
setSimValue(bidirect_drvr_vertex, LogicValue::unknown);
}
delete pin_iter;
}
// Annotate graph edges disabled by constant values.
void
Sim::annotateGraphEdges()
{
for (const Instance *inst : instances_to_annotate_)
annotateVertexEdges(inst, true);
}
void
Sim::annotateVertexEdges(const Instance *inst,
bool annotate)
{
debugPrint(debug_, "sim", 4, "annotate %s %s",
network_->pathName(inst),
annotate ? "true" : "false");
InstancePinIterator *pin_iter = network_->pinIterator(inst);
while (pin_iter->hasNext()) {
Pin *pin = pin_iter->next();
Vertex *vertex = graph_->pinDrvrVertex(pin);
if (vertex)
annotateVertexEdges(inst, pin, vertex, annotate);
}
delete pin_iter;
}
void
Sim::annotateVertexEdges(const Instance *inst,
const Pin *pin,
Vertex *vertex,
bool annotate)
{
bool fanin_disables_changed = false;
VertexInEdgeIterator edge_iter(vertex, graph_);
while (edge_iter.hasNext()) {
Edge *edge = edge_iter.next();
if (!edge->role()->isWire()) {
Vertex *from_vertex = edge->from(graph_);
Pin *from_pin = from_vertex->pin();
TimingSense sense = TimingSense::unknown;
bool is_disabled_cond = false;
if (annotate) {
// Set timing sense on edges in instances that have constant pins.
if (logicZeroOne(from_vertex))
sense = TimingSense::none;
else
sense = functionSense(inst, from_pin, pin);
if (sense != TimingSense::none)
// Disable conditional timing edges based on constant pins.
is_disabled_cond = isCondDisabled(edge, inst, from_pin,
pin, network_,sim_)
// Disable mode conditional timing
// edges based on constant pins.
|| isModeDisabled(edge,inst,network_,sim_);
}
bool disables_changed = false;
if (sense != edge->simTimingSense()) {
edge->setSimTimingSense(sense);
disables_changed = true;
fanin_disables_changed = true;
}
if (is_disabled_cond != edge->isDisabledCond()) {
edge->setIsDisabledCond(is_disabled_cond);
disables_changed = true;
fanin_disables_changed = true;
}
if (observer_ && disables_changed)
observer_->fanoutEdgesChangeAfter(from_vertex);
}
}
if (observer_ && fanin_disables_changed)
observer_->faninEdgesChangeAfter(vertex);
}
bool
isCondDisabled(Edge *edge,
const Instance *inst,
const Pin *from_pin,
const Pin *to_pin,
const Network *network,
Sim *sim)
{
bool is_disabled;
FuncExpr *disable_cond;
isCondDisabled(edge, inst, from_pin, to_pin, network, sim,
is_disabled, disable_cond);
return is_disabled;
}
void
isCondDisabled(Edge *edge,
const Instance *inst,
const Pin *from_pin,
const Pin *to_pin,
const Network *network,
Sim *sim,
bool &is_disabled,
FuncExpr *&disable_cond)
{
TimingArcSet *arc_set = edge->timingArcSet();
FuncExpr *cond = arc_set->cond();
if (cond) {
LogicValue cond_value = sim->evalExpr(cond, inst);
disable_cond = cond;
is_disabled = (cond_value == LogicValue::zero);
}
else {
// Unconditional "default" arc set is disabled if another
// conditional arc from/to the same pins is enabled (condition
// evals to logic one).
LibertyCell *cell = network->libertyCell(inst);
LibertyPort *from_port = network->libertyPort(from_pin);
LibertyPort *to_port = network->libertyPort(to_pin);
is_disabled = false;
for (TimingArcSet *cond_set : cell->timingArcSets(from_port, to_port)) {
FuncExpr *cond = cond_set->cond();
if (cond && sim->evalExpr(cond, inst) == LogicValue::one) {
disable_cond = cond;
is_disabled = true;
break;
}
}
}
}
bool
isModeDisabled(Edge *edge,
const Instance *inst,
const Network *network,
Sim *sim)
{
bool is_disabled;
FuncExpr *disable_cond;
isModeDisabled(edge, inst, network, sim,
is_disabled, disable_cond);
return is_disabled;
}
void
isModeDisabled(Edge *edge,
const Instance *inst,
const Network *network,
Sim *sim,
bool &is_disabled,
FuncExpr *&disable_cond)
{
// Default values.
is_disabled = false;
disable_cond = 0;
TimingArcSet *arc_set = edge->timingArcSet();
const char *mode_name = arc_set->modeName();
const char *mode_value = arc_set->modeValue();
if (mode_name && mode_value) {
LibertyCell *cell = network->libertyCell(inst);
ModeDef *mode_def = cell->findModeDef(mode_name);
if (mode_def) {
ModeValueDef *value_def = mode_def->findValueDef(mode_value);
if (value_def) {
FuncExpr *cond = value_def->cond();
if (cond) {
LogicValue cond_value = sim->evalExpr(cond, inst);
if (cond_value == LogicValue::zero) {
// For a mode value to be disabled by having a value of
// logic zero one mode value must logic one.
for (const auto [name, value_def] : *mode_def->values()) {
if (value_def) {
FuncExpr *cond1 = value_def->cond();
if (cond1) {
LogicValue cond_value1 = sim->evalExpr(cond1, inst);
if (cond_value1 == LogicValue::one) {
disable_cond = cond;
is_disabled = true;
break;
}
}
}
}
}
}
}
}
}
}
} // namespace
Reference in New Issue View Git Blame Copy Permalink