Instance array is supported in dataflow analyzer and AST code generator.

Author: shtaxxx

pyverilog/ast_code_generator/codegen.py

@@ -746,18 +746,31 @@ def visit_DelayStatement(self, node):
         rslt = template.render(template_dict)
         return rslt
 
-    def visit_Instance(self, node):
+    def visit_InstanceList(self, node):
         filename = getfilename(node)
         template = self.env.get_template(filename)
-        portlist = [ self.visit(port) for port in node.portlist ]
         parameterlist = [ self.visit(param) for param in node.parameterlist ]
+        instances = [ self.visit(instance) for instance in node.instances ]
         template_dict = {
             'module' : node.module,
+            'parameterlist' : parameterlist,
+            'len_parameterlist' : len(parameterlist),
+            'instances' : instances,
+            'len_instances' : len(instances),
+            }
+        rslt = template.render(template_dict)
+        return rslt
+
+    def visit_Instance(self, node):
+        filename = getfilename(node)
+        template = self.env.get_template(filename)
+        array = '' if node.array is None else self.visit(node.array)
+        portlist = [ self.visit(port) for port in node.portlist ]
+        template_dict = {
             'name' : node.name,
+            'array' : array,
             'portlist' : portlist,
             'len_portlist' : len(portlist),
-            'parameterlist' : parameterlist,
-            'len_parameterlist' : len(parameterlist),
             }
         rslt = template.render(template_dict)
         return rslt

pyverilog/ast_code_generator/list_ast.txt

@@ -87,6 +87,7 @@ Initial
 WaitStatement
 ForeverStatement
 DelayStatement
+InstanceList
 Instance
 ParamArg
 PortArg

pyverilog/ast_code_generator/template/instance.txt

@@ -1,12 +1,5 @@
-{{ module }}
-{%- if len_parameterlist > 0 %}
- #({% for param in parameterlist %}
-   {{ param }}{%- if loop.index < len_parameterlist -%}, {%- endif -%}
-   {% endfor %}
-   )
-{%- endif %}
-{{ name }}
+{{ name }}{{ array }}
   ({% for port in portlist %}
    {{ port }}{%- if loop.index < len_portlist -%}, {%- endif -%}
    {% endfor %}
-   );
+   )

pyverilog/ast_code_generator/template/instancelist.txt

@@ -0,0 +1,10 @@
+{{ module }}
+{%- if len_parameterlist > 0 %}
+ #({% for param in parameterlist %}
+   {{ param }}{%- if loop.index < len_parameterlist -%}, {%- endif -%}
+   {% endfor %}
+   )
+{%- endif %}
+{%- for instance in instances %}
+{{ instance }}{%- if loop.index < len_instances -%}, {%- endif -%}
+{%- endfor -%};

pyverilog/dataflow/bindvisitor.py

@@ -135,25 +135,29 @@ def visit_Task(self, node):
         self.generic_visit(node)
         self.frames.unsetTaskDef()
 
-    def _visit_Instance_primitive(self, node):
-        primitive_type = primitives[node.module]
-        left = node.portlist[0].argname
-        right = None
-        if primitive_type == None:
-            right = Partselect(node.portlist[1].argname, IntConst('0'), IntConst('0'))
-        elif primitive_type == Unot:
-            right = Ulnot(Partselect(node.portlist[1].argname, IntConst('0'), IntConst('0')))
-        else:
-            concat_list = [Partselect(p.argname, IntConst('0'), IntConst('0')) for p in node.portlist[1:]]
-            right = primitive_type(Concat(concat_list))
-        self.addBind(left, right, bindtype='assign')
+    def visit_InstanceList(self, node):
+        for i in node.instances:
+            self.visit(i)
 
     def visit_Instance(self, node):
-        if node.module in primitives:
-            self._visit_Instance_primitive(node)
-            return
+        if node.array: return self._visit_Instance_array(node)
+        nodename = node.name
+        return self._visit_Instance_body(node, nodename)
+    
+    def _visit_Instance_array(self, node):
+        current = self.frames.getCurrent()
+        msb = self.optimize(self.getTree(node.array.msb, current)).value
+        lsb = self.optimize(self.getTree(node.array.lsb, current)).value
+        num_of_pins = msb + 1 - lsb
+        
+        for i in range(lsb, msb+1):
+            nodename = node.name + '_' + str(i)
+            self._visit_Instance_body(node, nodename, arrayindex=i)
 
-        current = self.stackInstanceFrame(node.name, node.module)
+    def _visit_Instance_body(self, node, nodename, arrayindex=None):
+        if node.module in primitives: return self._visit_Instance_primitive(node, arrayindex)
+        
+        current = self.stackInstanceFrame(nodename, node.module)
 
         scope = self.frames.getCurrent()
 
