Merge branch 'master' into verilog-ams

[sverilog.git] / net_design.cc

/*
 * Copyright (c) 2000-2007 Stephen Williams (steve@icarus.com)
 *
 *    This source code is free software; you can redistribute it
 *    and/or modify it in source code form under the terms of the GNU
 *    General Public License as published by the Free Software
 *    Foundation; either version 2 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, write to the Free Software
 *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

# include "config.h"

# include  <iostream>
# include  <cstdlib>

/*
 * This source file contains all the implementations of the Design
 * class declared in netlist.h.
 */

# include  "netlist.h"
# include  "util.h"
# include  "compiler.h"
# include  "netmisc.h"
# include  <sstream>
# include  "ivl_assert.h"

Design:: Design()
: errors(0), nodes_(0), procs_(0), lcounter_(0)
{
      procs_idx_ = 0;
      des_precision_ = 0;
      nodes_functor_cur_ = 0;
      nodes_functor_nxt_ = 0;
}

Design::~Design()
{
}

string Design::local_symbol(const string&path)
{
      ostringstream res;
      res << path << "." << "_L" << lcounter_;
      lcounter_ += 1;

      return res.str();
}

void Design::set_precision(int val)
{
      if (val < des_precision_)
            des_precision_ = val;
}

int Design::get_precision() const
{
      return des_precision_;
}

uint64_t Design::scale_to_precision(uint64_t val,
                                    const NetScope*scope) const
{
      int units = scope->time_unit();
      assert( units >= des_precision_ );

      while (units > des_precision_) {
            units -= 1;
            val *= 10;
      }

      return val;
}

NetScope* Design::make_root_scope(perm_string root)
{
      NetScope *root_scope_;
      root_scope_ = new NetScope(0, hname_t(root), NetScope::MODULE);
        /* This relies on the fact that the basename return value is
           permallocated. */
      root_scope_->set_module_name(root_scope_->basename());
      root_scopes_.push_back(root_scope_);
      return root_scope_;
}

NetScope* Design::find_root_scope()
{
      assert(root_scopes_.front());
      return root_scopes_.front();
}

list<NetScope*> Design::find_root_scopes()
{
      return root_scopes_;
}

const list<NetScope*> Design::find_root_scopes() const
{
      return root_scopes_;
}

/*
 * This method locates a scope in the design, given its rooted
 * hierarchical name. Each component of the key is used to scan one
 * more step down the tree until the name runs out or the search
 * fails.
 */
NetScope* Design::find_scope(const std::list<hname_t>&path) const
{
      if (path.empty())
            return 0;

      for (list<NetScope*>::const_iterator scope = root_scopes_.begin()
                 ; scope != root_scopes_.end(); scope++) {

            NetScope*cur = *scope;
            if (path.front() != cur->fullname())
                  continue;

            std::list<hname_t> tmp = path;
            tmp.pop_front();

            while (cur) {
                  if (tmp.empty()) return cur;

                  cur = cur->child( tmp.front() );

                  tmp.pop_front();
            }

      }

      return 0;
}

/*
 * This is a relative lookup of a scope by name. The starting point is
 * the scope parameter within which I start looking for the scope. If
 * I do not find the scope within the passed scope, start looking in
 * parent scopes until I find it, or I run out of parent scopes.
 */
NetScope* Design::find_scope(NetScope*scope, const std::list<hname_t>&path,
                             NetScope::TYPE type) const
{
      assert(scope);
      if (path.empty())
            return scope;

      for ( ; scope ;  scope = scope->parent()) {

            std::list<hname_t> tmp = path;

            NetScope*cur = scope;
            do {
                  hname_t key = tmp.front();
                    /* If we are looking for a module or we are not
                     * looking at the last path component check for
                     * a name match (second line). */
                  if (cur->type() == NetScope::MODULE
                      && (type == NetScope::MODULE || tmp.size() > 1)
                      && cur->module_name()==key.peek_name()) {

                          /* Up references may match module name */

                  } else {
                        cur = cur->child( key );
                        if (cur == 0) break;
                  }
                  tmp.pop_front();
            } while (!tmp.empty());

            if (cur) return cur;
      }

        // Last chance. Look for the name starting at the root.
      return find_scope(path);
}

/*
 * This method runs through the scope, noticing the defparam
 * statements that were collected during the elaborate_scope pass and
 * applying them to the target parameters. The implementation actually
 * works by using a specialized method from the NetScope class that
 * does all the work for me.
 */
