siliconcompiler 0.29.4__py3-none-any.whl → 0.30.0__py3-none-any.whl

siliconcompiler/_metadata.py

@@ -1,5 +1,5 @@
 # Version number following semver standard.
-version = '0.29.4'
+version = '0.30.0'
 
 # Default server address for remote runs, if unspecified.
 default_server = 'https://server.siliconcompiler.com'

siliconcompiler/apps/sc.py

@@ -95,7 +95,7 @@ def main():
 
     try:
         # Run flow
-        chip.run()
+        chip.run(raise_exception=True)
 
         # Print Job Summary
         chip.summary()

siliconcompiler/apps/sc_install.py

@@ -248,6 +248,34 @@ To system debugging information (this should only be used to debug):
             if not install_tool(tool, tools[tool], args.build_dir, args.prefix):
                 return 1
 
+    if not args.show:
+        msgs = []
+        for env, path in (
+                ("PATH", "bin"),
+                ("LD_LIBRARY_PATH", "lib")):
+            check_path = os.path.join(args.prefix, path)
+            envs = [
+                os.path.expandvars(os.path.expanduser(p))
+                for p in os.getenv(env, "").split(":")
+            ]
+            print(envs)
+            if check_path not in envs:
+                msgs.extend([
+                    "",
+                    f"{check_path} not found in {env}",
+                    "you may need to add it the following your shell",
+                    "initialization script:",
+                    f'export {env}="{check_path}:${env}"'
+                ])
+        if msgs:
+            center_len = max(len(msg) for msg in msgs)
+            max_len = center_len + 4
+            print("#"*max_len)
+            for msg in msgs:
+                print(f"# {msg:<{center_len}} #")
+            print(f"# {' '*center_len} #")
+            print("#"*max_len)
+
     return 0
 
 

siliconcompiler/core.py

@@ -67,7 +67,7 @@ class Chip:
         except FileNotFoundError:
             raise SiliconCompilerError(
                 "SiliconCompiler must be run from a directory that exists. "
-                "If you are sure that your working directory is valid, try running `cd $(pwd)`.""")
+                "If you are sure that your working directory is valid, try running `cd $(pwd)`.")
 
         # Initialize custom error handling for codecs. This has to be called
         # by each spawned (as opposed to forked) subprocess
@@ -3153,7 +3153,7 @@ class Chip:
                     self.add('flowgraph', flow, newstep, index, 'input', (newin, in_index))
 
     ###########################################################################
-    def run(self):
+    def run(self, raise_exception=False):
         '''
         Executes tasks in a flowgraph.
 
@@ -3177,12 +3177,23 @@ class Chip:
         processes to exit before start, returning control to the the main
         program which can then exit.
 
+        Args:
+            raise_exception (bool): if True, will rethrow errors that the flow raises,
+                otherwise will report the error and return False
+
         Examples:
             >>> run()
             Runs the execution flow defined by the flowgraph dictionary.
         '''
 
-        sc_runner(self)
+        try:
+            sc_runner(self)
+        except Exception as e:
+            if raise_exception:
+                raise e
+            self.logger.error(str(e))
+            return False
+        return True
 
     ###########################################################################
     def show(self, filename=None, screenshot=False, extension=None):
@@ -3320,7 +3331,7 @@ class Chip:
 
         # run show flow
         try:
-            self.run()
+            self.run(raise_exception=True)
             if screenshot:
                 step, index = _get_flowgraph_exit_nodes(self, flow='showflow')[0]
                 success = self.find_result('png', step=step, index=index)

siliconcompiler/schema/schema_cfg.py

@@ -10,7 +10,7 @@ try:
 except ImportError:
     from siliconcompiler.schema.utils import trim
 
-SCHEMA_VERSION = '0.48.6'
+SCHEMA_VERSION = '0.49.0'
 
 #############################################################################
 # PARAM DEFINITION