@@ -164,7 +168,7 @@ def visit_Instance(self, node):
             paramname = paramnames[paramnames_i] if param.paramname is None else param.paramname
             if paramname not in paramnames:
                 raise verror.FormatError("No such parameter: %s in %s" % 
-                                         (paramname, node.name))
+                                         (paramname, nodename))
             name = scope + ScopeLabel(paramname, 'signal')
             self.setConstant(name, value)
             definition = Parameter(paramname, str(value.value))
@@ -175,15 +179,33 @@ def visit_Instance(self, node):
         for ioport_i, port in enumerate(node.portlist):
             if port.portname is not None and not (port.portname in ioports):
                 raise verror.FormatError("No such port: %s in %s" %
-                                         (port.argname.name, node.name))
-            self.addInstancePortBind(port, ioports[ioport_i])
+                                          (port.argname.name, nodename))
+            self.addInstancePortBind(port, ioports[ioport_i], arrayindex)
 
         new_current = self.frames.getCurrent()
         self.copyFrameInfo(new_current)
 
         self.visit(self.moduleinfotable.getDefinition(node.module))
         self.frames.setCurrent(current)
 
+    def _visit_Instance_primitive(self, node, arrayindex=None):
+        primitive_type = primitives[node.module]
+        left = node.portlist[0].argname
+        if arrayindex is not None:
+            left = Pointer(left, IntConst(str(arrayindex)))
+        right = None
+        if primitive_type == None:
+            right = (Pointer(node.portlist[1].argname, IntConst('0')) if arrayindex is None else
+                     Pointer(node.portlist[1].argname, IntConst(str(arrayindex))))
+        elif primitive_type == Unot:
+            right = (Ulnot(Pointer(node.portlist[1].argname, IntConst('0'))) if arrayindex is None else
+                     Ulnot(Pointer(node.portlist[1].argname, IntConst(str(arrayindex)))))
+        else:
+            concat_list = ([Pointer(p.argname, IntConst('0')) for p in node.portlist[1:]] if arrayindex is None else
+                           [Pointer(p.argname, IntConst(str(arrayindex))) for p in node.portlist[1:]])
+            right = primitive_type(Concat(concat_list))
+        self.addBind(left, right, bindtype='assign')
+        
     def visit_Initial(self, node):
         pass
         #label = self.labels.get( self.frames.getLabelKey('initial') )
@@ -806,11 +828,10 @@ def addInstanceParameterBind(self, param, name=None):
 
         self.addDataflow(dst, param.argname, lscope, rscope, None, 'parameter')
 
-    def addInstancePortBind(self, port, instportname=None):
+    def addInstancePortBind(self, port, instportname=None, arrayindex=None):
         lscope = self.frames.getCurrent()
         rscope = lscope[:-1]
         portname = instportname if port.portname is None else port.portname
-
         ldst = self.getDestinations(portname, lscope)
         if ldst[0][0] is None:
             raise verror.DefinitionError('No such port: %s' % portname)
@@ -819,15 +840,21 @@ def addInstancePortBind(self, port, instportname=None):
         for t in termtype:
             if t == 'Input':
                 if port.argname is None: continue
-                self.addDataflow(ldst, port.argname, lscope, rscope)
+                portarg = (port.argname if arrayindex is None else
+                           Pointer(port.argname, IntConst(str(arrayindex))))
+                self.addDataflow(ldst, portarg, lscope, rscope)
             elif t == 'Output':
                 if port.argname is None: continue
-                rdst = self.getDestinations(port.argname, rscope)
+                portarg = (port.argname if arrayindex is None else
+                           Pointer(port.argname, IntConst(str(arrayindex))))
+                rdst = self.getDestinations(portarg, rscope)
                 self.addDataflow(rdst, portname, rscope, lscope)
             elif t == 'Inout':
                 if port.argname is None: continue
-                self.addDataflow(ldst, port.argname, lscope, rscope)
-                rdst = self.getDestinations(port.argname, rscope)
+                portarg = (port.argname if arrayindex is None else
+                           Pointer(port.argname, IntConst(str(arrayindex))))
+                self.addDataflow(ldst, portarg, lscope, rscope)
+                rdst = self.getDestinations(portarg, rscope)
                 self.addDataflow(rdst, portname, rscope, lscope)
 
     ############################################################################

pyverilog/dataflow/modulevisitor.py

@@ -60,6 +60,9 @@ def visit_Always(self, node):
     def visit_Initial(self, node):
         pass
 
+    def visit_InstanceList(self, node):
+        pass
+
     def visit_Instance(self, node):
         pass
 

pyverilog/dataflow/signalvisitor.py

@@ -116,10 +116,28 @@ def visit_Initial(self, node):
         #self.generic_visit(node)
         #self.frames.setCurrent(current)
 