void Design::run_defparams()
{
      for (list<NetScope*>::const_iterator scope = root_scopes_.begin();
           scope != root_scopes_.end(); scope++)
            (*scope)->run_defparams(this);
}

void NetScope::run_defparams(Design*des)
{
      { NetScope*cur = sub_;
        while (cur) {
              cur->run_defparams(des);
              cur = cur->sib_;
        }
      }

      map<pform_name_t,NetExpr*>::const_iterator pp;
      for (pp = defparams.begin() ;  pp != defparams.end() ;  pp ++ ) {
            NetExpr*val = (*pp).second;
            pform_name_t path = (*pp).first;

            perm_string perm_name = peek_tail_name(path);
            path.pop_back();

            list<hname_t> eval_path = eval_scope_path(des, this, path);

              /* If there is no path on the name, then the targ_scope
                 is the current scope. */
            NetScope*targ_scope = des->find_scope(this, eval_path);
            if (targ_scope == 0) {
                  cerr << val->get_fileline() << ": warning: scope of " <<
                        path << "." << perm_name << " not found." << endl;
                  continue;
            }

            bool flag = targ_scope->replace_parameter(perm_name, val);
            if (! flag) {
                  cerr << val->get_fileline() << ": warning: parameter "
                       << perm_name << " not found in "
                       << scope_path(targ_scope) << "." << endl;
            }

      }
}

void Design::evaluate_parameters()
{
      for (list<NetScope*>::const_iterator scope = root_scopes_.begin();
           scope != root_scopes_.end(); scope++)
            (*scope)->evaluate_parameters(this);
}

void NetScope::evaluate_parameter_logic_(Design*des, param_ref_t cur)
{
      long msb = 0;
      long lsb = 0;
      bool range_flag = false;

        /* Evaluate the msb expression, if it is present. */
      if ((*cur).second.msb) {
            eval_expr((*cur).second.msb);
            if (! eval_as_long(msb, (*cur).second.msb)) {
                  cerr << (*cur).second.expr->get_fileline()
                       << ": internal error: "
                       << "unable to evaluate msb expression "
                       << "for parameter " << (*cur).first << ": "
                       << *(*cur).second.msb << endl;
                  des->errors += 1;
                  return;
            }

            range_flag = true;
      }

        /* Evaluate the lsb expression, if it is present. */
      if ((*cur).second.lsb) {
            eval_expr((*cur).second.lsb);
            if (! eval_as_long(lsb, (*cur).second.lsb)) {
                  cerr << (*cur).second.expr->get_fileline()
                       << ": internal error: "
                       << "unable to evaluate lsb expression "
                       << "for parameter " << (*cur).first << ": "
                       << *(*cur).second.lsb << endl;
                  des->errors += 1;
                  return;
            }

            range_flag = true;
      }


        /* Evaluate the parameter expression, if necessary. */
      NetExpr*expr = (*cur).second.expr;
      assert(expr);

      eval_expr(expr);

      /* The eval_expr may delete any replace the expr pointer, so the
         second.expr value cannot be relied on. Might as well replace
         it now with the expression that we evaluated. */
      (*cur).second.expr = expr;

      switch (expr->expr_type()) {
          case IVL_VT_REAL:
            if (! dynamic_cast<const NetECReal*>(expr)) {
                  cerr << expr->get_fileline()
                       << ": internal error: "
                       << "unable to evaluate real parameter value: "
                       << *expr << endl;
                  des->errors += 1;
                  return;
            }
            break;

          case IVL_VT_LOGIC:
          case IVL_VT_BOOL:
            if (! dynamic_cast<const NetEConst*>(expr)) {
                  cerr << expr->get_fileline()
                       << ": internal error: "
                       << "unable to evaluate parameter "
                       << (*cur).first
                       << " value: " << *expr << endl;
                  des->errors += 1;
                  return;
            }
            break;

          default:
            cerr << expr->get_fileline()
                 << ": internal error: "
                 << "unhandled expression type?" << endl;
            des->errors += 1;
            return;
      }

        /* If the parameter has range information, then make
        sure the value is set right. Note that if the
        parameter doesn't have an explicit range, then it
        will get the signedness from the expression itself. */
      if (range_flag) {
            unsigned long wid = (msb >= lsb)? msb - lsb : lsb - msb;
            wid += 1;

            NetEConst*val = dynamic_cast<NetEConst*>(expr);
            assert(val);

            verinum value = val->value();

            if (! (value.has_len()
                   && (value.len() == wid)
                   && (value.has_sign() == (*cur).second.signed_flag))) {

                  verinum tmp (value, wid);
                  tmp.has_sign ( (*cur).second.signed_flag );
                  delete val;
                  val = new NetEConst(tmp);
                  expr = val;
            }
      }

        // If there are no value ranges to test the value against,
        // then we are done.
      if ((*cur).second.range == 0) {
            return;
      }

      NetEConst*val = dynamic_cast<NetEConst*>((*cur).second.expr);
      ivl_assert(*(*cur).second.expr, (*cur).second.expr);
      ivl_assert(*(*cur).second.expr, val);

      verinum value = val->value();

      bool from_flag = (*cur).second.range == 0? true : false;
      for (range_t*value_range = (*cur).second.range
                 ; value_range ; value_range = value_range->next) {

              // If we already know that the value is
              // within a "from" range, then do not test
              // any more of the from ranges.
            if (from_flag && value_range->exclude_flag==false)
                  continue;

            if (value_range->low_expr) {
                  NetEConst*tmp = dynamic_cast<NetEConst*>(value_range->low_expr);
                  ivl_assert(*value_range->low_expr, tmp);
                  if (value_range->low_open_flag && value <= tmp->value())
                        continue;
                  else if (value < tmp->value())
                        continue;
            }

            if (value_range->high_expr) {
                  NetEConst*tmp = dynamic_cast<NetEConst*>(value_range->high_expr);
                  ivl_assert(*value_range->high_expr, tmp);
                  if (value_range->high_open_flag && value >= tmp->value())
                        continue;
                  else if (value > tmp->value())
                        continue;
            }

              // Within the range. If this is a "from"
              // range, then set the from_flag and continue.
            if (value_range->exclude_flag == false) {
                  from_flag = true;
                  continue;
            }

              // OH NO! In an excluded range. signal an error.
            from_flag = false;
            break;
      }

        // If we found no from range that contains the
        // value, then report an error.
      if (! from_flag) {
            cerr << val->get_fileline() << ": error: "
                 << "Parameter value " << value
                 << " is out of range for parameter " << (*cur).first
                 << "." << endl;
            des->errors += 1;
      }
}