@@ -1260,17 +1260,35 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_package_type 'abcd bga'",
                 "api: chip.set('datasheet', 'package', 'abcd', 'type', 'bga')"],
-            schelp="""Package type specified on a named package basis.""")
+            schelp="""Package type.""")
 
     scparam(cfg, ['datasheet', 'package', name, 'footprint'],
-            sctype='str',
+            sctype='[file]',
             shorthelp="Datasheet: package footprint",
-            switch="-datasheet_package_footprint 'name <str>'",
+            switch="-datasheet_package_footprint 'name <file>'",
+            example=[
+                "cli: -datasheet_package_footprint 'abcd ./soic8.kicad_mod'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'footprint', './soic8.kicad_mod')"],
+            schelp="""Package footprint file. Supported 3D model file formats include:
+
+            * (KICAD_MOD) KiCad Standard Footprint Format
+
+            """)
+
+    scparam(cfg, ['datasheet', 'package', name, '3dmodel'],
+            sctype='[file]',
+            shorthelp="Datasheet: package 3D model",
+            switch="-datasheet_package_3dmodel 'name <file>'",
             example=[
-                "cli: -datasheet_package_footprint 'abcd soic8'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'footprint', 'soic8')"],
-            schelp="""Package footprint name. The name of the footprint can be a standard
-            footprint name or a reference designator from a footprint library.""")
+                "cli: -datasheet_package_3dmodel 'abcd ./soic8.step'",
+                "api: chip.set('datasheet', 'package', 'abcd', '3dmodel', './soic8.step')"],
+            schelp="""Package 3D model file. Supported 3D model file formats include:
+
+            * (STEP) Standard for the Exchange of Product Data Format
+            * (STL) Stereolithography Format
+            * (WRL) Virtually Reality Modeling Language Format
+
+            """)
 
     scparam(cfg, ['datasheet', 'package', name, 'drawing'],
             sctype='[file]',
@@ -1279,38 +1297,14 @@ def schema_datasheet(cfg, name='default', mode='default'):
             example=[
                 "cli: -datasheet_package_drawing 'abcd p484.pdf'",
                 "api: chip.set('datasheet', 'package', 'abcd', 'drawing', 'p484.pdf')"],
-            schelp="""Mechanical package outline for documentation purposes.
-            Common file formats include PDF, DOC, SVG, and PNG.""")
+            schelp="""Mechanical drawing for documentation purposes.
+            Supported file formats include: PDF, DOC, SVG, and PNG.""")
 
-    scparam(cfg, ['datasheet', 'package', name, 'pincount'],
-            sctype='int',
-            shorthelp="Datasheet: package total pincount",
-            switch="-datasheet_package_pincount 'name <int>'",
-            example=[
-                "cli: -datasheet_package_pincount 'abcd 484'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pincount', '484')"],
-            schelp="""Total number package pins of the named package.""")
-
-    scparam(cfg, ['datasheet', 'package', name, 'anchor'],
-            sctype='(float,float)',
-            defvalue=(0.0, 0.0),
-            unit='um',
-            shorthelp="Datasheeet: package anchor",
-            switch="-datasheet_package_anchor 'name <(float,float)>'",
-            example=[
-                "cli: -datasheet_package_anchor 'i0 (3.0,3.0)'",
-                "api: chip.set('datasheet', 'package', 'i0', 'anchor', (3.0, 3.0))"],
-            schelp="""
-            Package anchor point with respect to the lower left corner of the package.
-            When placing a component on a substrate, the placement location specifies
-            the distance from the substrate origin to the anchor point of the placed
-            object.""")
-
-    # critical dimensions
+    # key package metrics
     metrics = {'length': ['length', (4000, 4000, 4000), 'um'],
                'width': ['width', (4000, 4000, 4000), 'um'],
                'thickness': ['thickness', (900, 1000, 1100), 'um'],
-               'pitch': ['pitch', (800, 850, 900), 'um']
+               'pinpitch': ['pin pitch', (800, 850, 900), 'um']
                }
 
     for i, v in metrics.items():
