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

ReportPath const 

commit 4d332349276d687b836e38a6b5fd80f0891094cd
Author: James Cherry <cherry@parallaxsw.com>
Date:   Wed Jan 29 17:53:02 2025 -0700

    GraphDelayCalc const

    Signed-off-by: James Cherry <cherry@parallaxsw.com>

commit e1a397ef8f3b50c2ca939a2312d1e76b73c358a9
Author: James Cherry <cherry@parallaxsw.com>
Date:   Tue Jan 28 19:14:09 2025 -0700

    ReportPath const

    Signed-off-by: James Cherry <cherry@parallaxsw.com>

commit fe876cf884f1c1615e28dfcdda9a509cb01cd364
Author: James Cherry <cherry@parallaxsw.com>
Date:   Tue Jan 28 16:48:29 2025 -0700

    const

    Signed-off-by: James Cherry <cherry@parallaxsw.com>

Signed-off-by: James Cherry <cherry@parallaxsw.com>
This commit is contained in:
James Cherry 2025-02-01 14:53:28 -08:00
parent 398a22e97d
commit c12059e180
20 changed files with 553 additions and 583 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
dcalc/GraphDelayCalc.cc
View File

@ -321,8 +321,8 @@ GraphDelayCalc::seedDrvrSlew(Vertex *drvr_vertex,
Port *port = network_->port(drvr_pin); Port *port = network_->port(drvr_pin);
drive = sdc_->findInputDrive(port); drive = sdc_->findInputDrive(port);
} }
for (auto rf : RiseFall::range()) { for (const RiseFall *rf : RiseFall::range()) {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
if (drive) { if (drive) {
const MinMax *cnst_min_max = dcalc_ap->constraintMinMax(); const MinMax *cnst_min_max = dcalc_ap->constraintMinMax();
const LibertyCell *drvr_cell; const LibertyCell *drvr_cell;
@ -350,8 +350,8 @@ void
GraphDelayCalc::seedNoDrvrCellSlew(Vertex *drvr_vertex, GraphDelayCalc::seedNoDrvrCellSlew(Vertex *drvr_vertex,
const Pin *drvr_pin, const Pin *drvr_pin,
const RiseFall *rf, const RiseFall *rf,
InputDrive *drive, const InputDrive *drive,
DcalcAnalysisPt *dcalc_ap, const DcalcAnalysisPt *dcalc_ap,
ArcDelayCalc *arc_delay_calc) ArcDelayCalc *arc_delay_calc)
{ {
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
@ -397,7 +397,7 @@ void
GraphDelayCalc::seedNoDrvrSlew(Vertex *drvr_vertex, GraphDelayCalc::seedNoDrvrSlew(Vertex *drvr_vertex,
const Pin *drvr_pin, const Pin *drvr_pin,
const RiseFall *rf, const RiseFall *rf,
DcalcAnalysisPt *dcalc_ap, const DcalcAnalysisPt *dcalc_ap,
ArcDelayCalc *arc_delay_calc) ArcDelayCalc *arc_delay_calc)
{ {
const MinMax *slew_min_max = dcalc_ap->slewMinMax(); const MinMax *slew_min_max = dcalc_ap->slewMinMax();
@ -429,8 +429,8 @@ GraphDelayCalc::seedLoadSlew(Vertex *vertex)
vertex->name(sdc_network_)); vertex->name(sdc_network_));
ClockSet *clks = sdc_->findLeafPinClocks(pin); ClockSet *clks = sdc_->findLeafPinClocks(pin);
initSlew(vertex); initSlew(vertex);
for (auto rf : RiseFall::range()) { for (const RiseFall *rf : RiseFall::range()) {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *slew_min_max = dcalc_ap->slewMinMax(); const MinMax *slew_min_max = dcalc_ap->slewMinMax();
if (!vertex->slewAnnotated(rf, slew_min_max)) { if (!vertex->slewAnnotated(rf, slew_min_max)) {
float slew = 0.0; float slew = 0.0;
@ -807,11 +807,11 @@ GraphDelayCalc::initLoadSlews(Vertex *drvr_vertex)
Edge *wire_edge = edge_iter.next(); Edge *wire_edge = edge_iter.next();
if (wire_edge->isWire()) { if (wire_edge->isWire()) {
Vertex *load_vertex = wire_edge->to(graph_); Vertex *load_vertex = wire_edge->to(graph_);
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *slew_min_max = dcalc_ap->slewMinMax(); const MinMax *slew_min_max = dcalc_ap->slewMinMax();
Slew slew_init_value(slew_min_max->initValue()); Slew slew_init_value(slew_min_max->initValue());
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
for (auto rf : RiseFall::range()) { for (const RiseFall *rf : RiseFall::range()) {
if (!load_vertex->slewAnnotated(rf, slew_min_max)) if (!load_vertex->slewAnnotated(rf, slew_min_max))
graph_->setSlew(load_vertex, rf, ap_index, slew_init_value); graph_->setSlew(load_vertex, rf, ap_index, slew_init_value);
} }
@ -827,7 +827,6 @@ GraphDelayCalc::findDriverDelays1(Vertex *drvr_vertex,
LoadPinIndexMap &load_pin_index_map) LoadPinIndexMap &load_pin_index_map)
{ {
initSlew(drvr_vertex); initSlew(drvr_vertex);
initWireDelays(drvr_vertex);
bool delay_changed = false; bool delay_changed = false;
array<bool, RiseFall::index_count> delay_exists = {false, false}; array<bool, RiseFall::index_count> delay_exists = {false, false};
VertexInEdgeIterator edge_iter(drvr_vertex, graph_); VertexInEdgeIterator edge_iter(drvr_vertex, graph_);
@ -842,7 +841,7 @@ GraphDelayCalc::findDriverDelays1(Vertex *drvr_vertex,
arc_delay_calc, load_pin_index_map, arc_delay_calc, load_pin_index_map,
delay_exists); delay_exists);
} }
for (auto rf : RiseFall::range()) { for (const RiseFall *rf : RiseFall::range()) {
if (!delay_exists[rf->index()]) if (!delay_exists[rf->index()])
zeroSlewAndWireDelays(drvr_vertex, rf); zeroSlewAndWireDelays(drvr_vertex, rf);
} }
@ -856,10 +855,10 @@ GraphDelayCalc::findDriverDelays1(Vertex *drvr_vertex,
void void
GraphDelayCalc::initRootSlews(Vertex *vertex) GraphDelayCalc::initRootSlews(Vertex *vertex)
{ {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *slew_min_max = dcalc_ap->slewMinMax(); const MinMax *slew_min_max = dcalc_ap->slewMinMax();
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
for (auto rf : RiseFall::range()) { for (const RiseFall *rf : RiseFall::range()) {
if (!vertex->slewAnnotated(rf, slew_min_max)) if (!vertex->slewAnnotated(rf, slew_min_max))
graph_->setSlew(vertex, rf, ap_index, default_slew); graph_->setSlew(vertex, rf, ap_index, default_slew);
} }
@ -895,7 +894,7 @@ GraphDelayCalc::findDriverEdgeDelays(Vertex *drvr_vertex,
Vertex *from_vertex = edge->from(graph_); Vertex *from_vertex = edge->from(graph_);
const TimingArcSet *arc_set = edge->timingArcSet(); const TimingArcSet *arc_set = edge->timingArcSet();
bool delay_changed = false; bool delay_changed = false;
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
for (const TimingArc *arc : arc_set->arcs()) { for (const TimingArc *arc : arc_set->arcs()) {
delay_changed |= findDriverArcDelays(drvr_vertex, multi_drvr, edge, arc, delay_changed |= findDriverArcDelays(drvr_vertex, multi_drvr, edge, arc,
dcalc_ap, arc_delay_calc, dcalc_ap, arc_delay_calc,
@ -982,7 +981,7 @@ GraphDelayCalc::makeArcDcalcArgs(Vertex *drvr_vertex,
ArcDelayCalc *arc_delay_calc) ArcDelayCalc *arc_delay_calc)
{ {
ArcDcalcArgSeq dcalc_args; ArcDcalcArgSeq dcalc_args;
for (auto drvr_vertex1 : multi_drvr->drvrs()) { for (Vertex *drvr_vertex1 : multi_drvr->drvrs()) {
Edge *edge1 = nullptr; Edge *edge1 = nullptr;
const TimingArc *arc1 = nullptr; const TimingArc *arc1 = nullptr;
if (drvr_vertex1 == drvr_vertex) { if (drvr_vertex1 == drvr_vertex) {
@ -1212,7 +1211,7 @@ GraphDelayCalc::loadCap(const Pin *drvr_pin,
{ {
const MinMax *min_max = dcalc_ap->constraintMinMax(); const MinMax *min_max = dcalc_ap->constraintMinMax();
float load_cap = min_max->initValue(); float load_cap = min_max->initValue();
for (auto drvr_rf : RiseFall::range()) { for (const RiseFall *drvr_rf : RiseFall::range()) {
float cap = loadCap(drvr_pin, drvr_rf, dcalc_ap); float cap = loadCap(drvr_pin, drvr_rf, dcalc_ap);
load_cap = min_max->minMax(cap, load_cap); load_cap = min_max->minMax(cap, load_cap);
} }
@ -1359,8 +1358,8 @@ GraphDelayCalc::netCaps(const Pin *drvr_pin,
void void
GraphDelayCalc::initSlew(Vertex *vertex) GraphDelayCalc::initSlew(Vertex *vertex)
{ {
for (auto rf : RiseFall::range()) { for (const RiseFall *rf : RiseFall::range()) {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *slew_min_max = dcalc_ap->slewMinMax(); const MinMax *slew_min_max = dcalc_ap->slewMinMax();
if (!vertex->slewAnnotated(rf, slew_min_max)) { if (!vertex->slewAnnotated(rf, slew_min_max)) {
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
@ -1374,7 +1373,7 @@ void
GraphDelayCalc::zeroSlewAndWireDelays(Vertex *drvr_vertex, GraphDelayCalc::zeroSlewAndWireDelays(Vertex *drvr_vertex,
const RiseFall *rf) const RiseFall *rf)
{ {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
const MinMax *slew_min_max = dcalc_ap->slewMinMax(); const MinMax *slew_min_max = dcalc_ap->slewMinMax();
// Init drvr slew. // Init drvr slew.
@ -1406,11 +1405,11 @@ GraphDelayCalc::initWireDelays(Vertex *drvr_vertex)
while (edge_iter.hasNext()) { while (edge_iter.hasNext()) {
Edge *wire_edge = edge_iter.next(); Edge *wire_edge = edge_iter.next();
if (wire_edge->isWire()) { if (wire_edge->isWire()) {
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt * dcalc_ap : corners_->dcalcAnalysisPts()) {
const MinMax *delay_min_max = dcalc_ap->delayMinMax(); const MinMax *delay_min_max = dcalc_ap->delayMinMax();
Delay delay_init_value(delay_min_max->initValue()); Delay delay_init_value(delay_min_max->initValue());
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
for (auto rf : RiseFall::range()) { for (const RiseFall *rf : RiseFall::range()) {
if (!graph_->wireDelayAnnotated(wire_edge, rf, ap_index)) if (!graph_->wireDelayAnnotated(wire_edge, rf, ap_index))
graph_->setWireArcDelay(wire_edge, rf, ap_index, delay_init_value); graph_->setWireArcDelay(wire_edge, rf, ap_index, delay_init_value);
} }
@ -1466,7 +1465,7 @@ GraphDelayCalc::findCheckEdgeDelays(Edge *edge,
const Pin *related_out_pin = 0; const Pin *related_out_pin = 0;
if (related_out_port) if (related_out_port)
related_out_pin = network_->findPin(inst, related_out_port); related_out_pin = network_->findPin(inst, related_out_port);
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
if (!graph_->arcDelayAnnotated(edge, arc, ap_index)) { if (!graph_->arcDelayAnnotated(edge, arc, ap_index)) {
const Slew &from_slew = checkEdgeClkSlew(from_vertex, from_rf, const Slew &from_slew = checkEdgeClkSlew(from_vertex, from_rf,
@ -1583,7 +1582,7 @@ GraphDelayCalc::minPeriod(const Pin *pin,
{ {
exists = false; exists = false;
const MinMax *min_max = MinMax::max(); const MinMax *min_max = MinMax::max();
for (auto dcalc_ap : corners_->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners_->dcalcAnalysisPts()) {
// Sdf annotation. // Sdf annotation.
float min_period1 = 0.0; float min_period1 = 0.0;
bool exists1 = false; bool exists1 = false;
@ -1639,11 +1638,11 @@ MultiDrvrNet::findCaps(const Sdc *sdc)
int count = RiseFall::index_count * corners->dcalcAnalysisPtCount(); int count = RiseFall::index_count * corners->dcalcAnalysisPtCount();
net_caps_.resize(count); net_caps_.resize(count);
const Pin *drvr_pin = dcalc_drvr_->pin(); const Pin *drvr_pin = dcalc_drvr_->pin();
for (auto dcalc_ap : corners->dcalcAnalysisPts()) { for (const DcalcAnalysisPt *dcalc_ap : corners->dcalcAnalysisPts()) {
DcalcAPIndex ap_index = dcalc_ap->index(); DcalcAPIndex ap_index = dcalc_ap->index();
const Corner *corner = dcalc_ap->corner(); const Corner *corner = dcalc_ap->corner();
const MinMax *min_max = dcalc_ap->constraintMinMax(); const MinMax *min_max = dcalc_ap->constraintMinMax();
for (auto drvr_rf : RiseFall::range()) { for (const RiseFall *drvr_rf : RiseFall::range()) {
int drvr_rf_index = drvr_rf->index(); int drvr_rf_index = drvr_rf->index();
int index = ap_index * RiseFall::index_count + drvr_rf_index; int index = ap_index * RiseFall::index_count + drvr_rf_index;
NetCaps &net_caps = net_caps_[index]; NetCaps &net_caps = net_caps_[index];

4
include/sta/ExceptionPath.hh
View File

@ -125,7 +125,7 @@ public:
virtual float delay() const { return 0.0; } virtual float delay() const { return 0.0; }
virtual const char *name() const { return nullptr; } virtual const char *name() const { return nullptr; }
virtual bool isDefault() const { return false; } virtual bool isDefault() const { return false; }
virtual bool ignoreClkLatency() { return false; } virtual bool ignoreClkLatency() const { return false; }
protected: protected:
virtual const char *typeString() const = 0; virtual const char *typeString() const = 0;
@ -210,7 +210,7 @@ public:
virtual float delay() const { return delay_; } virtual float delay() const { return delay_; }
virtual int typePriority() const; virtual int typePriority() const;
virtual bool tighterThan(ExceptionPath *exception) const; virtual bool tighterThan(ExceptionPath *exception) const;
virtual bool ignoreClkLatency() { return ignore_clk_latency_; } virtual bool ignoreClkLatency() const { return ignore_clk_latency_; }
protected: protected:
bool ignore_clk_latency_; bool ignore_clk_latency_;

6
include/sta/GraphDelayCalc.hh
View File

@ -144,13 +144,13 @@ protected:
void seedNoDrvrSlew(Vertex *drvr_vertex, void seedNoDrvrSlew(Vertex *drvr_vertex,
const Pin *drvr_pin, const Pin *drvr_pin,
const RiseFall *rf, const RiseFall *rf,
DcalcAnalysisPt *dcalc_ap, const DcalcAnalysisPt *dcalc_ap,
ArcDelayCalc *arc_delay_calc); ArcDelayCalc *arc_delay_calc);
void seedNoDrvrCellSlew(Vertex *drvr_vertex, void seedNoDrvrCellSlew(Vertex *drvr_vertex,
const Pin *drvr_pin, const Pin *drvr_pin,
const RiseFall *rf, const RiseFall *rf,
InputDrive *drive, const InputDrive *drive,
DcalcAnalysisPt *dcalc_ap, const DcalcAnalysisPt *dcalc_ap,
ArcDelayCalc *arc_delay_calc); ArcDelayCalc *arc_delay_calc);
void seedLoadSlew(Vertex *vertex); void seedLoadSlew(Vertex *vertex);
void setInputPortWireDelays(Vertex *vertex); void setInputPortWireDelays(Vertex *vertex);

18
include/sta/InputDrive.hh
View File

@ -51,10 +51,10 @@ public:
void driveResistance(const RiseFall *rf, void driveResistance(const RiseFall *rf,
const MinMax *min_max, const MinMax *min_max,
float &res, float &res,
bool &exists); bool &exists) const;
bool hasDriveResistance(const RiseFall *rf, bool hasDriveResistance(const RiseFall *rf,
const MinMax *min_max); const MinMax *min_max) const;
bool driveResistanceMinMaxEqual(const RiseFall *rf); bool driveResistanceMinMaxEqual(const RiseFall *rf) const;
void setDriveCell(const LibertyLibrary *library, void setDriveCell(const LibertyLibrary *library,
const LibertyCell *cell, const LibertyCell *cell,
const LibertyPort *from_port, const LibertyPort *from_port,
@ -68,18 +68,18 @@ public:
const LibertyCell *&cell, const LibertyCell *&cell,
const LibertyPort *&from_port, const LibertyPort *&from_port,
float *&from_slews, float *&from_slews,
const LibertyPort *&to_port); const LibertyPort *&to_port) const;
InputDriveCell *driveCell(const RiseFall *rf, InputDriveCell *driveCell(const RiseFall *rf,
const MinMax *min_max); const MinMax *min_max) const;
bool hasDriveCell(const RiseFall *rf, bool hasDriveCell(const RiseFall *rf,
const MinMax *min_max); const MinMax *min_max) const;
// True if rise/fall/min/max drive cells are equal. // True if rise/fall/min/max drive cells are equal.
bool driveCellsEqual(); bool driveCellsEqual() const;
void slew(const RiseFall *rf, void slew(const RiseFall *rf,
const MinMax *min_max, const MinMax *min_max,
float &slew, float &slew,
bool &exists); bool &exists) const;
RiseFallMinMax *slews() { return &slews_; } const RiseFallMinMax *slews() const { return &slews_; }
private: private:
RiseFallMinMax slews_; RiseFallMinMax slews_;

32
include/sta/PathEnd.hh
View File

@ -85,8 +85,8 @@ public:
const RiseFall *transition(const StaState *sta) const; const RiseFall *transition(const StaState *sta) const;
PathAnalysisPt *pathAnalysisPt(const StaState *sta) const; PathAnalysisPt *pathAnalysisPt(const StaState *sta) const;
PathAPIndex pathIndex(const StaState *sta) const; PathAPIndex pathIndex(const StaState *sta) const;
virtual void reportShort(ReportPath *report) const = 0; virtual void reportShort(const ReportPath *report) const = 0;
virtual void reportFull(ReportPath *report) const = 0; virtual void reportFull(const ReportPath *report) const = 0;
// Predicates for PathEnd type. // Predicates for PathEnd type.
// Default methods overridden by respective types. // Default methods overridden by respective types.
@ -228,8 +228,8 @@ public:
virtual Type type() const; virtual Type type() const;
virtual const char *typeName() const; virtual const char *typeName() const;
virtual PathEnd *copy(); virtual PathEnd *copy();
virtual void reportShort(ReportPath *report) const; virtual void reportShort(const ReportPath *report) const;
virtual void reportFull(ReportPath *report) const; virtual void reportFull(const ReportPath *report) const;
virtual bool isUnconstrained() const; virtual bool isUnconstrained() const;
virtual Required requiredTime(const StaState *sta) const; virtual Required requiredTime(const StaState *sta) const;
virtual Required requiredTimeOffset(const StaState *sta) const; virtual Required requiredTimeOffset(const StaState *sta) const;
@ -327,8 +327,8 @@ public:
virtual PathEnd *copy(); virtual PathEnd *copy();
virtual Type type() const; virtual Type type() const;
virtual const char *typeName() const; virtual const char *typeName() const;
virtual void reportShort(ReportPath *report) const; virtual void reportShort(const ReportPath *report) const;
virtual void reportFull(ReportPath *report) const; virtual void reportFull(const ReportPath *report) const;
virtual bool isCheck() const { return true; } virtual bool isCheck() const { return true; }
virtual ArcDelay margin(const StaState *sta) const; virtual ArcDelay margin(const StaState *sta) const;
virtual float macroClkTreeDelay(const StaState *sta) const; virtual float macroClkTreeDelay(const StaState *sta) const;
@ -373,8 +373,8 @@ public:
virtual PathEnd *copy(); virtual PathEnd *copy();
PathVertex *latchDisable(); PathVertex *latchDisable();
const PathVertex *latchDisable() const; const PathVertex *latchDisable() const;
virtual void reportShort(ReportPath *report) const; virtual void reportShort(const ReportPath *report) const;
virtual void reportFull(ReportPath *report) const; virtual void reportFull(const ReportPath *report) const;
virtual TimingRole *checkRole(const StaState *sta) const; virtual TimingRole *checkRole(const StaState *sta) const;
virtual Required requiredTime(const StaState *sta) const; virtual Required requiredTime(const StaState *sta) const;
virtual Arrival borrow(const StaState *sta) const; virtual Arrival borrow(const StaState *sta) const;
@ -432,8 +432,8 @@ public:
virtual PathEnd *copy(); virtual PathEnd *copy();
virtual Type type() const; virtual Type type() const;
virtual const char *typeName() const; virtual const char *typeName() const;
virtual void reportShort(ReportPath *report) const; virtual void reportShort(const ReportPath *report) const;
virtual void reportFull(ReportPath *report) const; virtual void reportFull(const ReportPath *report) const;
virtual bool isOutputDelay() const { return true; } virtual bool isOutputDelay() const { return true; }
virtual ArcDelay margin(const StaState *sta) const; virtual ArcDelay margin(const StaState *sta) const;
virtual TimingRole *checkRole(const StaState *sta) const; virtual TimingRole *checkRole(const StaState *sta) const;
@ -478,8 +478,8 @@ public:
virtual PathEnd *copy(); virtual PathEnd *copy();
virtual Type type() const; virtual Type type() const;
virtual const char *typeName() const; virtual const char *typeName() const;
virtual void reportShort(ReportPath *report) const; virtual void reportShort(const ReportPath *report) const;
virtual void reportFull(ReportPath *report) const; virtual void reportFull(const ReportPath *report) const;
virtual bool isGatedClock() const { return true; } virtual bool isGatedClock() const { return true; }
virtual ArcDelay margin(const StaState *) const { return margin_; } virtual ArcDelay margin(const StaState *) const { return margin_; }
virtual TimingRole *checkRole(const StaState *sta) const; virtual TimingRole *checkRole(const StaState *sta) const;
@ -510,8 +510,8 @@ public:
virtual PathEnd *copy(); virtual PathEnd *copy();
virtual Type type() const; virtual Type type() const;
virtual const char *typeName() const; virtual const char *typeName() const;
virtual void reportShort(ReportPath *report) const; virtual void reportShort(const ReportPath *report) const;
virtual void reportFull(ReportPath *report) const; virtual void reportFull(const ReportPath *report) const;
virtual bool isDataCheck() const { return true; } virtual bool isDataCheck() const { return true; }
virtual const ClockEdge *targetClkEdge(const StaState *sta) const; virtual const ClockEdge *targetClkEdge(const StaState *sta) const;
virtual TimingRole *checkRole(const StaState *sta) const; virtual TimingRole *checkRole(const StaState *sta) const;
@ -566,8 +566,8 @@ public:
virtual PathEnd *copy(); virtual PathEnd *copy();
virtual Type type() const; virtual Type type() const;
virtual const char *typeName() const; virtual const char *typeName() const;
virtual void reportShort(ReportPath *report) const; virtual void reportShort(const ReportPath *report) const;
virtual void reportFull(ReportPath *report) const; virtual void reportFull(const ReportPath *report) const;
virtual bool isPathDelay() const { return true; } virtual bool isPathDelay() const { return true; }
virtual TimingRole *checkRole(const StaState *sta) const; virtual TimingRole *checkRole(const StaState *sta) const;
virtual bool pathDelayMarginIsExternal() const; virtual bool pathDelayMarginIsExternal() const;

18
include/sta/PathExpanded.hh
View File

@ -49,20 +49,20 @@ public:
// path(0) is the startpoint. // path(0) is the startpoint.
// path(size()-1) is the endpoint. // path(size()-1) is the endpoint.
const PathRef *path(size_t index) const; const PathRef *path(size_t index) const;
TimingArc *prevArc(size_t index); TimingArc *prevArc(size_t index) const;
// Returns the path start point. // Returns the path start point.
// Register/Latch Q pin // Register/Latch Q pin
// Input pin // Input pin
PathRef *startPath(); const PathRef *startPath() const;
PathRef *startPrevPath(); const PathRef *startPrevPath() const;
PathRef *endPath(); const PathRef *endPath() const;
TimingArc *startPrevArc(); TimingArc *startPrevArc() const;
size_t startIndex() const; size_t startIndex() const;
void clkPath(PathRef &clk_path); void clkPath(PathRef &clk_path) const;
void latchPaths(// Return values. void latchPaths(// Return values.
PathRef *&d_path, const PathRef *&d_path,
PathRef *&q_path, const PathRef *&q_path,
Edge *&d_q_edge); Edge *&d_q_edge) const;
protected: protected:
void expandGenclk(PathRef *clk_path); void expandGenclk(PathRef *clk_path);

12
include/sta/Search.hh
View File

@ -341,9 +341,9 @@ public:
Arrival insertion, Arrival insertion,
const PathAnalysisPt *path_ap); const PathAnalysisPt *path_ap);
// Timing derated arc delay for a path analysis point. // Timing derated arc delay for a path analysis point.
ArcDelay deratedDelay(Vertex *from_vertex, ArcDelay deratedDelay(const Vertex *from_vertex,
TimingArc *arc, const TimingArc *arc,
Edge *edge, const Edge *edge,
bool is_clk, bool is_clk,
const PathAnalysisPt *path_ap); const PathAnalysisPt *path_ap);
@ -501,9 +501,9 @@ protected:
void findArrivalsSeed(); void findArrivalsSeed();
void seedFilterStarts(); void seedFilterStarts();
bool hasEnabledChecks(Vertex *vertex) const; bool hasEnabledChecks(Vertex *vertex) const;
virtual float timingDerate(Vertex *from_vertex, virtual float timingDerate(const Vertex *from_vertex,
TimingArc *arc, const TimingArc *arc,
Edge *edge, const Edge *edge,
bool is_clk, bool is_clk,
const PathAnalysisPt *path_ap); const PathAnalysisPt *path_ap);
void deletePaths(); void deletePaths();

2
include/sta/Sta.hh
View File

@ -922,7 +922,7 @@ public:
void reportPathEnd(PathEnd *end); void reportPathEnd(PathEnd *end);
void reportPathEnds(PathEndSeq *ends); void reportPathEnds(PathEndSeq *ends);
ReportPath *reportPath() { return report_path_; } ReportPath *reportPath() { return report_path_; }
void reportPath(Path *path); void reportPath(const Path *path);
// Report clk skews for clks. // Report clk skews for clks.
void reportClkSkew(ConstClockSeq &clks, void reportClkSkew(ConstClockSeq &clks,

17
sdc/InputDrive.cc
View File

@ -64,19 +64,20 @@ void
InputDrive::driveResistance(const RiseFall *rf, InputDrive::driveResistance(const RiseFall *rf,
const MinMax *min_max, const MinMax *min_max,
float &res, float &res,
bool &exists) bool &exists) const
{ {
drive_resistances_.value(rf, min_max, res, exists); drive_resistances_.value(rf, min_max, res, exists);
} }
bool bool
InputDrive::hasDriveResistance(const RiseFall *rf, const MinMax *min_max) InputDrive::hasDriveResistance(const RiseFall *rf,
const MinMax *min_max) const
{ {
return drive_resistances_.hasValue(rf, min_max); return drive_resistances_.hasValue(rf, min_max);
} }
bool bool
InputDrive::driveResistanceMinMaxEqual(const RiseFall *rf) InputDrive::driveResistanceMinMaxEqual(const RiseFall *rf) const
{ {
float min_res, max_res; float min_res, max_res;
bool min_exists, max_exists; bool min_exists, max_exists;
@ -120,7 +121,7 @@ InputDrive::driveCell(const RiseFall *rf,
const LibertyCell *&cell, const LibertyCell *&cell,
const LibertyPort *&from_port, const LibertyPort *&from_port,
float *&from_slews, float *&from_slews,
const LibertyPort *&to_port) const LibertyPort *&to_port) const
{ {
InputDriveCell *drive = drive_cells_[rf->index()][min_max->index()]; InputDriveCell *drive = drive_cells_[rf->index()][min_max->index()];
if (drive) { if (drive) {
@ -139,20 +140,20 @@ InputDrive::driveCell(const RiseFall *rf,
InputDriveCell * InputDriveCell *
InputDrive::driveCell(const RiseFall *rf, InputDrive::driveCell(const RiseFall *rf,
const MinMax *min_max) const MinMax *min_max) const
{ {
return drive_cells_[rf->index()][min_max->index()]; return drive_cells_[rf->index()][min_max->index()];
} }
bool bool
InputDrive::hasDriveCell(const RiseFall *rf, InputDrive::hasDriveCell(const RiseFall *rf,
const MinMax *min_max) const MinMax *min_max) const
{ {
return drive_cells_[rf->index()][min_max->index()] != nullptr; return drive_cells_[rf->index()][min_max->index()] != nullptr;
} }
bool bool
InputDrive::driveCellsEqual() InputDrive::driveCellsEqual() const
{ {
int rise_index = RiseFall::riseIndex(); int rise_index = RiseFall::riseIndex();
int fall_index = RiseFall::fallIndex(); int fall_index = RiseFall::fallIndex();
@ -171,7 +172,7 @@ void
InputDrive::slew(const RiseFall *rf, InputDrive::slew(const RiseFall *rf,
const MinMax *min_max, const MinMax *min_max,
float &slew, float &slew,
bool &exists) bool &exists) const
{ {
slews_.value(rf, min_max, slew, exists); slews_.value(rf, min_max, slew, exists);
} }

2
sdc/WriteSdc.cc
View File

@ -1716,7 +1716,7 @@ WriteSdc::writeInputTransitions() const
Port *port = port_iter->next(); Port *port = port_iter->next();
InputDrive *drive = sdc_->findInputDrive(port); InputDrive *drive = sdc_->findInputDrive(port);
if (drive) { if (drive) {
RiseFallMinMax *slews = drive->slews(); const RiseFallMinMax *slews = drive->slews();
WriteGetPort write_port(port, this); WriteGetPort write_port(port, this);
writeRiseFallMinMaxTimeCmd("set_input_transition", slews, write_port); writeRiseFallMinMaxTimeCmd("set_input_transition", slews, write_port);
} }

4
search/CheckMaxSkews.hh
View File

@ -61,9 +61,9 @@ public:
PathVertex *ref_path, PathVertex *ref_path,
TimingArc *check_arc, TimingArc *check_arc,
Edge *check_edge); Edge *check_edge);
PathVertex *clkPath() { return &clk_path_; } const PathVertex *clkPath() const { return &clk_path_; }
Pin *clkPin(const StaState *sta) const; Pin *clkPin(const StaState *sta) const;
PathVertex *refPath() { return &ref_path_; } const PathVertex *refPath() const { return &ref_path_; }
Pin *refPin(const StaState *sta) const; Pin *refPin(const StaState *sta) const;
Delay skew(const StaState *sta) const; Delay skew(const StaState *sta) const;
ArcDelay maxSkew(const StaState *sta) const; ArcDelay maxSkew(const StaState *sta) const;

38
search/Latches.cc
View File

@ -51,15 +51,15 @@ void
Latches::latchRequired(const Path *data_path, Latches::latchRequired(const Path *data_path,
const PathVertex *enable_path, const PathVertex *enable_path,
const PathVertex *disable_path, const PathVertex *disable_path,
MultiCyclePath *mcp, const MultiCyclePath *mcp,
PathDelay *path_delay, const PathDelay *path_delay,
Arrival src_clk_latency, Arrival src_clk_latency,
const ArcDelay &margin, const ArcDelay &margin,
// Return values. // Return values.
Required &required, Required &required,
Arrival &borrow, Arrival &borrow,
Arrival &adjusted_data_arrival, Arrival &adjusted_data_arrival,
Delay &time_given_to_startpoint) Delay &time_given_to_startpoint) const
{ {
const Arrival data_arrival = data_path->arrival(this); const Arrival data_arrival = data_path->arrival(this);
float max_delay = 0.0; float max_delay = 0.0;
@ -161,7 +161,7 @@ Latches::latchBorrowInfo(const Path *data_path,
Crpr &open_crpr, Crpr &open_crpr,
Crpr &crpr_diff, Crpr &crpr_diff,
Delay &max_borrow, Delay &max_borrow,
bool &borrow_limit_exists) bool &borrow_limit_exists) const
{ {
if (data_path && enable_path && disable_path) { if (data_path && enable_path && disable_path) {
const ClockEdge *data_clk_edge = data_path->clkEdge(this); const ClockEdge *data_clk_edge = data_path->clkEdge(this);
@ -220,7 +220,7 @@ Latches::latchRequired(const Path *data_path,
Required &required, Required &required,
Arrival &borrow, Arrival &borrow,
Arrival &adjusted_data_arrival, Arrival &adjusted_data_arrival,
Delay &time_given_to_startpoint) Delay &time_given_to_startpoint) const
{ {
Vertex *data_vertex = data_path->vertex(this); Vertex *data_vertex = data_path->vertex(this);
const RiseFall *data_rf = data_path->transition(this); const RiseFall *data_rf = data_path->transition(this);
@ -244,10 +244,10 @@ Latches::latchRequired(const Path *data_path,
// Find the latch enable open/close path from the close/open path. // Find the latch enable open/close path from the close/open path.
void void
Latches::latchEnableOtherPath(Path *path, Latches::latchEnableOtherPath(const Path *path,
const PathAnalysisPt *tgt_clk_path_ap, const PathAnalysisPt *tgt_clk_path_ap,
// Return value. // Return value.
PathVertex &other_path) PathVertex &other_path) const
{ {
Vertex *vertex = path->vertex(this); Vertex *vertex = path->vertex(this);
const ClockEdge *clk_edge = path->clkEdge(this); const ClockEdge *clk_edge = path->clkEdge(this);
@ -266,8 +266,8 @@ Latches::latchEnableOtherPath(Path *path,
} }
void void
Latches::latchEnablePath(Path *q_path, Latches::latchEnablePath(const Path *q_path,
Edge *d_q_edge, const Edge *d_q_edge,
// Return value. // Return value.
PathVertex &enable_path) const PathVertex &enable_path) const
@ -299,9 +299,9 @@ Latches::latchEnablePath(Path *q_path,
// times of the enable. The to_tag for Q is adjusted to the that of // times of the enable. The to_tag for Q is adjusted to the that of
// the enable open edge. // the enable open edge.
void void
Latches::latchOutArrival(Path *data_path, Latches::latchOutArrival(const Path *data_path,
TimingArc *d_q_arc, const TimingArc *d_q_arc,
Edge *d_q_edge, const Edge *d_q_edge,
const PathAnalysisPt *path_ap, const PathAnalysisPt *path_ap,
// Return values. // Return values.
Tag *&q_tag, Tag *&q_tag,
@ -398,7 +398,7 @@ Latches::latchOutArrival(Path *data_path,
} }
ExceptionPath * ExceptionPath *
Latches::exceptionTo(Path *data_path, Latches::exceptionTo(const Path *data_path,
const ClockEdge *en_clk_edge) const ClockEdge *en_clk_edge)
{ {
// Look for exceptions -to data or -to enable clk. // Look for exceptions -to data or -to enable clk.
@ -415,7 +415,7 @@ ArcDelay
Latches::latchSetupMargin(Vertex *data_vertex, Latches::latchSetupMargin(Vertex *data_vertex,
const RiseFall *data_rf, const RiseFall *data_rf,
const Path *disable_path, const Path *disable_path,
const PathAnalysisPt *path_ap) const PathAnalysisPt *path_ap) const
{ {
if (disable_path) { if (disable_path) {
Vertex *enable_vertex = disable_path->vertex(this); Vertex *enable_vertex = disable_path->vertex(this);
@ -443,12 +443,12 @@ Latches::latchSetupMargin(Vertex *data_vertex,
} }
void void
Latches::latchTimeGivenToStartpoint(Path *d_path, Latches::latchTimeGivenToStartpoint(const Path *d_path,
Path *q_path, const Path *q_path,
Edge *d_q_edge, const Edge *d_q_edge,
// Return values. // Return values.
Arrival &time_given, Arrival &time_given,
PathVertex &enable_path) PathVertex &enable_path) const
{ {
latchEnablePath(q_path, d_q_edge, enable_path); latchEnablePath(q_path, d_q_edge, enable_path);
if (!enable_path.isNull() if (!enable_path.isNull()
@ -470,7 +470,7 @@ Latches::latchTimeGivenToStartpoint(Path *d_path,
} }
void void
Latches::latchDtoQEnable(Edge *d_q_edge, Latches::latchDtoQEnable(const Edge *d_q_edge,
const Instance *inst, const Instance *inst,
// Return values. // Return values.
Vertex *&enable_vertex, Vertex *&enable_vertex,

37
search/Latches.hh
View File

@ -38,24 +38,24 @@ class Latches : public StaState
{ {
public: public:
Latches(StaState *sta); Latches(StaState *sta);
void latchTimeGivenToStartpoint(Path *d_path, void latchTimeGivenToStartpoint(const Path *d_path,
Path *q_path, const Path *q_path,
Edge *d_q_edge, const Edge *d_q_edge,
// Return values. // Return values.
Arrival &time_given, Arrival &time_given,
PathVertex &enable_path); PathVertex &enable_path) const;
void latchRequired(const Path *data_path, void latchRequired(const Path *data_path,
const PathVertex *enable_path, const PathVertex *enable_path,
const PathVertex *disable_path, const PathVertex *disable_path,
MultiCyclePath *mcp, const MultiCyclePath *mcp,
PathDelay *path_delay, const PathDelay *path_delay,
Arrival src_clk_latency, Arrival src_clk_latency,
const ArcDelay &margin, const ArcDelay &margin,
// Return values. // Return values.
Required &required, Required &required,
Delay &borrow, Delay &borrow,
Arrival &adjusted_data_arrival, Arrival &adjusted_data_arrival,
Delay &time_given_to_startpoint); Delay &time_given_to_startpoint) const;
void latchRequired(const Path *data_path, void latchRequired(const Path *data_path,
const PathVertex *enable_path, const PathVertex *enable_path,
const PathVertex *disable_path, const PathVertex *disable_path,
@ -64,7 +64,7 @@ public:
Required &required, Required &required,
Delay &borrow, Delay &borrow,
Arrival &adjusted_data_arrival, Arrival &adjusted_data_arrival,
Delay &time_given_to_startpoint); Delay &time_given_to_startpoint) const;
void latchBorrowInfo(const Path *data_path, void latchBorrowInfo(const Path *data_path,
const PathVertex *enable_path, const PathVertex *enable_path,
const PathVertex *disable_path, const PathVertex *disable_path,
@ -78,26 +78,27 @@ public:
Crpr &open_crpr, Crpr &open_crpr,
Crpr &crpr_diff, Crpr &crpr_diff,
Delay &max_borrow, Delay &max_borrow,
bool &borrow_limit_exists); bool &borrow_limit_exists) const;
bool isLatchDtoQ(Edge *edge) const; bool isLatchDtoQ(Edge *edge) const;
// Find the latch EN->Q edge for a D->Q edge. // Find the latch EN->Q edge for a D->Q edge.
void latchDtoQEnable(Edge *d_q_edge, void latchDtoQEnable(const Edge *d_q_edge,
const Instance *inst, const Instance *inst,
// Return values. // Return values.
Vertex *&enable_vertex, Vertex *&enable_vertex,
const RiseFall *&enable_rf, const RiseFall *&enable_rf,
LatchEnableState &state) const; LatchEnableState &state) const;
LatchEnableState latchDtoQState(Edge *d_q_edge) const; LatchEnableState latchDtoQState(Edge *d_q_edge) const;
void latchEnableOtherPath(Path *path, void latchEnableOtherPath(const Path *path,
const PathAnalysisPt *tgt_clk_path_ap, const PathAnalysisPt *tgt_clk_path_ap,
// Return value. // Return value.
PathVertex &other_path); PathVertex &other_path) const;
void latchEnablePath(Path *q_path, Edge *d_q_edge, void latchEnablePath(const Path *q_path,
const Edge *d_q_edge,
// Return value. // Return value.
PathVertex &enable_path) const; PathVertex &enable_path) const;
void latchOutArrival(Path *data_path, void latchOutArrival(const Path *data_path,
TimingArc *d_q_arc, const TimingArc *d_q_arc,
Edge *d_q_edge, const Edge *d_q_edge,
const PathAnalysisPt *path_ap, const PathAnalysisPt *path_ap,
Tag *&q_tag, Tag *&q_tag,
ArcDelay &arc_delay, ArcDelay &arc_delay,
@ -107,8 +108,8 @@ protected:
ArcDelay latchSetupMargin(Vertex *data_vertex, ArcDelay latchSetupMargin(Vertex *data_vertex,
const RiseFall *data_rf, const RiseFall *data_rf,
const Path *disable_path, const Path *disable_path,
const PathAnalysisPt *path_ap); const PathAnalysisPt *path_ap) const;
ExceptionPath *exceptionTo(Path *data_path, ExceptionPath *exceptionTo(const Path *data_path,
const ClockEdge *en_clk_edge); const ClockEdge *en_clk_edge);
}; };

28
search/PathEnd.cc
View File

@ -428,7 +428,7 @@ PathEnd::checkInterClkUncertainty(const ClockEdge *src_clk_edge,
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
void void
PathEndUnconstrained::reportFull(ReportPath *report) const PathEndUnconstrained::reportFull(const ReportPath *report) const
{ {
report->reportFull(this); report->reportFull(this);
} }
@ -440,7 +440,7 @@ PathEndUnconstrained::slackNoCrpr(const StaState *) const
} }
void void
PathEndUnconstrained::reportShort(ReportPath *report) const PathEndUnconstrained::reportShort(const ReportPath *report) const
{ {
report->reportShort(this); report->reportShort(this);
} }
@ -979,13 +979,13 @@ PathEndCheck::typeName() const
} }
void void
PathEndCheck::reportFull(ReportPath *report) const PathEndCheck::reportFull(const ReportPath *report) const
{ {
report->reportFull(this); report->reportFull(this);
} }
void void
PathEndCheck::reportShort(ReportPath *report) const PathEndCheck::reportShort(const ReportPath *report) const
{ {
report->reportShort(this); report->reportShort(this);
} }
@ -1170,13 +1170,13 @@ PathEndLatchCheck::latchDisable() const
} }
void void
PathEndLatchCheck::reportFull(ReportPath *report) const PathEndLatchCheck::reportFull(const ReportPath *report) const
{ {
report->reportFull(this); report->reportFull(this);
} }
void void
PathEndLatchCheck::reportShort(ReportPath *report) const PathEndLatchCheck::reportShort(const ReportPath *report) const
{ {
report->reportShort(this); report->reportShort(this);
} }
@ -1359,13 +1359,13 @@ PathEndOutputDelay::typeName() const
} }
void void
PathEndOutputDelay::reportFull(ReportPath *report) const PathEndOutputDelay::reportFull(const ReportPath *report) const
{ {
report->reportFull(this); report->reportFull(this);
} }
void void
PathEndOutputDelay::reportShort(ReportPath *report) const PathEndOutputDelay::reportShort(const ReportPath *report) const
{ {
report->reportShort(this); report->reportShort(this);
} }
@ -1571,13 +1571,13 @@ PathEndGatedClock::checkRole(const StaState *) const
} }
void void
PathEndGatedClock::reportFull(ReportPath *report) const PathEndGatedClock::reportFull(const ReportPath *report) const
{ {
report->reportFull(this); report->reportFull(this);
} }
void void
PathEndGatedClock::reportShort(ReportPath *report) const PathEndGatedClock::reportShort(const ReportPath *report) const
{ {
report->reportShort(this); report->reportShort(this);
} }
@ -1734,13 +1734,13 @@ PathEndDataCheck::checkRole(const StaState *sta) const
} }
void void
PathEndDataCheck::reportFull(ReportPath *report) const PathEndDataCheck::reportFull(const ReportPath *report) const
{ {
report->reportFull(this); report->reportFull(this);
} }
void void
PathEndDataCheck::reportShort(ReportPath *report) const PathEndDataCheck::reportShort(const ReportPath *report) const
{ {
report->reportShort(this); report->reportShort(this);
} }
@ -1858,13 +1858,13 @@ PathEndPathDelay::findSrcClkArrival(const StaState *sta)
} }
void void
PathEndPathDelay::reportFull(ReportPath *report) const PathEndPathDelay::reportFull(const ReportPath *report) const
{ {
report->reportFull(this); report->reportFull(this);
} }
void void
PathEndPathDelay::reportShort(ReportPath *report) const PathEndPathDelay::reportShort(const ReportPath *report) const
{ {
report->reportShort(this); report->reportShort(this);
} }

34
search/PathExpanded.cc
View File

@ -164,31 +164,31 @@ PathExpanded::path(size_t index) const
} }
TimingArc * TimingArc *
PathExpanded::prevArc(size_t index) PathExpanded::prevArc(size_t index) const
{ {
return prev_arcs_[pathsIndex(index)]; return prev_arcs_[pathsIndex(index)];
} }
PathRef * const PathRef *
PathExpanded::startPath() PathExpanded::startPath() const
{ {
return &paths_[start_index_]; return &paths_[start_index_];
} }
PathRef * const PathRef *
PathExpanded::endPath() PathExpanded::endPath() const
{ {
return &paths_[0]; return &paths_[0];
} }
TimingArc * TimingArc *
PathExpanded::startPrevArc() PathExpanded::startPrevArc() const
{ {
return prev_arcs_[start_index_]; return prev_arcs_[start_index_];
} }
PathRef * const PathRef *
PathExpanded::startPrevPath() PathExpanded::startPrevPath() const
{ {
size_t start1 = start_index_ + 1; size_t start1 = start_index_ + 1;
if (start1 < paths_.size()) if (start1 < paths_.size())
@ -198,11 +198,11 @@ PathExpanded::startPrevPath()
} }
void void
PathExpanded::clkPath(PathRef &clk_path) PathExpanded::clkPath(PathRef &clk_path) const
{ {
const Latches *latches = sta_->latches(); const Latches *latches = sta_->latches();
PathRef *start = startPath(); const PathRef *start = startPath();
TimingArc *prev_arc = startPrevArc(); const TimingArc *prev_arc = startPrevArc();
if (start && prev_arc) { if (start && prev_arc) {
TimingRole *role = prev_arc->role(); TimingRole *role = prev_arc->role();
if (role == TimingRole::latchDtoQ()) { if (role == TimingRole::latchDtoQ()) {
@ -215,7 +215,7 @@ PathExpanded::clkPath(PathRef &clk_path)
} }
else if (role == TimingRole::regClkToQ() else if (role == TimingRole::regClkToQ()
|| role == TimingRole::latchEnToQ()) { || role == TimingRole::latchEnToQ()) {
PathRef *start_prev = startPrevPath(); const PathRef *start_prev = startPrevPath();
if (start_prev) if (start_prev)
clk_path.init(start_prev); clk_path.init(start_prev);
} }
@ -226,15 +226,15 @@ PathExpanded::clkPath(PathRef &clk_path)
void void
PathExpanded::latchPaths(// Return values. PathExpanded::latchPaths(// Return values.
PathRef *&d_path, const PathRef *&d_path,
PathRef *&q_path, const PathRef *&q_path,
Edge *&d_q_edge) Edge *&d_q_edge) const
{ {
d_path = nullptr; d_path = nullptr;
q_path = nullptr; q_path = nullptr;
d_q_edge = nullptr; d_q_edge = nullptr;
PathRef *start = startPath(); const PathRef *start = startPath();
TimingArc *prev_arc = startPrevArc(); const TimingArc *prev_arc = startPrevArc();
if (start if (start
&& prev_arc && prev_arc
&& prev_arc->role() == TimingRole::latchDtoQ()) { && prev_arc->role() == TimingRole::latchDtoQ()) {

441
search/ReportPath.cc
View File

File diff suppressed because it is too large Load Diff

366
search/ReportPath.hh
View File

@ -44,7 +44,7 @@ typedef Vector<ReportField*> ReportFieldSeq;
class ReportPath : public StaState class ReportPath : public StaState
{ {
public: public:
explicit ReportPath(StaState *sta); ReportPath(StaState *sta);
virtual ~ReportPath(); virtual ~ReportPath();
ReportPathFormat pathFormat() const { return format_; } ReportPathFormat pathFormat() const { return format_; }
void setPathFormat(ReportPathFormat format); void setPathFormat(ReportPathFormat format);
@ -61,93 +61,93 @@ public:
void setNoSplit(bool no_split); void setNoSplit(bool no_split);
bool reportSigmas() const { return report_sigmas_; } bool reportSigmas() const { return report_sigmas_; }
void setReportSigmas(bool report); void setReportSigmas(bool report);
ReportField *findField(const char *name); ReportField *findField(const char *name) const;
// Header above reportPathEnd results. // Header above reportPathEnd results.
void reportPathEndHeader(); void reportPathEndHeader() const;
// Footer below reportPathEnd results. // Footer below reportPathEnd results.
void reportPathEndFooter(); void reportPathEndFooter() const;
void reportPathEnd(PathEnd *end); void reportPathEnd(const PathEnd *end) const;
// Format report_path_endpoint only: // Format report_path_endpoint only:
// Previous path end is used to detect path group changes // Previous path end is used to detect path group changes
// so headers are reported by group. // so headers are reported by group.
void reportPathEnd(PathEnd *end, void reportPathEnd(const PathEnd *end,
PathEnd *prev_end, const PathEnd *prev_end,
bool last); bool last) const;
void reportPathEnds(PathEndSeq *ends); void reportPathEnds(const PathEndSeq *ends) const;
void reportPath(const Path *path); void reportPath(const Path *path) const;
void reportShort(const PathEndUnconstrained *end); void reportShort(const PathEndUnconstrained *end) const;
void reportShort(const PathEndCheck *end); void reportShort(const PathEndCheck *end) const;
void reportShort(const PathEndLatchCheck *end); void reportShort(const PathEndLatchCheck *end) const;
void reportShort(const PathEndPathDelay *end); void reportShort(const PathEndPathDelay *end) const;
void reportShort(const PathEndOutputDelay *end); void reportShort(const PathEndOutputDelay *end) const;
void reportShort(const PathEndGatedClock *end); void reportShort(const PathEndGatedClock *end) const;
void reportShort(const PathEndDataCheck *end); void reportShort(const PathEndDataCheck *end) const;
void reportFull(const PathEndUnconstrained *end); void reportFull(const PathEndUnconstrained *end) const;
void reportFull(const PathEndCheck *end); void reportFull(const PathEndCheck *end) const;
void reportFull(const PathEndLatchCheck *end); void reportFull(const PathEndLatchCheck *end) const;
void reportFull(const PathEndPathDelay *end); void reportFull(const PathEndPathDelay *end) const;
void reportFull(const PathEndOutputDelay *end); void reportFull(const PathEndOutputDelay *end) const;
void reportFull(const PathEndGatedClock *end); void reportFull(const PathEndGatedClock *end) const;
void reportFull(const PathEndDataCheck *end); void reportFull(const PathEndDataCheck *end) const;
void reportJsonHeader(); void reportJsonHeader() const;
void reportJsonFooter(); void reportJsonFooter() const;
void reportJson(const PathEnd *end, void reportJson(const PathEnd *end,
bool last); bool last) const;
void reportJson(const Path *path); void reportJson(const Path *path) const;
void reportJson(const Path *path, void reportJson(const Path *path,
const char *path_name, const char *path_name,
int indent, int indent,
bool trailing_comma, bool trailing_comma,
string &result); string &result) const;
void reportJson(const PathExpanded &expanded, void reportJson(const PathExpanded &expanded,
const char *path_name, const char *path_name,
int indent, int indent,
bool trailing_comma, bool trailing_comma,
string &result); string &result) const;
void reportEndHeader(); void reportEndHeader() const;
void reportEndLine(PathEnd *end); void reportEndLine(const PathEnd *end) const;
void reportSummaryHeader(); void reportSummaryHeader() const;
void reportSummaryLine(PathEnd *end); void reportSummaryLine(const PathEnd *end) const;
void reportSlackOnlyHeader(); void reportSlackOnlyHeader() const;
void reportSlackOnly(PathEnd *end); void reportSlackOnly(const PathEnd *end) const;
void reportMpwCheck(MinPulseWidthCheck *check, void reportMpwCheck(const MinPulseWidthCheck *check,
bool verbose); bool verbose) const;
void reportMpwChecks(MinPulseWidthCheckSeq *checks, void reportMpwChecks(const MinPulseWidthCheckSeq *checks,
bool verbose); bool verbose) const;
void reportMpwHeaderShort(); void reportMpwHeaderShort() const;
void reportShort(MinPulseWidthCheck *check); void reportShort(const MinPulseWidthCheck *check) const;
void reportVerbose(MinPulseWidthCheck *check); void reportVerbose(const MinPulseWidthCheck *check) const;
void reportCheck(MinPeriodCheck *check, void reportCheck(const MinPeriodCheck *check,
bool verbose); bool verbose) const;
void reportChecks(MinPeriodCheckSeq *checks, void reportChecks(const MinPeriodCheckSeq *checks,
bool verbose); bool verbose) const;
void reportPeriodHeaderShort(); void reportPeriodHeaderShort() const;
void reportShort(MinPeriodCheck *check); void reportShort(const MinPeriodCheck *check) const;
void reportVerbose(MinPeriodCheck *check); void reportVerbose(const MinPeriodCheck *check) const;
void reportCheck(MaxSkewCheck *check, void reportCheck(const MaxSkewCheck *check,
bool verbose); bool verbose) const;
void reportChecks(MaxSkewCheckSeq *checks, void reportChecks(const MaxSkewCheckSeq *checks,
bool verbose); bool verbose) const;
void reportMaxSkewHeaderShort(); void reportMaxSkewHeaderShort() const;
void reportShort(MaxSkewCheck *check); void reportShort(const MaxSkewCheck *check) const;
void reportVerbose(MaxSkewCheck *check); void reportVerbose(const MaxSkewCheck *check) const;
void reportLimitShortHeader(const ReportField *field); void reportLimitShortHeader(const ReportField *field) const;
void reportLimitShort(const ReportField *field, void reportLimitShort(const ReportField *field,
Pin *pin, Pin *pin,
float value, float value,
float limit, float limit,
float slack); float slack) const;
void reportLimitVerbose(const ReportField *field, void reportLimitVerbose(const ReportField *field,
Pin *pin, Pin *pin,
const RiseFall *rf, const RiseFall *rf,
@ -155,7 +155,7 @@ public:
float limit, float limit,
float slack, float slack,
const Corner *corner, const Corner *corner,
const MinMax *min_max); const MinMax *min_max) const;
ReportField *fieldSlew() const { return field_slew_; } ReportField *fieldSlew() const { return field_slew_; }
ReportField *fieldFanout() const { return field_fanout_; } ReportField *fieldFanout() const { return field_fanout_; }
ReportField *fieldCapacitance() const { return field_capacitance_; } ReportField *fieldCapacitance() const { return field_capacitance_; }
@ -169,83 +169,83 @@ protected:
bool left_justify, bool left_justify,
Unit *unit, Unit *unit,
bool enabled); bool enabled);
void reportEndpointHeader(PathEnd *end, void reportEndpointHeader(const PathEnd *end,
PathEnd *prev_end); const PathEnd *prev_end) const;
void reportShort(const PathEndUnconstrained *end, void reportShort(const PathEndUnconstrained *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportShort(const PathEndCheck *end, void reportShort(const PathEndCheck *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportShort(const PathEndLatchCheck *end, void reportShort(const PathEndLatchCheck *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportShort(const PathEndPathDelay *end, void reportShort(const PathEndPathDelay *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportShort(const PathEndOutputDelay *end, void reportShort(const PathEndOutputDelay *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportShort(const PathEndGatedClock *end, void reportShort(const PathEndGatedClock *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportShort(const PathEndDataCheck *end, void reportShort(const PathEndDataCheck *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportEndpoint(const PathEndOutputDelay *end); void reportEndpoint(const PathEndOutputDelay *end) const;
void reportEndpointOutputDelay(const PathEndClkConstrained *end); void reportEndpointOutputDelay(const PathEndClkConstrained *end) const;
void reportEndpoint(const PathEndPathDelay *end); void reportEndpoint(const PathEndPathDelay *end) const;
void reportEndpoint(const PathEndGatedClock *end); void reportEndpoint(const PathEndGatedClock *end) const;
string pathEndpoint(PathEnd *end); string pathEndpoint(const PathEnd *end) const;
string pathStartpoint(PathEnd *end, string pathStartpoint(const PathEnd *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportBorrowing(const PathEndLatchCheck *end, void reportBorrowing(const PathEndLatchCheck *end,
Arrival &borrow, Arrival &borrow,
Arrival &time_given_to_startpoint); Arrival &time_given_to_startpoint) const;
void reportEndpoint(const PathEndDataCheck *end); void reportEndpoint(const PathEndDataCheck *end) const;
const char *clkNetworkDelayIdealProp(bool is_ideal); const char *clkNetworkDelayIdealProp(bool is_ideal) const;
string checkRoleReason(const PathEnd *end); string checkRoleReason(const PathEnd *end) const;
string checkRoleString(const PathEnd *end); string checkRoleString(const PathEnd *end) const;
virtual void reportGroup(const PathEnd *end); virtual void reportGroup(const PathEnd *end) const;
void reportStartpoint(const PathEnd *end, void reportStartpoint(const PathEnd *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportUnclockedEndpoint(const PathEnd *end, void reportUnclockedEndpoint(const PathEnd *end,
const char *default_reason); const char *default_reason) const;
void reportEndpoint(const PathEndCheck *end); void reportEndpoint(const PathEndCheck *end) const;
void reportEndpoint(const PathEndLatchCheck *end); void reportEndpoint(const PathEndLatchCheck *end) const;
const char *latchDesc(const PathEndLatchCheck *end); const char *latchDesc(const PathEndLatchCheck *end) const;
void reportStartpoint(const char *start, void reportStartpoint(const char *start,
string reason); const string reason) const;
void reportEndpoint(const char *end, void reportEndpoint(const char *end,
string reason); const string reason) const;
void reportStartEndPoint(const char *pt, void reportStartEndPoint(const char *pt,
string reason, const string reason,
const char *key); const char *key) const;
string tgtClkName(const PathEnd *end); string tgtClkName(const PathEnd *end) const;
const char *clkRegLatchDesc(const PathEnd *end); const char *clkRegLatchDesc(const PathEnd *end) const;
void reportSrcPath(const PathEnd *end, void reportSrcPath(const PathEnd *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportTgtClk(const PathEnd *end); void reportTgtClk(const PathEnd *end) const;
void reportTgtClk(const PathEnd *end, void reportTgtClk(const PathEnd *end,
float prev_time); float prev_time) const;
void reportTgtClk(const PathEnd *end, void reportTgtClk(const PathEnd *end,
float prev_time, float prev_time,
bool is_prop); bool is_prop) const;
void reportTgtClk(const PathEnd *end, void reportTgtClk(const PathEnd *end,
float prev_time, float prev_time,
float src_offset, float src_offset,
bool is_prop); bool is_prop) const;
bool pathFromGenPropClk(const Path *clk_path, bool pathFromGenPropClk(const Path *clk_path,
const EarlyLate *early_late); const EarlyLate *early_late) const;
bool isGenPropClk(const Clock *clk, bool isGenPropClk(const Clock *clk,
const RiseFall *clk_rf, const RiseFall *clk_rf,
const MinMax *min_max, const MinMax *min_max,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportSrcClkAndPath(const Path *path, void reportSrcClkAndPath(const Path *path,
PathExpanded &expanded, const PathExpanded &expanded,
float time_offset, float time_offset,
Arrival clk_insertion, Arrival clk_insertion,
Arrival clk_latency, Arrival clk_latency,
bool is_path_delay); bool is_path_delay) const;
bool reportGenClkSrcPath(const Path *clk_path, bool reportGenClkSrcPath(const Path *clk_path,
const Clock *clk, const Clock *clk,
const RiseFall *clk_rf, const RiseFall *clk_rf,
const MinMax *min_max, const MinMax *min_max,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportGenClkSrcAndPath(const Path *path, void reportGenClkSrcAndPath(const Path *path,
const Clock *clk, const Clock *clk,
const RiseFall *clk_rf, const RiseFall *clk_rf,
@ -253,7 +253,7 @@ protected:
const PathAnalysisPt *path_ap, const PathAnalysisPt *path_ap,
float time_offset, float time_offset,
float path_time_offset, float path_time_offset,
bool clk_used_as_data); bool clk_used_as_data) const;
bool reportGenClkSrcPath1(const Clock *clk, bool reportGenClkSrcPath1(const Clock *clk,
const Pin *clk_pin, const Pin *clk_pin,
const RiseFall *clk_rf, const RiseFall *clk_rf,
@ -261,99 +261,99 @@ protected:
const PathAnalysisPt *path_ap, const PathAnalysisPt *path_ap,
float gclk_time, float gclk_time,
float time_offset, float time_offset,
bool clk_used_as_data); bool clk_used_as_data) const;
void reportClkSrcLatency(Arrival insertion, void reportClkSrcLatency(Arrival insertion,
float clk_time, float clk_time,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportPathLine(const Path *path, void reportPathLine(const Path *path,
Delay incr, Delay incr,
Arrival time, Arrival time,
const char *line_case); const char *line_case) const;
void reportCommonClkPessimism(const PathEnd *end, void reportCommonClkPessimism(const PathEnd *end,
Arrival &clk_arrival); Arrival &clk_arrival) const ;
void reportClkUncertainty(const PathEnd *end, void reportClkUncertainty(const PathEnd *end,
Arrival &clk_arrival); Arrival &clk_arrival) const ;
void reportClkLine(const Clock *clk, void reportClkLine(const Clock *clk,
const char *clk_name, const char *clk_name,
const RiseFall *clk_rf, const RiseFall *clk_rf,
Arrival clk_time, Arrival clk_time,
const MinMax *min_max); const MinMax *min_max) const ;
void reportClkLine(const Clock *clk, void reportClkLine(const Clock *clk,
const char *clk_name, const char *clk_name,
const RiseFall *clk_rf, const RiseFall *clk_rf,
Arrival prev_time, Arrival prev_time,
Arrival clk_time, Arrival clk_time,
const MinMax *min_max); const MinMax *min_max) const ;
void reportRequired(const PathEnd *end, void reportRequired(const PathEnd *end,
string margin_msg); string margin_msg) const ;
void reportSlack(const PathEnd *end); void reportSlack(const PathEnd *end) const ;
void reportSlack(Slack slack); void reportSlack(Slack slack) const ;
void reportSpaceSlack(PathEnd *end, void reportSpaceSlack(const PathEnd *end,
string &line); string &line) const ;
void reportSpaceSlack(Slack slack, void reportSpaceSlack(Slack slack,
string &line); string &line) const ;
void reportSrcPathArrival(const PathEnd *end, void reportSrcPathArrival(const PathEnd *end,
PathExpanded &expanded); const PathExpanded &expanded) const ;
void reportPath(const PathEnd *end, void reportPath(const PathEnd *end,
PathExpanded &expanded); const PathExpanded &expanded) const;
void reportPathFull(const Path *path); void reportPathFull(const Path *path) const;
void reportPathHeader(); void reportPathHeader() const;
void reportPath1(const Path *path, void reportPath1(const Path *path,
PathExpanded &expanded, const PathExpanded &expanded,
bool clk_used_as_data, bool clk_used_as_data,
float time_offset); float time_offset) const;
void reportPath2(const Path *path, void reportPath2(const Path *path,
PathExpanded &expanded, const PathExpanded &expanded,
bool clk_used_as_data, bool clk_used_as_data,
float time_offset); float time_offset) const;
void reportPath3(const Path *path, void reportPath3(const Path *path,
PathExpanded &expanded, const PathExpanded &expanded,
bool clk_used_as_data, bool clk_used_as_data,
bool report_clk_path, bool report_clk_path,
Arrival prev_time, Arrival prev_time,
float time_offset); float time_offset) const;
void reportPath4(const Path *path, void reportPath4(const Path *path,
PathExpanded &expanded, const PathExpanded &expanded,
bool clk_used_as_data, bool clk_used_as_data,
bool skip_first_path, bool skip_first_path,
bool skip_last_path, bool skip_last_path,
float time_offset); float time_offset) const;
void reportPath5(const Path *path, void reportPath5(const Path *path,
PathExpanded &expanded, const PathExpanded &expanded,
size_t path_first_index, size_t path_first_index,
size_t path_last_index, size_t path_last_index,
bool propagated_clk, bool propagated_clk,
bool report_clk_path, bool report_clk_path,
Arrival prev_time, Arrival prev_time,
float time_offset); float time_offset) const;
void reportHierPinsThru(const Path *path, void reportHierPinsThru(const Path *path,
const TimingArc *prev_arc); const TimingArc *prev_arc) const;
void reportInputExternalDelay(const Path *path, void reportInputExternalDelay(const Path *path,
float time_offset); float time_offset) const;
void reportLine(const char *what, void reportLine(const char *what,
Delay total, Delay total,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportLineNegative(const char *what, void reportLineNegative(const char *what,
Delay total, Delay total,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportLine(const char *what, void reportLine(const char *what,
Delay total, Delay total,
const EarlyLate *early_late, const EarlyLate *early_late,
const RiseFall *rf); const RiseFall *rf) const;
void reportLine(const char *what, void reportLine(const char *what,
Delay incr, Delay incr,
Delay total, Delay total,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportLine(const char *what, void reportLine(const char *what,
Delay incr, Delay incr,
Delay total, Delay total,
const EarlyLate *early_late, const EarlyLate *early_late,
const RiseFall *rf); const RiseFall *rf) const;
void reportLine(const char *what, void reportLine(const char *what,
Slew slew, Slew slew,
Delay incr, Delay incr,
Delay total, Delay total,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportLine(const char *what, void reportLine(const char *what,
float cap, float cap,
Slew slew, Slew slew,
@ -364,83 +364,83 @@ protected:
const EarlyLate *early_late, const EarlyLate *early_late,
const RiseFall *rf, const RiseFall *rf,
string src_attr, string src_attr,
const char *line_case); const char *line_case) const;
void reportLineTotal(const char *what, void reportLineTotal(const char *what,
Delay incr, Delay incr,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportLineTotalMinus(const char *what, void reportLineTotalMinus(const char *what,
Delay decr, Delay decr,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportLineTotal1(const char *what, void reportLineTotal1(const char *what,
Delay incr, Delay incr,
bool incr_with_minus, bool incr_with_minus,
const EarlyLate *early_late); const EarlyLate *early_late) const;
void reportDashLineTotal(); void reportDashLineTotal() const;
void reportDescription(const char *what, void reportDescription(const char *what,
string &result); string &result) const;
void reportDescription(const char *what, void reportDescription(const char *what,
bool first_field, bool first_field,
bool last_field, bool last_field,
string &result); string &result) const;
void reportFieldTime(float value, void reportFieldTime(float value,
ReportField *field, ReportField *field,
string &result); string &result) const;
void reportSpaceFieldTime(float value, void reportSpaceFieldTime(float value,
string &result); string &result) const;
void reportSpaceFieldDelay(Delay value, void reportSpaceFieldDelay(Delay value,
const EarlyLate *early_late, const EarlyLate *early_late,
string &result); string &result) const;
void reportFieldDelayMinus(Delay value, void reportFieldDelayMinus(Delay value,
const EarlyLate *early_late, const EarlyLate *early_late,
ReportField *field, const ReportField *field,
string &result); string &result) const;
void reportTotalDelay(Delay value, void reportTotalDelay(Delay value,
const EarlyLate *early_late, const EarlyLate *early_late,
string &result); string &result) const;
void reportFieldDelay(Delay value, void reportFieldDelay(Delay value,
const EarlyLate *early_late, const EarlyLate *early_late,
ReportField *field, const ReportField *field,
string &result); string &result) const;
void reportField(float value, void reportField(float value,
const ReportField *field, const ReportField *field,
string &result); string &result) const;
void reportField(const char *value, void reportField(const char *value,
const ReportField *field, const ReportField *field,
string &result); string &result) const;
void reportFieldBlank(const ReportField *field, void reportFieldBlank(const ReportField *field,
string &result); string &result) const;
void reportDashLine(); void reportDashLine() const;
void reportDashLine(int line_width); void reportDashLine(int line_width) const;
void reportBlankLine(); void reportBlankLine() const;
string descriptionField(Vertex *vertex); string descriptionField(const Vertex *vertex) const;
string descriptionField(const Pin *pin); string descriptionField(const Pin *pin) const;
string descriptionNet(const Pin *pin); string descriptionNet(const Pin *pin) const;
bool reportClkPath() const; bool reportClkPath() const;
string clkName(const Clock *clk, string clkName(const Clock *clk,
bool inverted); bool inverted) const;
bool hasExtInputDriver(const Pin *pin, bool hasExtInputDriver(const Pin *pin,
const RiseFall *rf, const RiseFall *rf,
const MinMax *min_max); const MinMax *min_max) const;
float drvrFanout(Vertex *drvr, float drvrFanout(Vertex *drvr,
const Corner *corner, const Corner *corner,
const MinMax *min_max); const MinMax *min_max) const;
const char *mpwCheckHiLow(MinPulseWidthCheck *check); const char *mpwCheckHiLow(const MinPulseWidthCheck *check) const;
void reportSkewClkPath(const char *arrival_msg, void reportSkewClkPath(const char *arrival_msg,
const PathVertex *clk_path); const PathVertex *clk_path) const;
const char *edgeRegLatchDesc(Edge *edge, const char *edgeRegLatchDesc(const Edge *edge,
TimingArc *arc); const TimingArc *arc) const;
const char *checkRegLatchDesc(const TimingRole *role, const char *checkRegLatchDesc(const TimingRole *role,
const RiseFall *clk_rf) const; const RiseFall *clk_rf) const;
const char *regDesc(const RiseFall *clk_rf) const; const char *regDesc(const RiseFall *clk_rf) const;
const char *latchDesc(const RiseFall *clk_rf) const; const char *latchDesc(const RiseFall *clk_rf) const;
void pathClkPath(const Path *path, void pathClkPath(const Path *path,
PathRef &clk_path) const; const PathRef &clk_path) const;
bool isPropagated(const Path *clk_path); bool isPropagated(const Path *clk_path) const;
bool isPropagated(const Path *clk_path, bool isPropagated(const Path *clk_path,
const Clock *clk); const Clock *clk) const;
bool pathFromClkPin(PathExpanded &expanded); bool pathFromClkPin(const PathExpanded &expanded) const;
bool pathFromClkPin(const Path *path, bool pathFromClkPin(const Path *path,
const Pin *start_pin); const Pin *start_pin) const;
void latchPaths(const Path *path, void latchPaths(const Path *path,
// Return values. // Return values.
PathRef &d_path, PathRef &d_path,
@ -448,22 +448,22 @@ protected:
Edge *&d_q_edge) const; Edge *&d_q_edge) const;
bool nextArcAnnotated(const PathRef *next_path, bool nextArcAnnotated(const PathRef *next_path,
size_t next_index, size_t next_index,
PathExpanded &expanded, const PathExpanded &expanded,
DcalcAPIndex ap_index); DcalcAPIndex ap_index) const;
float tgtClkInsertionOffet(const Path *clk_path, float tgtClkInsertionOffet(const Path *clk_path,
const EarlyLate *early_late, const EarlyLate *early_late,
PathAnalysisPt *path_ap); const PathAnalysisPt *path_ap) const;
// InputDelay used to seed path root. // InputDelay used to seed path root.
InputDelay *pathInputDelay(const Path *path) const; InputDelay *pathInputDelay(const Path *path) const;
void pathInputDelayRefPath(const Path *path, void pathInputDelayRefPath(const Path *path,
InputDelay *input_delay, const InputDelay *input_delay,
// Return value. // Return value.
PathRef &ref_path); PathRef &ref_path) const;
const char *asRisingFalling(const RiseFall *rf); const char *asRisingFalling(const RiseFall *rf) const;
const char *asRiseFall(const RiseFall *rf); const char *asRiseFall(const RiseFall *rf) const;
Delay delayIncr(Delay time, Delay delayIncr(Delay time,
Delay prev, Delay prev,
const MinMax *min_max); const MinMax *min_max) const;
// Path options. // Path options.
ReportPathFormat format_; ReportPathFormat format_;

12
search/Search.cc
View File

@ -2997,9 +2997,9 @@ Search::clkInfoCount() const
} }
ArcDelay ArcDelay
Search::deratedDelay(Vertex *from_vertex, Search::deratedDelay(const Vertex *from_vertex,
TimingArc *arc, const TimingArc *arc,
Edge *edge, const Edge *edge,
bool is_clk, bool is_clk,
const PathAnalysisPt *path_ap) const PathAnalysisPt *path_ap)
{ {
@ -3011,9 +3011,9 @@ Search::deratedDelay(Vertex *from_vertex,
} }
float float
Search::timingDerate(Vertex *from_vertex, Search::timingDerate(const Vertex *from_vertex,
TimingArc *arc, const TimingArc *arc,
Edge *edge, const Edge *edge,
bool is_clk, bool is_clk,
const PathAnalysisPt *path_ap) const PathAnalysisPt *path_ap)
{ {

4
search/Sta.cc
View File

@ -2574,7 +2574,7 @@ Sta::reportPathEnds(PathEndSeq *ends)
} }
void void
Sta::reportPath(Path *path) Sta::reportPath(const Path *path)
{ {
report_path_->reportPath(path); report_path_->reportPath(path);
} }
@ -3177,7 +3177,7 @@ bool
MinPeriodEndVisitor::pathIsFromInputPort(PathEnd *path_end) MinPeriodEndVisitor::pathIsFromInputPort(PathEnd *path_end)
{ {
PathExpanded expanded(path_end->path(), sta_); PathExpanded expanded(path_end->path(), sta_);
PathRef *start = expanded.startPath(); const PathRef *start = expanded.startPath();
Graph *graph = sta_->graph(); Graph *graph = sta_->graph();
const Pin *first_pin = start->pin(graph); const Pin *first_pin = start->pin(graph);
Network *network = sta_->network(); Network *network = sta_->network();

2
spice/WritePathSpice.cc
View File

@ -220,7 +220,7 @@ WritePathSpice::writeSpice()
void void
WritePathSpice::writeHeader() WritePathSpice::writeHeader()
{ {
Path *start_path = path_expanded_.startPath(); const Path *start_path = path_expanded_.startPath();
string title = stdstrPrint("Path from %s %s to %s %s", string title = stdstrPrint("Path from %s %s to %s %s",
network_->pathName(start_path->pin(this)), network_->pathName(start_path->pin(this)),
start_path->transition(this)->asString(), start_path->transition(this)->asString(),