void NetScope::evaluate_parameter_real_(Design*des, param_ref_t cur)
{
      NetExpr*expr = (*cur).second.expr;
      assert(expr);

      NetECReal*res = 0;
      eval_expr(expr);

      switch (expr->expr_type()) {
          case IVL_VT_REAL:
            if (NetECReal*tmp = dynamic_cast<NetECReal*>(expr)) {
                  res = tmp;
            } else {
                  ivl_assert(*expr, 0);
            }
            break;

          case IVL_VT_LOGIC:
          case IVL_VT_BOOL:
            if (NetEConst*tmp = dynamic_cast<NetEConst*>(expr)) {
                  verireal val (tmp->value().as_long());
                  res = new NetECReal(val);
                  res->set_line(*tmp);
            } else {
                  ivl_assert(*expr, 0);
            }
            break;

          default:
            ivl_assert(*expr, 0);
            break;
      }

      (*cur).second.expr = res;
      double value = res->value().as_double();

      bool from_flag = (*cur).second.range == 0? true : false;
      for (range_t*value_range = (*cur).second.range
                 ; value_range ; value_range = value_range->next) {

            if (from_flag && value_range->exclude_flag==false)
                  continue;

            if (value_range->low_expr) {
                  double tmp;
                  bool flag = eval_as_double(tmp, value_range->low_expr);
                  ivl_assert(*value_range->low_expr, flag);
                  if (value_range->low_open_flag && value <= tmp)
                        continue;
                  else if (value < tmp)
                        continue;
            }

            if (value_range->high_expr) {
                  double tmp;
                  bool flag = eval_as_double(tmp, value_range->high_expr);
                  ivl_assert(*value_range->high_expr, flag);
                  if (value_range->high_open_flag && value >= tmp)
                        continue;
                  else if (value > tmp)
                        continue;
            }

            if (value_range->exclude_flag == false) {
                  from_flag = true;
                  continue;
            }

              // All the above tests failed, so we must have tripped
              // an exclude rule.
            from_flag = false;
            break;
      }

      if (! from_flag) {
            cerr << res->get_fileline() << ": error: "
                 << "Parameter value " << value
                 << " is out of range for parameter " << (*cur).first
                 << "." << endl;
            des->errors += 1;
      }
}