@@ -1322,63 +1316,46 @@ def schema_datasheet(cfg, name='default', mode='default'):
                 example=[
                     f"cli: -datasheet_package_{i} 'abcd {v[1]}'",
                     f"api: chip.set('datasheet', 'package', 'abcd', '{i}', {v[1]}"],
-                schelp=f"""Datasheet: package {v[0]}. Values are tuples of
+                schelp=f"""Package {v[0]}. Values are tuples of
                 (min, nominal, max).""")
 
-    # pinout diagram
-    pinnumber = 'default'
-    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'shape'],
-            sctype='enum',
-            enum=['circle', 'rectangle', 'square', 'octagon'],
-            shorthelp="Datasheet: package pin shape",
-            switch="-datasheet_package_pin_shape 'name pinnumber <str>'",
+    # pin
+    scparam(cfg, ['datasheet', 'package', name, 'pincount'],
+            sctype='int',
+            shorthelp="Datasheet: package pin count",
+            switch="-datasheet_package_pincount 'name <int>'",
             example=[
-                "cli: -datasheet_package_pin_shape 'abcd B1 circle'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'shape', 'circle')"],
-            schelp="""Datasheet: package pin shape specified on a per package
-            and per pin number basis.""")
-
-    metrics = {'width': ['width', (200, 250, 300), 'um'],
-               'length': ['length', (200, 250, 300), 'um']
-               }
+                "cli: -datasheet_package_pincount 'abcd 484'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'pincount', '484')"],
+            schelp="""Total number package pins.""")
 
-    for i, v in metrics.items():
-        scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, i],
-                unit=v[2],
-                sctype='(float,float,float)',
-                shorthelp=f"Datasheet: package pin {v[0]}",
-                switch=f"-datasheet_package_pin_{i} 'name pinnumber <(float,float,float)>'",
-                example=[
-                    f"cli: -datasheet_package_pin_{i} 'abcd B1 {v[1]}'",
-                    f"api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', '{i}', {v[1]}"],
-                schelp=f"""Datsheet: {v[0]} specified on a per package and per pin number
-                basis. Values are tuples of (min, nominal, max).""")
+    number = 'default'
+    scparam(cfg, ['datasheet', 'package', name, 'pin', number, 'signal'],
+            sctype='str',
+            shorthelp="Datasheet: package pin signal map",
+            switch="-datasheet_package_pin_signal 'name number <str>'",
+            example=[
+                "cli: -datasheet_package_pin_signal 'abcd B1 clk'",
+                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'signal', 'clk')"],
+            schelp="""Mapping between the package physical pin name ("1", "2", "A1", "B3", ...)
+            and the corresponding device signal name ("VDD", "CLK", "NRST") found in the
+            :keypath:`datasheet,pin`.""")
 
-    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'loc'],
+    # anchor
+    scparam(cfg, ['datasheet', 'package', name, 'anchor'],
             sctype='(float,float)',
+            defvalue=(0.0, 0.0),
             unit='um',
-            shorthelp="Datasheet: package pin location",
-            switch="-datasheet_package_pin_loc 'name pinnumber <(float,float)>'",
+            shorthelp="Datasheet: package anchor",
+            switch="-datasheet_package_anchor 'name <(float,float)>'",
             example=[
-                "cli: -datasheet_package_pin_loc 'abcd B1 (500,500)'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'loc', (500,500)"],
-            schelp="""Datsheet: Package pin location specified as an (x,y) tuple on a per
-            package and per pin number basis. Locations specify the center of the pin with
-            respect to the center of the package.""")
-
-    scparam(cfg, ['datasheet', 'package', name, 'pin', pinnumber, 'name'],
-            sctype='str',
-            shorthelp="Datasheet: package pin name",
-            switch="-datasheet_package_pin_name 'name pinnumber <str>'",
-            example=[
-                "cli: -datasheet_package_pin_name 'abcd B1 clk'",
-                "api: chip.set('datasheet', 'package', 'abcd', 'pin', 'B1', 'name', 'clk')"],
-            schelp="""Datsheet: Package pin name specified on a per package and per pin
-            number basis. The pin number is generally an integer starting at '1' in the case of
-            packages like qfn, qfp and an array index ('A1', 'A2') in the case of array packages
-            like bgas. The pin name refers to the logical function assigned to the physical
-            pin number (e.g clk, vss, in). Details regarding the logical pin is stored in
-            the :keypath:`datasheet,pin`.""")
+                "cli: -datasheet_package_anchor 'i0 (3.0, 3.0)'",
+                "api: chip.set('datasheet', 'package', 'i0', 'anchor', (3.0, 3.0))"],
+            schelp="""
+            Package anchor point with respect to the lower left corner of the package.
+            When placing a component on a substrate, the placement location specifies
+            the distance from the substrate origin to the anchor point of the placed
+            object.""")
 
     ######################
     # Pin Specifications
@@ -3784,10 +3761,11 @@ def schema_constraint(cfg):
                 "api: chip.set('constraint', 'component', 'i0', 'halo', (1, 1))"],
             schelp="""
             Placement keepout halo around the named component, specified as a
