Add new synthsplit functor.

This provides support for handling synthesis constructs in the vlog95
target.

Makefile.in

@@ -100,7 +100,7 @@ CTARGETFLAGS = @CTARGETFLAGS@
 M = LineInfo.o StringHeap.o
 
 TT = t-dll.o t-dll-api.o t-dll-expr.o t-dll-proc.o t-dll-analog.o
-FF = cprop.o nodangle.o synth.o synth2.o syn-rules.o
+FF = cprop.o nodangle.o synth.o synth2.o synthsplit.o syn-rules.o
 
 O = main.o async.o design_dump.o discipline.o dup_expr.o elaborate.o \
     elab_expr.o elaborate_analog.o elab_lval.o elab_net.o \

functor.cc

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999-2012 Stephen Williams (steve@icarus.com)
+ * Copyright (c) 1999-2016 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
@@ -102,6 +102,10 @@ void functor_t::sign_extend(Design*, NetSignExtend*)
 {
 }
 
+void functor_t::lpm_substitute(Design*, NetSubstitute*)
+{
+}
+
 void functor_t::lpm_ureduce(Design*, NetUReduce*)
 {
 }
@@ -255,6 +259,11 @@ void NetSignExtend::functor_node(Design*des, functor_t*fun)
       fun->sign_extend(des, this);
 }
 
+void NetSubstitute::functor_node(Design*des, functor_t*fun)
+{
+      fun->lpm_substitute(des, this);
+}
+
 void NetUReduce::functor_node(Design*des, functor_t*fun)
 {
       fun->lpm_ureduce(des, this);

functor.h

@@ -1,7 +1,7 @@
 #ifndef IVL_functor_H
 #define IVL_functor_H
 /*
- * Copyright (c) 1999-2014 Stephen Williams (steve@icarus.com)
+ * Copyright (c) 1999-2016 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
@@ -89,6 +89,9 @@ struct functor_t {
 	/* This method is called for each power. */
       virtual void lpm_pow(class Design*des, class NetPow*);
 
+	/* This method is called for each part substitute. */
+      virtual void lpm_substitute(class Design*des, class NetSubstitute*);
+
 	/* This method is called for each unary reduction gate. */
       virtual void lpm_ureduce(class Design*des, class NetUReduce*);
 

main.cc

@@ -1,5 +1,5 @@
 const char COPYRIGHT[] =
-          "Copyright (c) 1998-2015 Stephen Williams (steve@icarus.com)";
+          "Copyright (c) 1998-2016 Stephen Williams (steve@icarus.com)";
 
 /*
  *    This source code is free software; you can redistribute it
@@ -228,6 +228,7 @@ bool synthesis = false;
 extern void cprop(Design*des);
 extern void synth(Design*des);
 extern void synth2(Design*des);
+extern void synthsplit(Design*des);
 extern void syn_rules(Design*des);
 extern void nodangle(Design*des);
 
@@ -236,11 +237,12 @@ static struct net_func_map {
       const char*name;
       void (*func)(Design*);
 } func_table[] = {
-      { "cprop",   &cprop },
+      { "cprop",      &cprop },
-      { "nodangle",&nodangle },
+      { "nodangle",   &nodangle },
-      { "synth",   &synth },
+      { "synth",      &synth },
-      { "synth2",  &synth2 },
+      { "synth2",     &synth2 },
-      { "syn-rules",   &syn_rules },
+      { "synthsplit", &synthsplit },
+      { "syn-rules",  &syn_rules },
       { 0, 0 }
 };
 

netlist.h

@@ -261,6 +261,7 @@ class NetObj  : public NetPins, public Attrib {
       const NetScope* scope() const;
 
       perm_string name() const { return name_; }
+      void rename(perm_string n) { name_ = n; }
 
       const NetExpr* rise_time() const { return delay1_; }
       const NetExpr* fall_time() const { return delay2_; }
@@ -2260,6 +2261,7 @@ class NetSubstitute : public NetNode {
 
       virtual void dump_node(ostream&, unsigned ind) const;
       virtual bool emit_node(struct target_t*tgt) const;
+      virtual void functor_node(Design*des, functor_t*fun);
 
     private:
       unsigned wid_;

synthsplit.cc

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2016 Martin Whitaker (icarus@martin-whitaker.me.uk)
+ *
+ *    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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+# include "config.h"
+
+# include  <cstdlib>
+# include  <sstream>
+# include  "netlist.h"
+# include  "functor.h"
+# include  "compiler.h"
+# include  "ivl_assert.h"
+
+
+/*
+ * The synthsplit functor is primarily provided for use by the vlog95
+ * target. To implement some LPM objects, it needs to take a bit or part
+ * of one of the LPM inputs. If that input is not connected to a real
+ * net in the design, we need to create a net at that point so that
+ * there is something to which we can apply a bit or part select. This
+ * has the effect of splitting the synthesised structure at that point.
+ * Rather than creating a new net, we just look for a temporary net
+ * created by the synthesis process (there should be at least one) and
+ * reset its "local" flag. We also prepend another '_' to the synthetic
+ * name to avoid name collisions when we recompile the vlog95 output
+ * (because NetScope::local_symbol() doesn't actually check that the
+ * name it generates is unique).
+ */
+
+struct synthsplit_functor  : public functor_t {
+
+      unsigned count;
+
+      virtual void lpm_mux(Design*des, NetMux*obj);
+      virtual void lpm_part_select(Design*des, NetPartSelect*obj);
+      virtual void lpm_substitute(Design*des, NetSubstitute*obj);
+};
+
+static bool expose_nexus(Nexus*nex)
+{
+      NetNet*sig = 0;
+      for (Link*cur = nex->first_nlink() ; cur ; cur = cur->next_nlink()) {
+
+	    NetNet*cur_sig = dynamic_cast<NetNet*> (cur->get_obj());
+	    if (cur_sig == 0)
+		  continue;
+
+	    if (!cur_sig->local_flag())
+		  return false;
+
+	    sig = cur_sig;
+      }
+      assert(sig);
+      ostringstream res;
+      res << "_" << sig->name();
+      sig->rename(lex_strings.make(res.str()));
+      sig->local_flag(false);
+      return true;
+}
+
+/*
+ * The vlog95 target implements a wide mux as a hierarchy of 2:1 muxes,
+ * picking off one bit of the select input at each level of the hierarchy.
+ */
+void synthsplit_functor::lpm_mux(Design*, NetMux*obj)
+{
+      if (obj->sel_width() == 1)
+	    return;
+
+      if (expose_nexus(obj->pin_Sel().nexus()))
+	    count += 1;
+}
+
+/*
+ * A VP part select is going to select a part from its input.
+ */
+void synthsplit_functor::lpm_part_select(Design*, NetPartSelect*obj)
+{
+      if (obj->dir() != NetPartSelect::VP)
+	    return;
+
+      if (expose_nexus(obj->pin(1).nexus()))
+	    count += 1;
+}
+
+/*
+ * A substitute is going to select one or two parts from the wider input signal.
+ */
+void synthsplit_functor::lpm_substitute(Design*, NetSubstitute*obj)
+{
+      if (expose_nexus(obj->pin(1).nexus()))
+	    count += 1;
+}
+
+void synthsplit(Design*des)
+{
+      synthsplit_functor synthsplit;
+      synthsplit.count = 0;
+      if (verbose_flag) {
+	    cout << " ... Look for intermediate nodes" << endl << flush;
+      }
+      des->functor(&synthsplit);
+      if (verbose_flag) {
+	    cout << " ... Exposed " << synthsplit.count 
+		 << " intermediate signals." << endl << flush;
+      }
+}