void NetScope::evaluate_parameters(Design*des)
{
      NetScope*cur = sub_;
      while (cur) {
            cur->evaluate_parameters(des);
            cur = cur->sib_;
      }


        // Evaluate the parameter values. The parameter expressions
        // have already been elaborated and replaced by the scope
        // scanning code. Now the parameter expression can be fully
        // evaluated, or it cannot be evaluated at all.

      for (param_ref_t cur = parameters.begin()
                 ; cur != parameters.end() ;  cur ++) {

            switch ((*cur).second.type) {
                case IVL_VT_BOOL:
                case IVL_VT_LOGIC:
                  evaluate_parameter_logic_(des, cur);
                  break;

                case IVL_VT_REAL:
                  evaluate_parameter_real_(des, cur);
                  break;

                default:
                  cerr << (*cur).second.get_fileline() << ": internal error: "
                       << "Unexpected expression type " << (*cur).second.type
                       << "." << endl;
                  ivl_assert((*cur).second, 0);
                  break;
            }
      }

}

const char* Design::get_flag(const string&key) const
{
      map<string,const char*>::const_iterator tmp = flags_.find(key);
      if (tmp == flags_.end())
            return "";
      else
            return (*tmp).second;
}

/*
 * This method looks for a signal (reg, wire, whatever) starting at
 * the specified scope. If the name is hierarchical, it is split into
 * scope and name and the scope used to find the proper starting point
 * for the real search.
 *
 * It is the job of this function to properly implement Verilog scope
 * rules as signals are concerned.
 */
NetNet* Design::find_signal(NetScope*scope, pform_name_t path)
{
      assert(scope);

      perm_string key = peek_tail_name(path);
      path.pop_back();
      if (! path.empty()) {
            list<hname_t> eval_path = eval_scope_path(this, scope, path);
            scope = find_scope(scope, eval_path);
      }

      while (scope) {
            if (NetNet*net = scope->find_signal(key))
                  return net;

            if (scope->type() == NetScope::MODULE)
                  break;

            scope = scope->parent();
      }

      return 0;
}

NetFuncDef* Design::find_function(NetScope*scope, const pform_name_t&name)
{
      assert(scope);

      std::list<hname_t> eval_path = eval_scope_path(this, scope, name);
      NetScope*func = find_scope(scope, eval_path, NetScope::FUNC);
      if (func && (func->type() == NetScope::FUNC))
            return func->func_def();

      return 0;
}

NetScope* Design::find_task(NetScope*scope, const pform_name_t&name)
{
      std::list<hname_t> eval_path = eval_scope_path(this, scope, name);
      NetScope*task = find_scope(scope, eval_path, NetScope::TASK);
      if (task && (task->type() == NetScope::TASK))
            return task;

      return 0;
}

void Design::add_node(NetNode*net)
{
      assert(net->design_ == 0);
      if (nodes_ == 0) {
            net->node_next_ = net;
            net->node_prev_ = net;
      } else {
            net->node_next_ = nodes_->node_next_;
            net->node_prev_ = nodes_;
            net->node_next_->node_prev_ = net;
            net->node_prev_->node_next_ = net;
      }
      nodes_ = net;
      net->design_ = this;
}

void Design::del_node(NetNode*net)
{
      assert(net->design_ == this);
      assert(net != 0);

        /* Interact with the Design::functor method by manipulating the
           cur and nxt pointers that it is using. */
      if (net == nodes_functor_nxt_)
            nodes_functor_nxt_ = nodes_functor_nxt_->node_next_;
      if (net == nodes_functor_nxt_)
            nodes_functor_nxt_ = 0;

      if (net == nodes_functor_cur_)
            nodes_functor_cur_ = 0;

        /* Now perform the actual delete. */
      if (nodes_ == net)
            nodes_ = net->node_prev_;

      if (nodes_ == net) {
            nodes_ = 0;
      } else {
            net->node_next_->node_prev_ = net->node_prev_;
            net->node_prev_->node_next_ = net->node_next_;
      }

      net->design_ = 0;
}

void Design::add_process(NetProcTop*pro)
{
      pro->next_ = procs_;
      procs_ = pro;
}

void Design::delete_process(NetProcTop*top)
{
      assert(top);
      if (procs_ == top) {
            procs_ = top->next_;

      } else {
            NetProcTop*cur = procs_;
            while (cur->next_ != top) {
                  assert(cur->next_);
                  cur = cur->next_;
            }

            cur->next_ = top->next_;
      }

      if (procs_idx_ == top)
            procs_idx_ = top->next_;

      delete top;
}