-            (horizontal, vertical) tuple represented in microns.""")
+            (horizontal, vertical) tuple.""")
 
     scparam(cfg, ['constraint', 'component', inst, 'rotation'],
             sctype='enum',
+            pernode='optional',
             defvalue='R0',
             enum=['R0', 'R90', 'R180', 'R270',
                   'MX', 'MX_R90', 'MX_R180', 'MX_R270',
@@ -3795,7 +3773,6 @@ def schema_constraint(cfg):
                   'MZ', 'MZ_R90', 'MZ_R180', 'MZ_R270',
                   'MZ_MX', 'MZ_MX_R90', 'MZ_MX_R180', 'MZ_MX_R270',
                   'MZ_MY', 'MZ_MY_R90', 'MZ_MY_R180', 'MZ_MY_R270'],
-            pernode='optional',
             shorthelp="Constraint: component rotation",
             switch="-constraint_component_rotation 'inst <str>'",
             example=[
@@ -3829,6 +3806,49 @@ def schema_constraint(cfg):
         * ``MZ_MX_R270``, ``MZ_MY_R90``: Reverse metal stack, flip on x-axis and rotate 270 deg ccw
             """)
 
+    scparam(cfg, ['constraint', 'component', inst, 'substrate'],
+            sctype='str',
+            pernode='optional',
+            shorthelp="Constraint: component substrate",
+            switch="-constraint_component_substrate 'inst <str>'",
+            example=[
+                "cli: -constraint_component_substrate 'i0 pcb0'",
+                "api: chip.set('constraint', 'component', 'i0', 'substrate', 'pcb0')"],
+            schelp="""
+            Substrates are supporting material that components are placed upon.
+            List of supported substrates includes (but not limited to):
+            wafers, dies, panels, PCBs.""")
+
+    scparam(cfg, ['constraint', 'component', inst, 'side'],
+            sctype='enum',
+            enum=['left', 'right', 'front', 'back', 'top', 'bottom'],
+            pernode='optional',
+            shorthelp="Constraint: component side",
+            switch="-constraint_component_side 'inst <str>'",
+            example=[
+                "cli: -constraint_component_side 'i0 top'",
+                "api: chip.set('constraint', 'component', 'i0', 'side', 'top')"],
+            schelp="""
+            Side of the substrate where the component should be placed. The `side`
+            definitions are with respect to a viewer looking sideways at an object.
+            Top is towards the sky, front is the side closest to the viewer, and
+            right is right. The maximum number of sides per substrate is six""")
+
+    scparam(cfg, ['constraint', 'component', inst, 'zheight'],
+            sctype='float',
+            pernode='optional',
+            unit='um',
+            shorthelp="Constraint: component placement zheight",
+            switch="-constraint_component_zheight 'inst <float>'",
+            example=[
+                "cli: -constraint_component_zheight 'i0 100.0'",
+                "api: chip.set('constraint', 'component', 'i0', 'zheight', 100.0)"],
+            schelp="""
+            Height above the substrate for component placement. The space
+            between the component and substrate is occupied by material,
+            supporting scaffolding, and electrical connections (eg. bumps,
+            vias, pillars).""")
+
     # PINS
     name = 'default'
     scparam(cfg, ['constraint', 'pin', name, 'placement'],
@@ -3848,6 +3868,44 @@ def schema_constraint(cfg):
             may adjust sizes to meet competing goals such as manufacturing design
             rules and grid placement guidelines.""")
 
+    metrics = {'width': ['width', 1.0],
+               'length': ['length', 1.0],
+               'height': ['height', 1.0]
+               }
+
+    for i, v in metrics.items():
+        scparam(cfg, ['constraint', 'pin', name, i],
+                sctype='float',
+                unit='um',
+                pernode='optional',
+                shorthelp=f"Constraint: pin {i}",
+                switch=f"-constraint_pin_{i} 'name <float>'",
+                example=[
+                    f"cli: -constraint_pin_{i} 'nreset {v[1]}'",
+                    f"api: chip.set('constraint', 'pin', 'nreset', {i}, {v[1]})"],
+                schelp=f"""
+                Pin {i} constraint. This parameter represents goal/intent, not an exact
+                specification. The layout system may adjust sizes to meet
+                competing goals such as manufacturing design rules and grid placement
+                guidelines.""")
+
+    scparam(cfg, ['constraint', 'pin', name, 'shape'],
+            sctype='enum',
+            enum=['circle', 'rectangle', 'square',
+                  'hexagon', 'octagon', 'oval', 'pill', 'polygon'],
+            pernode='optional',
+            shorthelp="Constraint: pin shape",
+            switch="-constraint_pin_shape 'name <str>'",
+            example=[
+                "cli: -constraint_pin_shape 'nreset circle'",
+                "api: chip.set('constraint', 'pin', 'nreset', 'shape', 'circle')"],
+            schelp="""
+            Pin shape constraint specified on a per pin basis. In 3D design systems,
+            the pin shape represents the cross section of the pin in the direction
+            orthogonal to the signal flow direction. The 'pill' (aka stadium) shape,
+            is rectangle with semicircles at a pair of opposite sides. The other
+            pin shapes represent common geometric shape definitions.""")
+
     scparam(cfg, ['constraint', 'pin', name, 'layer'],
             sctype='str',
             pernode='optional',
@@ -3903,8 +3961,8 @@ def schema_constraint(cfg):
                 "cli: -constraint_net_maxlength 'nreset 1000'",
                 "api: chip.set('constraint', 'net', 'nreset', 'maxlength', '1000')"],
             schelp="""
-            Maximum total length of a net, specified in microns.
-            Wildcards ('*') can be used for net names.""")
+            Maximum total length of a net. Wildcards ('*') can be used for
+            net names.""")
 
     scparam(cfg, ['constraint', 'net', name, 'maxresistance'],
             sctype='float',
@@ -3930,9 +3988,8 @@ def schema_constraint(cfg):
                 "api: chip.set('constraint', 'net', 'nreset', 'ndr', (0.4, 0.4))"],
             schelp="""
             Definitions of non-default routing rule specified on a per