+    def visit_InstanceList(self, node):
+        for i in node.instances:
+            self.visit(i)
+
     def visit_Instance(self, node):
-        if node.module in primitives: return
+        if node.array: return self._visit_Instance_array(node)
+        nodename = node.name
+        return self._visit_Instance_body(node, nodename)
+        
+    def _visit_Instance_array(self, node):
+        current = self.frames.getCurrent()
+        msb = self.optimize(self.getTree(node.array.msb, current)).value
+        lsb = self.optimize(self.getTree(node.array.lsb, current)).value
 
-        current = self.stackInstanceFrame(node.name, node.module)
+        for i in range(lsb, msb+1):
+            nodename = node.name + '_' + str(i)
+            self._visit_Instance_body(node, nodename)
+            
+    def _visit_Instance_body(self, node, nodename):
+        if node.module in primitives: return self._visit_Instance_primitive(node)
+
+        current = self.stackInstanceFrame(nodename, node.module)
 
         self.setInstanceSimpleConstantTerms()
 
@@ -130,7 +148,7 @@ def visit_Instance(self, node):
             paramname = paramnames[paramnames_i] if param.paramname is None else param.paramname 
             if paramname not in paramnames:
                 raise verror.FormatError("No such parameter: %s in %s" % 
-                                         (paramname, node.name))
+                                         (paramname, nodename))
             value = self.optimize(self.getTree(param.argname, current))
             name, definition = self.searchConstantDefinition(scope, paramname)
             self.setConstant(name, value)
@@ -141,6 +159,9 @@ def visit_Instance(self, node):
         self.visit(self.moduleinfotable.getDefinition(node.module))
         self.frames.setCurrent(current)
 
+    def _visit_Instance_primitive(self, node):
+        pass
+            
     def visit_Always(self, node):
         label = self.labels.get( self.frames.getLabelKey('always') )
         current = self.frames.addFrame(ScopeLabel(label, 'always'), 

pyverilog/testcode/instance_array.v

@@ -3,7 +3,9 @@ module TOP
    input [3:0] VAL,
    output [3:0] LED0,
    output [3:0] LED1,
-   output [3:0] LED2
+   output [3:0] LED2,
+   output [3:0] LED3,
+   input [3:0] in0, in1, in2
    );
 
   SUB 
@@ -17,7 +19,9 @@ module TOP
     # (.MODE(0))
     inst_sub4[3:0] (VAL, LED1),
     inst_sub5[3:0] (VAL, LED2);
-    
+
+  and U0[3:0] (LED3, in0, in1, in2);
+  
 endmodule
 
 module SUB #

pyverilog/vparser/ast.py

@@ -579,12 +579,15 @@ def children(self):
         return tuple(nodelist)
 
 class InstanceList(Node):
-    attr_names = ()
-    def __init__(self, list):
-        self.list = list
+    attr_names = ('module',)
+    def __init__(self, module, parameterlist, instances):
+        self.module = module
+        self.parameterlist = parameterlist
+        self.instances = instances
     def children(self):
         nodelist = []
-        if self.list: nodelist.extend(self.list)
+        if self.parameterlist: nodelist.extend(self.parameterlist)
+        if self.instances: nodelist.extend(self.instances)
         return tuple(nodelist)
 
 class Instance(Node):
@@ -597,9 +600,9 @@ def __init__(self, module, name, portlist, parameterlist, array=None):
         self.array = array
     def children(self):
         nodelist = []
-        if self.portlist: nodelist.extend(self.portlist)
-        if self.parameterlist: nodelist.extend(self.parameterlist)
         if self.array: nodelist.append(self.array)
+        if self.parameterlist: nodelist.extend(self.parameterlist)
+        if self.portlist: nodelist.extend(self.portlist)
         return tuple(nodelist)
 
 class ParamArg(Node):

pyverilog/vparser/parser.py

@@ -1316,14 +1316,14 @@ def p_instance(self, p):
         instancelist = []
         for instance_name, instance_ports, instance_array in p[3]:
             instancelist.append( Instance(p[1], instance_name, instance_ports, p[2], instance_array) )
-        p[0] = InstanceList( tuple(instancelist) )
+        p[0] = InstanceList(p[1], p[2], tuple(instancelist))
 
     def p_instance_or(self, p):
         'instance : SENS_OR parameterlist instance_bodylist SEMICOLON'
         instancelist = []
         for instance_name, instance_ports, instance_array in p[3]:
             instancelist.append( Instance(p[1], instance_name, instance_ports, p[2], instance_array) )
-        p[0] = InstanceList( tuple(instancelist) )
+        p[0] = InstanceList(p[1], p[2], tuple(instancelist))
 
     def p_instance_bodylist(self, p):
         'instance_bodylist : instance_bodylist COMMA instance_body'