Preliminary unpacked support for localparam

Author: Pierre-Henri Horrein

PExpr.h

@@ -456,6 +456,12 @@ class PEIdent : public PExpr {
 					NetScope*found_in,
 					ivl_type_t par_type,
                                         bool need_const) const;
+      NetExpr*elaborate_expr_param_word_(Design*des,
+					NetScope*scope,
+					const NetExpr*par,
+					NetScope*found_in,
+					ivl_type_t par_type,
+                                        bool need_const) const;
       NetExpr*elaborate_expr_param_part_(Design*des,
 					 NetScope*scope,
 					 const NetExpr*par,

design_dump.cc

@@ -109,6 +109,9 @@ ostream& operator << (ostream&o, ivl_variable_type_t val)
 	  case IVL_VT_STRING:
 	    o << "string";
 	    break;
+	  case IVL_VT_UARRAY:
+	    o << "uarray";
+	    break;
 	  case IVL_VT_DARRAY:
 	    o << "darray";
 	    break;
@@ -1673,6 +1676,19 @@ void NetEArrayPattern::dump(ostream&fd) const
       fd << "}";
 }
 
+void NetEArrayPatternParam::dump(ostream&fd) const
+{
+      fd << "'{";
+      if (items_.size() >= 1) {
+	    if (items_[0]) fd << *items_[0];
+      }
+      for (size_t idx = 1 ; idx < items_.size() ; idx += 1) {
+	    fd << ", ";
+	    if (items_[idx]) fd << *items_[idx];
+      }
+      fd << "}";
+}
+
 void NetEBinary::dump(ostream&o) const
 {
       if (op_ == 'm' || op_ == 'M') {

dup_expr.cc

@@ -43,6 +43,17 @@ NetEArrayPattern*NetEArrayPattern::dup_expr() const
       return res;
 }
 
+NetEArrayPatternParam*NetEArrayPatternParam::dup_expr() const
+{
+      vector<NetExpr*>tmp (items_.size());
+      for (size_t idx = 0 ; idx < tmp.size() ; idx += 1)
+	    tmp[idx] = items_[idx]->dup_expr();
+
+      NetEArrayPatternParam*res = new NetEArrayPatternParam(scope_, name_, net_type(), tmp);
+      res->set_line(*this);
+      return res;
+}
+
 NetEBinary* NetEBinary::dup_expr() const
 {
       ivl_assert(*this, 0);

elab_expr.cc

@@ -109,6 +109,7 @@ NetExpr* elaborate_rval_expr(Design*des, NetScope*scope, ivl_type_t lv_net_type,
       int context_wid = -1;
       switch (lv_type) {
 	  case IVL_VT_DARRAY:
+	  case IVL_VT_UARRAY:
 	  case IVL_VT_QUEUE:
 	  case IVL_VT_CLASS:
 	      // For these types, use a different elab_and_eval that
@@ -186,11 +187,11 @@ NetExpr* PExpr::elaborate_expr(Design*des, NetScope*, unsigned, unsigned) const
  */
 unsigned PEAssignPattern::test_width(Design*, NetScope*, width_mode_t&)
 {
-      expr_type_  = IVL_VT_DARRAY;
-      expr_width_ = 1;
-      min_width_  = 1;
+      expr_type_  = IVL_VT_UARRAY;
+      expr_width_ = parms_.size();
+      min_width_  = expr_width_;
       signed_flag_= false;
-      return 1;
+      return expr_width_;
 }
 
 NetExpr*PEAssignPattern::elaborate_expr(Design*des, NetScope*scope,
@@ -208,7 +209,8 @@ NetExpr*PEAssignPattern::elaborate_expr(Design*des, NetScope*scope,
       }
 
       if (ntype->base_type()==IVL_VT_DARRAY ||
-          ntype->base_type()==IVL_VT_QUEUE)
+          ntype->base_type()==IVL_VT_QUEUE ||
+          ntype->base_type()==IVL_VT_UARRAY)
 	    return elaborate_expr_darray_(des, scope, ntype, flags);
 
       cerr << get_fileline() << ": sorry: I don't know how to elaborate "
@@ -222,7 +224,7 @@ NetExpr*PEAssignPattern::elaborate_expr(Design*des, NetScope*scope,
 NetExpr*PEAssignPattern::elaborate_expr_darray_(Design*des, NetScope*scope,
 						ivl_type_t ntype, unsigned flags) const
 {
-      const netdarray_t*array_type = dynamic_cast<const netdarray_t*> (ntype);
+      const netarray_t*array_type = dynamic_cast<const netarray_t*> (ntype);
       ivl_assert(*this, array_type);
 
 	// This is an array pattern, so run through the elements of
@@ -240,15 +242,12 @@ NetExpr*PEAssignPattern::elaborate_expr_darray_(Design*des, NetScope*scope,
       return res;
 }
 
-NetExpr* PEAssignPattern::elaborate_expr(Design*des, NetScope*, unsigned, unsigned) const
+NetExpr* PEAssignPattern::elaborate_expr(Design*des, NetScope*scope, unsigned width, unsigned flags) const
 {
       cerr << get_fileline() << ": sorry: I do not know how to"
 	   << " elaborate assignment patterns using old method." << endl;
       cerr << get_fileline() << ":      : Expression is: " << *this
 	   << endl;
-      des->errors += 1;
-      ivl_assert(*this, 0);
-      return 0;
 }
 
 unsigned PEBinary::test_width(Design*des, NetScope*scope, width_mode_t&mode)
@@ -3728,6 +3727,7 @@ bool PEIdent::calculate_packed_indices_(Design*des, NetScope*scope, NetNet*net,
       switch (net->data_type()) {
 	  case IVL_VT_STRING:
 	  case IVL_VT_DARRAY:
+	  case IVL_VT_UARRAY:
 	  case IVL_VT_QUEUE:
 	    dimensions += 1;
 	  default:
@@ -4606,9 +4606,9 @@ NetExpr* PEIdent::elaborate_expr(Design*des, NetScope*scope,
 	    NetExpr*tmp = elaborate_expr_param_(des, scope, par, found_in,
                                                 par_type, expr_wid, flags);
 
-            if (!tmp) return 0;
+       if (!tmp) return 0;
 
-            return pad_to_width(tmp, expr_wid, signed_flag_, *this);
+       return pad_to_width(tmp, expr_wid, signed_flag_, *this);
       }
 
 	// If the identifier names a signal (a variable or a net)
@@ -5123,6 +5123,77 @@ NetExpr* PEIdent::elaborate_expr_param_bit_(Design*des, NetScope*scope,
       return tmp;
 }
 
+NetExpr* PEIdent::elaborate_expr_param_word_(Design*des, NetScope*scope,
+					    const NetExpr*par,
+					    NetScope*found_in,
+					    ivl_type_t par_type,
+                                            bool need_const) const
+{
+      const NetEArrayPattern*par_ex = dynamic_cast<const NetEArrayPattern*> (par);
+      ivl_assert(*this, par_ex);
+      const netuarray_t*array = dynamic_cast<const netuarray_t*> (par->net_type());
+      if (!array) {
+         cerr << get_fileline() << "tried to get a word from non-array expression" << endl;
+         return 0;
+      }
+
+      long par_msv, par_lsv;
+      if(! calculate_param_range(*this, par_type, par_msv, par_lsv,
+				 par_ex->item_size())) return 0;
+
+      const name_component_t&name_tail = path_.back();
+      ivl_assert(*this, !name_tail.index.empty());
+      const index_component_t&index_tail = name_tail.index.back();
+      ivl_assert(*this, index_tail.msb);
+      ivl_assert(*this, !index_tail.lsb);
+
+      NetExpr*sel = elab_and_eval(des, scope, index_tail.msb, -1, need_const);
+      if (sel == 0) return 0;
+
+      if (debug_elaborate)
+	    cerr << get_fileline() << ": debug: Calculate bit select "
+		 << "[" << *sel << "] from range "
+		 << "[" << par_msv << ":" << par_lsv << "]." << endl;
+
+      perm_string name = peek_tail_name(path_);
+
+	// Handle the special case that the selection is constant. In this
+	// case, just precalculate the entire constant result.
+      NetEConst*sel_c = dynamic_cast<NetEConst*> (sel);
+      if (!sel_c) {
+         cerr << get_fileline() << "tried to get a word with non constant selector" << endl;
+         return 0;
+      }
+	   // Special case: If the bit select is constant and not fully
+	   // defined, then we know that the result must be 1'bx.
+	   if (! sel_c->value().is_defined()) {
+		 if (warn_ob_select) {
+		  cerr << get_fileline() << ": warning: "
+		          "Constant undefined bit select ["
+		       << sel_c->value() << "] for parameter '"
+		       << name << "'." << endl;
+		  cerr << get_fileline() << ":        : "
+		          "Replacing select with a constant 1'bx."
+		       << endl;
+		 }
+
+	// This is a convenience function for getting the width of an
+	// element. Strictly speaking it's not necessary.
+		 NetEConst*res = make_const_x(array->element_type()->packed_width());
+		 res->set_line(*this);
+		 return res;
+	   }
+	     // Calculate the canonical index value.
+	   long sel_v = sel_c->value().as_long();
+      sel_v -= par_msv;
+
+	     // Select a bit from the parameter.
+      NetExpr*res = (NetExpr *)par_ex->item(sel_v);
+	   //NetEConst*res = new NetEConst(rtn);
+	   res->set_line(*this);
+      return res;
+}
+
 NetExpr* PEIdent::elaborate_expr_param_part_(Design*des, NetScope*scope,
 					     const NetExpr*par,
 					     NetScope*,
@@ -5449,6 +5520,7 @@ NetExpr* PEIdent::elaborate_expr_param_(Design*des,
 
       const name_component_t&name_tail = path_.back();
       index_component_t::ctype_t use_sel = index_component_t::SEL_NONE;
+      // FIXME: this won't work with multidimensional array
       if (!name_tail.index.empty())
 	    use_sel = name_tail.index.back().sel;
 
@@ -5464,8 +5536,13 @@ NetExpr* PEIdent::elaborate_expr_param_(Design*des,
       ivl_assert(*this, use_sel != index_component_t::SEL_BIT_LAST);
 
       if (use_sel == index_component_t::SEL_BIT)
-	    return elaborate_expr_param_bit_(des, scope, par, found_in,
-					     par_type, need_const);
+       if (par->expr_type() == IVL_VT_UARRAY) {
+          return elaborate_expr_param_word_(des, scope, par, found_in,
+                       par_type, need_const);
+       } else {
+          return elaborate_expr_param_bit_(des, scope, par, found_in,
+                       par_type, need_const);
+       }
 
       if (use_sel == index_component_t::SEL_PART)
 	    return elaborate_expr_param_part_(des, scope, par, found_in,
@@ -5521,6 +5598,19 @@ NetExpr* PEIdent::elaborate_expr_param_(Design*des,
 			     << "Elaborate parameter <" << name
 			     << "> as constant " << *tmp << endl;
 	    }
+
+       const NetEArrayPattern*atmp = dynamic_cast<const NetEArrayPattern*>(par);
+       if (atmp) {
+         std::vector<NetExpr*> items(atmp->item_size());
+         for (int i = 0; i < atmp->item_size(); i++) {
+            items[i] = (NetExpr*)atmp->item(i);
+         }
+         tmp = new NetEArrayPatternParam(found_in, name, atmp->net_type(), items);
+         if (debug_elaborate)
+          cerr << get_fileline() << ": debug: "
+               << "Elaborate parameter <" << name
+               << "> as constant " << *tmp << endl;
+       }
 	      /* The numeric parameter value needs to have the file and line
 	       * information for the actual parameter not the expression. */
 	    assert(tmp);

emit.cc

@@ -593,6 +593,11 @@ void NetEArrayPattern::expr_scan(struct expr_scan_t*tgt) const
       tgt->expr_array_pattern(this);
 }
 
+void NetEArrayPatternParam::expr_scan(struct expr_scan_t*tgt) const
+{
+      tgt->expr_array_pattern(this);
+}
+
 void NetEBinary::expr_scan(struct expr_scan_t*tgt) const
 {
       tgt->expr_binary(this);

ivl_target.h

@@ -460,9 +460,10 @@ typedef enum ivl_variable_type_e ENUM_UNSIGNED_INT {
       IVL_VT_BOOL    = 3,
       IVL_VT_LOGIC   = 4,
       IVL_VT_STRING  = 5,
-      IVL_VT_DARRAY  = 6,  /* Array (esp. dynamic array) */
-      IVL_VT_CLASS   = 7,  /* SystemVerilog class instances */
-      IVL_VT_QUEUE   = 8,  /* SystemVerilog queue instances */
+      IVL_VT_UARRAY  = 6,  /* Array (esp. unpacked array) */
+      IVL_VT_DARRAY  = 7,  /* Array (esp. dynamic array) */
+      IVL_VT_CLASS   = 8,  /* SystemVerilog class instances */
+      IVL_VT_QUEUE   = 9,  /* SystemVerilog queue instances */
       IVL_VT_VECTOR = IVL_VT_LOGIC /* For compatibility */
 } ivl_variable_type_t;
 

main.cc

@@ -178,7 +178,7 @@ bool ignore_missing_modules = false;
  */
 bool debug_scopes = false;
 bool debug_eval_tree = false;
-bool debug_elaborate = false;
+bool debug_elaborate = true;
 bool debug_emit = false;
 bool debug_synth2 = false;
 bool debug_optimizer = false;

net_design.cc

@@ -508,6 +508,31 @@ void Design::evaluate_parameters()
       }
 }
 
+void NetScope::evaluate_parameter_array_(Design*des, param_ref_t cur)
+{
+      PExpr*val_expr = (*cur).second.val_expr;
+      NetScope*val_scope = (*cur).second.val_scope;
+      ivl_type_t param_type = cur->second.ivl_type;
+
+      ivl_assert(cur->second, val_expr);
+      ivl_assert(cur->second, param_type);
+
+      NetExpr*expr = elab_and_eval(des, val_scope, val_expr, param_type, true);
+      if (! expr)
+	    return;
+
+      cur->second.val = expr;
+
+      if (debug_elaborate) {
+	    cerr << cur->second.get_fileline() << ": " << __func__ << ": "
+		 << "Parameter type: " << *param_type << endl;
+	    cerr << cur->second.get_fileline() << ": " << __func__ << ": "
+		 << "Parameter value: " << *val_expr << endl;
+	    cerr << cur->second.get_fileline() << ": " << __func__ << ": "
+		 << "Elaborated value: " << *expr << endl;
+      }
+
+}
 void NetScope::evaluate_parameter_logic_(Design*des, param_ref_t cur)
 {
 	/* Evaluate the parameter expression. */
@@ -840,7 +865,7 @@ void NetScope::evaluate_parameter_(Design*des, param_ref_t cur)
       if (cur->second.val_expr == 0)
             return;
 
-      // Guess the varaiable type of the parameter. If the parameter has no
+      // Guess the variable type of the parameter. If the parameter has no
       // given type, then guess the type from the expression and use that to
       // evaluate.
       ivl_variable_type_t use_type;
@@ -849,6 +874,14 @@ void NetScope::evaluate_parameter_(Design*des, param_ref_t cur)
       else
 	    use_type = cur->second.val_expr->expr_type();
 
+      if (debug_elaborate) {
+         cerr << cur->second.get_fileline() << ": evaluating parameter " << cur->first
+            << ", param_type: " << param_type;
+         if (param_type) 
+            cerr << "(base type: " << param_type->base_type() << ")";
+         cerr << ", use_type: " << use_type
+               << "." << endl;
+      }
       if (cur->second.solving) {
             cerr << cur->second.get_fileline() << ": error: "
 	         << "Recursive parameter reference found involving "
@@ -868,9 +901,13 @@ void NetScope::evaluate_parameter_(Design*des, param_ref_t cur)
                   evaluate_parameter_real_(des, cur);
                   break;
 
-		case IVL_VT_STRING:
-		  evaluate_parameter_string_(des, cur);
-		  break;
+                case IVL_VT_UARRAY:
+                  evaluate_parameter_array_(des, cur);
+                  break;
+
+                case IVL_VT_STRING:
+                  evaluate_parameter_string_(des, cur);
+                  break;
 
                 default:
                   cerr << cur->second.get_fileline() << ": internal error: "