-            net basis. Constraints are entered as a (width, space) tuples
-            specified in microns. Wildcards ('*') can be used
-            for net names.""")
+            net basis. Constraints are entered as a (width, space) tuples.
+            Wildcards ('*') can be used for net names.""")
 
     scparam(cfg, ['constraint', 'net', name, 'minlayer'],
             sctype='str',

siliconcompiler/tools/__init__.py

@@ -1,11 +1,12 @@
 from siliconcompiler.tools import bambu
-from siliconcompiler.tools.bluespec import bluespec
+from siliconcompiler.tools import bluespec
 from siliconcompiler.tools.builtin import builtin
 from siliconcompiler.tools.chisel import chisel
 from siliconcompiler.tools.execute import execute
 from siliconcompiler.tools.genfasm import genfasm
 from siliconcompiler.tools.ghdl import ghdl
 from siliconcompiler.tools import gtkwave
+from siliconcompiler.tools import graphviz
 from siliconcompiler.tools.icarus import icarus
 from siliconcompiler.tools.icepack import icepack
 from siliconcompiler.tools.klayout import klayout
@@ -39,6 +40,7 @@ def get_tools():
             execute,
             genfasm,
             ghdl,
+            graphviz,
             gtkwave,
             icarus,
             icepack,

siliconcompiler/tools/bluespec/__init__.py

@@ -0,0 +1,35 @@
+'''
+Bluespec is a high-level hardware description language. It has a variety of
+advanced features including a powerful type system that can prevent errors
+prior to synthesis time, and its most distinguishing feature, Guarded Atomic
+Actions, allow you to define hardware components in a modular manner based
+on their invariants, and let the compiler pick a scheduler.
+
+Documentation: https://github.com/B-Lang-org/bsc#documentation
+
+Sources: https://github.com/B-Lang-org/bsc
+
+Installation: https://github.com/B-Lang-org/bsc#download
+'''
+
+from siliconcompiler.tools.bluespec import convert
+
+
+####################################################################
+# Make Docs
+####################################################################
+def make_docs(chip):
+    convert.setup(chip)
+    return chip
+
+
+################################
+# Setup Tool (pre executable)
+################################
+def parse_version(stdout):
+    # Examples:
+    # Bluespec Compiler, version 2021.12.1-27-g9a7d5e05 (build 9a7d5e05)
+    # Bluespec Compiler, version 2021.07 (build 4cac6eba)
+
+    long_version = stdout.split()[3]
+    return long_version.split('-')[0]

siliconcompiler/tools/bluespec/convert.py

@@ -8,6 +8,7 @@ from siliconcompiler import sc_open
 
 # Directory inside step/index dir to store bsc intermediate results.
 VLOG_DIR = 'verilog'
+BSC_DIR = 'bluespec'
 
 
 def setup(chip):
@@ -39,6 +40,7 @@ def setup(chip):
 
     # Input/Output requirements
     chip.add('tool', tool, 'task', task, 'output', chip.top() + '.v', step=step, index=index)
+    chip.add('tool', tool, 'task', task, 'output', chip.top() + '.dot', step=step, index=index)
 
     # Schema requirements
     add_require_input(chip, 'input', 'hll', 'bsv')
@@ -50,9 +52,10 @@ def setup(chip):
 ################################
 def pre_process(chip):
     # bsc requires its output directory exists before being called.
-    if os.path.isdir(VLOG_DIR):
-        shutil.rmtree(VLOG_DIR)
-    os.makedirs(VLOG_DIR)
+    for path in (VLOG_DIR, BSC_DIR):
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        os.makedirs(path)
 
 
 ################################
@@ -68,7 +71,13 @@ def runtime_options(chip):
 
     cmdlist.append('-verilog')
     cmdlist.append(f'-vdir {VLOG_DIR}')
+    cmdlist.append(f'-bdir {BSC_DIR}')
+    cmdlist.append('-info-dir reports')
     cmdlist.append('-u')
+    cmdlist.append('-v')
+
+    cmdlist.append('-show-module-use')
+    cmdlist.append('-sched-dot')
 
     cmdlist.append(f'-g {chip.top(step, index)}')
 
@@ -95,10 +104,40 @@ def post_process(chip):
     ''' Tool specific function to run after step execution
     '''
 
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+
+    shutil.copyfile(f"reports/{chip.top(step, index)}_combined_full.dot",
+                    f"outputs/{chip.top()}.dot")
+
+    extra_modules = set()
+    use_file = os.path.join(VLOG_DIR, f"{chip.top(step, index)}.use")
+    if os.path.exists(use_file):
+        BSC_BASE = os.path.dirname(
+            os.path.dirname(
+                chip.get('record', 'toolpath', step=step, index=index)))
+        BSC_LIB = os.path.join(BSC_BASE, "lib", "Verilog")
+
+        with sc_open(use_file) as f:
+            for module in f:
+                module = module.strip()
+                mod_path = os.path.join(BSC_LIB, f"{module}.v")
+                if os.path.exists(mod_path):
+                    extra_modules.add(mod_path)
+                else:
+                    chip.logger.warn(f"Unable to find module {module} source files at: {BSC_LIB}")
+
     # bsc outputs each compiled module to its own Verilog file, so we
     # concatenate them all to create a pickled output we can pass along.
     design = chip.top()
     with open(os.path.join('outputs', f'{design}.v'), 'w') as pickled_vlog:
         for src in os.listdir(VLOG_DIR):
-            with sc_open(os.path.join(VLOG_DIR, src)) as vlog_mod:
-                pickled_vlog.write(vlog_mod.read())
+            if src.endswith(".v"):
+                with sc_open(os.path.join(VLOG_DIR, src)) as vlog_mod:
+                    pickled_vlog.write(vlog_mod.read())
+
+        pickled_vlog.write("\n")
+        pickled_vlog.write("// Bluespec imports\n\n")
+        for vfile in extra_modules:
+            with sc_open(os.path.join(BSC_LIB, vfile)) as vlog_mod:
+                pickled_vlog.write(vlog_mod.read() + "\n")

siliconcompiler/tools/graphviz/__init__.py

@@ -0,0 +1,12 @@
+'''
+Graphviz is open source graph visualization software.
+Graph visualization is a way of representing structural information as diagrams
+of abstract graphs and networks.
+It has important applications in networking, bioinformatics, software engineering,
+database and web design, machine learning, and in visual interfaces for other
+technical domains.
+'''
+
+
+def make_docs(chip):
+    return chip

siliconcompiler/tools/graphviz/screenshot.py

@@ -0,0 +1,48 @@
+import graphviz
+import os
+
+from siliconcompiler import sc_open
+from siliconcompiler.tools._common import get_tool_task
+
+
+def setup(chip):
+    '''
+    Generate a screenshot of a dot file
+    '''
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    chip.set('tool', tool, 'task', task, 'threads', 1, step=step, index=index)
+
+    chip.add('tool', tool, 'task', task, 'output', chip.top() + '.png', step=step, index=index)
+
+
+def run(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    if os.path.exists(f'inputs/{chip.top()}.dot'):
+        file = f'inputs/{chip.top()}.dot'
+    elif os.path.exists(f'inputs/{chip.top()}.xdot'):
+        file = f'inputs/{chip.top()}.xdot'
+    elif chip.valid('tool', tool, 'task', task, 'var', 'show_filepath') and \
+            chip.get('tool', tool, 'task', task, 'var', 'show_filepath', step=step, index=index):
+        file = chip.get('tool', tool, 'task', task, 'var', 'show_filepath',
+                        step=step, index=index)[0]
+    else:
+        file = chip.find_files('input', 'image', 'dot', step=step, index=index)[0]
+
+    with sc_open(file) as dot:
+        dot_content = dot.read()
+
+    try:
+        dot = graphviz.Source(dot_content, format="png")
+        dot.render(filename=f"outputs/{chip.top()}", cleanup=True)
+        pass
+    except graphviz.ExecutableNotFound:
+        return 1
+
+    return 0