From dab04c221db76cc3326b32574730f5c89feb61d1 Mon Sep 17 00:00:00 2001 From: steve Date: Sat, 18 Sep 1999 01:53:08 +0000 Subject: [PATCH] Detect constant lessthen-equal expressions. --- elaborate.cc | 25 +++++++++++++++++++-- netlist.cc | 63 +++++++++++++++++++++++++++++++++++++++++----------- netlist.h | 20 ++++++++++------- 3 files changed, 85 insertions(+), 23 deletions(-) diff --git a/elaborate.cc b/elaborate.cc index 5365499a4..9e738485b 100644 --- a/elaborate.cc +++ b/elaborate.cc @@ -17,7 +17,7 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */ #if !defined(WINNT) -#ident "$Id: elaborate.cc,v 1.89 1999/09/17 02:06:25 steve Exp $" +#ident "$Id: elaborate.cc,v 1.90 1999/09/18 01:53:08 steve Exp $" #endif /* @@ -1441,6 +1441,8 @@ NetExpr* PEIdent::elaborate_expr(Design*des, const string&path) const assert(msb_); verinum*lsn = lsb_->eval_const(des, path); verinum*msn = msb_->eval_const(des, path); + assert(lsn); + assert(msn); unsigned long lsv = lsn->as_ulong(); unsigned long msv = msn->as_ulong(); unsigned long wid = 1 + ((msv>lsv)? (msv-lsv) : (lsv-msv)); @@ -2333,7 +2335,23 @@ NetProc* PForStatement::elaborate(Design*des, const string&path) const body->append(step); - NetWhile*loop = new NetWhile(cond_->elaborate_expr(des, path), body); + + /* Elaborate the condition expression. Try to evaluate it too, + in case it is a constant. This is an interesting case + worthy of a warning. */ + NetExpr*ce = cond_->elaborate_expr(des, path); + if (NetExpr*tmp = ce->eval_tree()) { + if (dynamic_cast(tmp)) + cerr << get_line() << ": warning: condition expression " + "is constant." << endl; + + ce = tmp; + } + + + /* All done, build up the loop. */ + + NetWhile*loop = new NetWhile(ce, body); top->append(loop); return top; } @@ -2600,6 +2618,9 @@ Design* elaborate(const map&modules, /* * $Log: elaborate.cc,v $ + * Revision 1.90 1999/09/18 01:53:08 steve + * Detect constant lessthen-equal expressions. + * * Revision 1.89 1999/09/17 02:06:25 steve * Handle unconnected module ports. * diff --git a/netlist.cc b/netlist.cc index 9ba9ea073..5ede6a7e9 100644 --- a/netlist.cc +++ b/netlist.cc @@ -17,7 +17,7 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */ #if !defined(WINNT) -#ident "$Id: netlist.cc,v 1.64 1999/09/16 04:18:15 steve Exp $" +#ident "$Id: netlist.cc,v 1.65 1999/09/18 01:53:08 steve Exp $" #endif # include @@ -920,7 +920,27 @@ NetEBinary* NetEBinary::dup_expr() const assert(0); } -NetExpr* NetEBinary::eval_eqeq() +/* + * Some of the derived classes can be evaluated by the compiler, this + * method provides the common aid of evaluating the parameter + * expressions. + */ +void NetEBinary::eval_sub_tree_() +{ + NetExpr*tmp = left_->eval_tree(); + if (tmp) { + delete left_; + left_ = tmp; + } + tmp = right_->eval_tree(); + if (tmp){ + delete right_; + right_ = tmp; + } +} + + +NetExpr* NetEBComp::eval_eqeq_() { NetEConst*l = dynamic_cast(left_); if (l == 0) return 0; @@ -942,22 +962,36 @@ NetExpr* NetEBinary::eval_eqeq() return new NetEConst(result); } -NetExpr* NetEBinary::eval_tree() +NetExpr* NetEBComp::eval_leeq_() { - NetExpr*tmp = left_->eval_tree(); - if (tmp) { - delete left_; - left_ = tmp; - } - tmp = right_->eval_tree(); - if (tmp){ - delete right_; - right_ = tmp; + NetEConst*r = dynamic_cast(right_); + if (r == 0) return 0; + + verinum rv = r->value(); + + /* Detect the case where the right side is greater that or + equal to the largest value the left side can possibly + have. */ + unsigned long lv = (1 << left_->expr_width()) - 1; + if (lv <= rv.as_ulong()) { + verinum result(verinum::V1, 1); + return new NetEConst(result); } + return 0; +} + + +NetExpr* NetEBComp::eval_tree() +{ + eval_sub_tree_(); + switch (op_) { case 'e': - return eval_eqeq(); + return eval_eqeq_(); + + case 'L': + return eval_leeq_(); default: return 0; @@ -1836,6 +1870,9 @@ NetNet* Design::find_signal(bool (*func)(const NetNet*)) /* * $Log: netlist.cc,v $ + * Revision 1.65 1999/09/18 01:53:08 steve + * Detect constant lessthen-equal expressions. + * * Revision 1.64 1999/09/16 04:18:15 steve * elaborate concatenation repeats. * diff --git a/netlist.h b/netlist.h index d1dc2e635..d5ba171c0 100644 --- a/netlist.h +++ b/netlist.h @@ -19,7 +19,7 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */ #if !defined(WINNT) -#ident "$Id: netlist.h,v 1.65 1999/09/16 04:18:15 steve Exp $" +#ident "$Id: netlist.h,v 1.66 1999/09/18 01:53:08 steve Exp $" #endif /* @@ -1146,22 +1146,17 @@ class NetEBinary : public NetExpr { virtual bool set_width(unsigned w); - // If both of my subexpressions are constants, then I can - // probably evaluate this part of the expression at compile - // time. - virtual NetExpr* eval_tree(); - virtual NetEBinary* dup_expr() const; virtual void expr_scan(struct expr_scan_t*) const; virtual void dump(ostream&) const; - NetExpr*eval_eqeq(); - protected: char op_; NetExpr* left_; NetExpr* right_; + + virtual void eval_sub_tree_(); }; /* @@ -1222,6 +1217,12 @@ class NetEBComp : public NetEBinary { ~NetEBComp(); virtual bool set_width(unsigned w); + virtual NetExpr* eval_tree(); + + private: + NetExpr*eval_eqeq_(); + NetExpr*eval_leeq_(); + }; /* @@ -1584,6 +1585,9 @@ extern ostream& operator << (ostream&, NetNet::Type); /* * $Log: netlist.h,v $ + * Revision 1.66 1999/09/18 01:53:08 steve + * Detect constant lessthen-equal expressions. + * * Revision 1.65 1999/09/16 04:18:15 steve * elaborate concatenation repeats. *