opencos-eda 0.2.36__py3-none-any.whl → 0.2.39__py3-none-any.whl

opencos/eda_config_defaults.yml

@@ -3,6 +3,28 @@
 # python mergedeep with Strategy.TYPESAFE_REPLACE. I considered doing TYPESAFE_ADDITIVE but then
 # the user would lose full control over existing list values.
 
+DEFAULT_HANDLERS:
+  # These commands (sim, elab, etc) require a tool, but have a default handler
+  # base class:
+  sim         : opencos.commands.CommandSim
+  elab        : opencos.commands.CommandElab
+  synth       : opencos.commands.CommandSynth
+  flist       : opencos.commands.CommandFList
+  proj        : opencos.commands.CommandProj
+  build       : opencos.commands.CommandBuild
+  upload      : opencos.commands.CommandUpload
+  open        : opencos.commands.CommandOpen
+  # These commands don't necessarily require a tool
+  multi       : opencos.commands.CommandMulti
+  tools-multi : opencos.commands.CommandToolsMulti
+  sweep       : opencos.commands.CommandSweep
+  # These commands (waves, export, targets) do not require a tool, or
+  # will self determine the tool:
+  waves       : opencos.commands.CommandWaves
+  export      : opencos.commands.CommandExport
+  targets     : opencos.commands.CommandTargets
+
+
 defines: { } # Add these defines to every eda call
 
 dep_command_enables:
@@ -47,9 +69,14 @@ file_extensions:
     - .vhdl
 
 command_determines_tool:
-  # eda commands that will self-determine the tool to use.
+  # eda commands that will self-determine the tool to use
   - waves
 
+command_uses_no_tools:
+  # eda commands that do not use a tool at all, will skip auto_tools_order
+  - export
+  - targets
+
 
 tools:
 

opencos/eda_config_reduced.yml

@@ -9,7 +9,6 @@ dep_command_enables:
   var_subst_os_env: false
 
 # Values overriden to false:
-deps_legacy_supported: false
 deps_subprocess_shell: false
 
 

opencos/eda_deps_bash_completion.bash

@@ -35,7 +35,7 @@ _eda_script_completion() {
     if [ -z "${completions}" ]; then
         # If we didn't find anything in a DEPS.[yml|yaml|toml|json], then use:
         # 1. a bunch of known eda words or args.
-        eda_words="multi sim elab flist build synth waves proj waves \
+        eda_words="multi sim elab flist build synth waves proj waves targets \
                     +define+ +incdirs+ \
                     --help --quiet --verbose --debug \
                     --tool --seed --top --keep --force --fake --lint --work-dir \

opencos/eda_extract_targets.py

@@ -72,12 +72,8 @@ def print_columns_manual(data: list, num_columns: int = 4, auto_columns: bool =
         if col_index == num_columns - 1 or i == len(data) - 1:
             print() # New line at the end of a row or end of data
 
-
-def run(partial_path: str = '', base_path=str(Path('.'))) -> None:
-    '''Returns None, prints DEPS keys into pretty columns, using arg
-
-    partial_path as a string filter for target completions.
-    '''
+def get_path_and_pattern(partial_path: str = '', base_path=str(Path('.'))) -> (str, str):
+    '''Returns tuple of (partial_path, partial_target or filter)'''
     partial_target = ''
     if not partial_path or partial_path == str(Path('.')):
         partial_path = PATH_LPREFIX
@@ -86,18 +82,40 @@ def run(partial_path: str = '', base_path=str(Path('.'))) -> None:
     if not partial_path:
         partial_path = PATH_LPREFIX
 
-    try:
-        keys = get_all_targets(
-            dirs=[partial_path],
-            base_path=base_path,
-            filter_str=partial_target,
-            error_on_empty_return=False,
-            lstrip_path=True
-        )
-    except:
-        keys = []
+    return partial_path, partial_target
 
-    print_columns_manual(data=keys, num_columns=4, auto_columns=True)
+
+
+def run(partial_paths: list, base_path=str(Path('.'))) -> None:
+    '''Returns None, prints DEPS keys into pretty columns, using arg
+
+    partial_path as a string filter for target completions.
+    '''
+
+    targets_set = set()
+    if not partial_paths:
+        partial_paths = [PATH_LPREFIX] # run on current directory.
+
+    for partial_path in partial_paths:
+        partial_path, partial_target = get_path_and_pattern(
+            partial_path=partial_path, base_path=base_path
+        )
+        try:
+            keys = get_all_targets(
+                dirs=[partial_path],
+                base_path=base_path,
+                filter_str=partial_target,
+                error_on_empty_return=False,
+                lstrip_path=True
+            )
+        except:
+            keys = []
+        for key in keys:
+            targets_set.add(key)
+
+    data = list(targets_set)
+    data.sort()
+    print_columns_manual(data=data, num_columns=4, auto_columns=True)
 
 
 def main() -> None:
@@ -109,8 +127,8 @@ def main() -> None:
     if len(sys.argv) > 1:
         partial_path = sys.argv[1]
     else:
-        partial_path = PATH_LPREFIX
-    run(partial_path)
+        partial_path = ''
+    run(partial_paths=[partial_path])
 
 
 if __name__ == "__main__":

opencos/files.py

@@ -29,7 +29,7 @@ ALL_FORCED_PREFIXES = set(list(FORCE_PREFIX_DICT.keys()))
 
 def get_source_file(target:str) -> (bool, str, str):
     '''Returns tuple: bool if file exists, filepath str, and optional forced file type str'''
-    if os.path.exists(target):
+    if os.path.isfile(target):
         # target exists as a file, return True w/ original target:
         return True, target, ''
 
@@ -37,7 +37,7 @@ def get_source_file(target:str) -> (bool, str, str):
         for p in ALL_FORCED_PREFIXES:
             if p in target:
                 fpath = ''.join(target.split(p)) # essentially just removing the "sv@" or whatever it is
-                if os.path.exists(fpath):
+                if os.path.isfile(fpath):
                     return True, fpath, FORCE_PREFIX_DICT.get(p)
 
     # target or fpath didn't exist, return False with the original target:

opencos/tests/helpers.py

@@ -142,13 +142,14 @@ class Helpers:
         # TODO(drew): There are some issues with log_it redirecting stdout from vivado
         # and modelsim_ase. So this may not work for all tools, you may have to directly
         # look at eda.work/{target}.sim/sim.log or xsim.log.
+        print(f'{os.getcwd()=}')
+        print(f'{command_str=}')
         with open(logfile, 'w', encoding='utf-8') as f:
-            with redirect_stdout(f):
-                with redirect_stderr(f):
-                    if use_eda_wrap:
-                        rc = eda_wrap(*(command_str.split()))
-                    else:
-                        rc = eda.main(*(command_str.split()))
+            with redirect_stdout(f), redirect_stderr(f):
+                if use_eda_wrap:
+                    rc = eda_wrap(*(command_str.split()))
+                else:
+                    rc = eda.main(*(command_str.split()))
             print(f'Wrote: {os.path.abspath(logfile)=}')
         return rc
 

opencos/tests/test_eda.py

@@ -53,6 +53,28 @@ def test_args_sim_default_tool():
     assert rc == 0
 
 
+class TestTargets(Helpers):
+    '''Tests for: eda targets'''
+
+    DEFAULT_DIR = os.path.join(THISPATH, '..', '..', 'lib', 'tests')
+
+    def test_lib_tests__no_pattern(self):
+        '''Test that this works: eda targets'''
+        self.chdir()
+        rc = self.log_it('targets --debug', use_eda_wrap=False)
+        assert rc == 0
+        assert self.is_in_log('oclib_fifo_test')
+        assert self.is_in_log('oclib_rrarb_test')
+
+    def test_lib_tests__with_pattern(self):
+        '''Test that this works: eda targets oclib_fifo*test'''
+        self.chdir()
+        rc = self.log_it('targets oclib_fifo*test', use_eda_wrap=False)
+        assert rc == 0
+        assert self.is_in_log('oclib_fifo_test')
+        assert not self.is_in_log('oclib_rrarb_test')
+
+
 @pytest.mark.skipif(
     'verilator' not in tools_loaded, reason="requires verilator"
 )

opencos/tools/invio.py

@@ -2,7 +2,6 @@
 
 # pylint: disable=R0801 # (duplicate code in derived classes, such as if-condition return.)
 
-import shutil
 import importlib.util
 
 from opencos import util
@@ -22,11 +21,11 @@ class ToolInvio(Tool):
         if self._VERSION:
             return self._VERSION
 
-        # We also have to make sure invio-py exists, or that we can import invio within python.
-        invio_py_path = shutil.which('invio-py')
+        # We also have to make sure we can import invio within python.
         spec = importlib.util.find_spec('invio')
-        if not spec or not invio_py_path:
-            self.error('"invio-py" not in path, or invio package not in python env')
+        if not spec:
+            self.error('"invio" package not in python env')
+
 
         return super().get_versions()
 

opencos/tools/invio_yosys.py

@@ -5,7 +5,6 @@
 # pylint: disable=too-many-locals     # TODO(drew): fix this later.
 
 import os
-import shutil
 import importlib.util
 
 from opencos import util
@@ -23,11 +22,10 @@ class ToolInvioYosys(ToolYosys):
         if self._VERSION:
             return self._VERSION
 
-        # We also have to make sure invio-py exists, or that we can import invio within python.
-        invio_py_path = shutil.which('invio-py')
+        # We also have to make sure we can import invio within python.
         spec = importlib.util.find_spec('invio')
-        if not spec or not invio_py_path:
-            self.error('"invio-py" not in path, or invio package not in python env')
+        if not spec:
+            self.error('"invio" package not in python env')
 
         # run ToolYosys.get_versions() to set up self.yosys_exe, and return the version
         # str:
@@ -49,6 +47,9 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
         self.args.update({
             'invio-blackbox': [],                # list of modules that invio/verific will blackbox.
         })
+        self.args_help.update({
+            'invio-blackbox': 'List of modules that invio will blackbox prior to yosys',
+        })
 
     def write_and_run_yosys_f_files(self, **kwargs) -> None:
 
@@ -74,13 +75,13 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
             os.mkdir(fullp)
 
         # create yosys.f so we can run a few commands within yosys.
-        yosys_f_path = os.path.join(work_dir, 'yosys.f')
-        yosys_v_path = os.path.join(work_dir, 'yosys', invio_dict['v_filename'])
-
-        synth_command = self.args.get('yosys-synth', 'synth')
+        yosys_f_path = os.path.join(self.full_work_dir, 'yosys.f')
+        self.yosys_v_path = os.path.join(self.yosys_out_dir, invio_dict['v_filename'])
 
         with open(yosys_f_path, 'w', encoding='utf-8') as f:
             lines = []
+            if self.args['liberty-file']:
+                lines.append('read_liberty -lib ' + self.args['liberty-file'])
             for path in invio_dict.get('blackbox_files_list', []):
                 # We have to read the verilog files from the invio blackbox_files_list:
                 lines.append(f'read_verilog {path}')
@@ -88,12 +89,9 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
                 # But we may blackbox different cells for yosys synthesis.
                 lines.append(f'blackbox {module}')
 
+
             lines.append(f'read_verilog {invio_dict["full_v_filename"]}')
-            lines += self.args.get('yosys-pre-synth', [])
-            lines += [
-                synth_command,
-                f'write_verilog {yosys_v_path}'
-            ]
+            lines += self.get_synth_command_lines()
             f.write('\n'.join(lines))
 
         synth_command_list = util.ShellCommandList(
@@ -105,6 +103,9 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
             ['python3', invio_dict['full_py_filename']], tee_fpath=invio_dict['full_py_filename']
         )
 
+        # Optinally create and run a sta.f:
+        sta_command_list = self.create_sta_f() # [] or util.ShellCommandList
+
         # We create a run_yosys.sh wrapping these scripts, but we do not run this one.
         util.write_shell_command_file(
             dirpath=self.args['work-dir'],
@@ -121,18 +122,25 @@ class CommandSynthInvioYosys(CommonSynthYosys, ToolInvioYosys):
                 # Gives us bash commands with tee and pipstatus:
                 invio_command_list,
                 synth_command_list,
+                sta_command_list,
             ],
         )
 
         # Do not run this if args['stop-before-compile'] is True
         if self.args.get('stop-before-compile', False) or \
            self.args.get('stop-after-compile', False):
-            pass # skip it.
-        else:
-            self.exec( work_dir=work_dir, command_list=synth_command_list,
-                       tee_fpath=synth_command_list.tee_fpath )
-            util.info(f'yosys: wrote verilog to {yosys_v_path}')
-        return self.status
+            return
+
+        # Run the synth commands standalone:
+        self.exec( work_dir=work_dir, command_list=synth_command_list,
+                   tee_fpath=synth_command_list.tee_fpath )
+
+        if self.args['sta']:
+            self.exec(work_dir=self.full_work_dir, command_list=sta_command_list,
+                      tee_fpath=sta_command_list.tee_fpath)
+
+        if self.status == 0:
+            util.info(f'yosys: wrote verilog to {self.yosys_v_path}')
 
 
 class CommandElabInvioYosys(CommandSynthInvioYosys):

opencos/tools/iverilog.py

@@ -156,8 +156,10 @@ class CommandSimIverilog(CommandSim, ToolIverilog):
                 # +define+{k}={v}, but also for SystemVerilog plusargs
                 command_list += [ '-D', f'{k}={sanitize_defines_for_sh(v)}' ]
 
-        assert len(self.files_sv) + len(self.files_v) > 0, \
-            f'{self.target=} {self.files_sv=} and {self.files_v=} are empty, cannot call iverilog'
+        if not self.files_sv and not self.files_v:
+            if not self.args['stop-before-compile']:
+                self.error(f'{self.target=} {self.files_sv=} and {self.files_v=} are empty,',
+                           'cannot call iverilog')
 
         command_list += list(self.files_sv) + list(self.files_v)
 

opencos/tools/modelsim_ase.py

@@ -178,9 +178,10 @@ class CommandSimModelsimAse(CommandSim, ToolModelsimAse):
             '-source',
             ] + list(self.files_sv) + list(self.files_v)
 
-        if len(self.files_sv) + len(self.files_v) == 0:
-            self.error(f'{self.target=} {self.files_sv=} and {self.files_v=} are empty,',
-                       'cannot create a valid vlog.f')
+        if not self.files_sv and not self.files_v:
+            if not self.args['stop-before-compile']:
+                self.error(f'{self.target=} {self.files_sv=} and {self.files_v=} are empty,',
+                           'cannot create a valid vlog.f')
 
         with open(vlog_dot_f_fpath, 'w', encoding='utf-8') as f:
             f.writelines(line + "\n" for line in vlog_dot_f_lines)

opencos/tools/slang_yosys.py

@@ -8,8 +8,7 @@ Contains classes for ToolSlangYosys, CommandSynthSlangYosys
 import os
 
 from opencos import util
-from opencos.commands import CommandSynth
-from opencos.tools.yosys import ToolYosys
+from opencos.tools.yosys import ToolYosys, CommonSynthYosys
 
 class ToolSlangYosys(ToolYosys):
     '''Uses slang.so in yosys plugins directory, called via yosys > plugin -i slang'''
@@ -28,49 +27,17 @@ class ToolSlangYosys(ToolYosys):
         })
 
 
-class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
+class CommandSynthSlangYosys(CommonSynthYosys, ToolSlangYosys):
     '''CommandSynthSlangYosys is a command handler for: eda synth --tool=slang_yosys'''
 
     def __init__(self, config: dict):
-        CommandSynth.__init__(self, config)
+        CommonSynthYosys.__init__(self, config)
         ToolSlangYosys.__init__(self, config=self.config)
-        self.args.update({
-            'sta': False,
-            'liberty-file': '',
-            'sdc-file': '',
-            'yosys-synth': 'synth',       # synth_xilinx, synth_altera, etc (see: yosys help)
-            'yosys-pre-synth': ['prep', 'proc'], # command run in yosys prior to yosys-synth.
-            'yosys-blackbox': [],                # list of modules that yosys will blackbox.
-        })
-        self.args_help.update({
-            'sta': 'After running Yosys, run "sta" with --liberty-file.' \
-            + ' sta can be installed via: https://github.com/The-OpenROAD-Project/OpenSTA',
-            'sdc-file': '.sdc file to use with --sta, if not present will use auto constraints',
-            'liberty-file': 'Single liberty file for synthesis and sta,' \
-            + ' for example: github/OpenSTA/examples/nangate45_slow.lib.gz',
-            'yosys-synth': 'The synth command provided to Yosys, see: yosys help.',
-            'yosys-pre-synth': 'Yosys commands performed prior to running "synth"' \
-            + ' (or eda arg value for --yosys-synth)',
-            'yosys-blackbox': 'List of modules that yosys will blackbox, likely will need these' \
-            + ' in Verilog-2001 for yosys to read outside of slang and synth',
-        })
 
         self.slang_out_dir = ''
-        self.yosys_out_dir = ''
         self.slang_v_path = ''
-        self.yosys_v_path = ''
-        self.full_work_dir = ''
-        self.blackbox_list = []
 
-    def do_it(self) -> None:
-        CommandSynth.do_it(self)
-
-        if self.is_export_enabled():
-            return
-
-        self._write_and_run_yosys_f_files()
-
-    def _write_and_run_yosys_f_files(self):
+    def write_and_run_yosys_f_files(self, **kwargs) -> None:
         '''
         1. Creates and runs: yosys.slang.f
            -- should create post_slang_ls.txt
@@ -88,28 +55,20 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
         util.debug(f'slang_yosys: {self.blackbox_list=}')
 
         # create {work_dir} / yosys
-        self.full_work_dir = self.args.get('work-dir', '')
-        if not self.full_work_dir:
-            self.error(f'work_dir={self.full_work_dir} is not set')
-        self.full_work_dir = os.path.abspath(self.full_work_dir)
         self.slang_out_dir = os.path.join(self.full_work_dir, 'slang')
-        self.yosys_out_dir = os.path.join(self.full_work_dir, 'yosys')
-        for p in [self.slang_out_dir, self.yosys_out_dir]:
-            util.safe_mkdir(p)
+        util.safe_mkdir(self.slang_out_dir)
 
         self.slang_v_path = os.path.join(self.slang_out_dir, f'{self.args["top"]}.v')
-        self.yosys_v_path = os.path.join(self.yosys_out_dir, f'{self.args["top"]}.v')
-
 
         # Run our created yosys.slang.f script
         # Note - this will always run, even if --stop-before-compile is set.
         slang_command_list = self._create_yosys_slang_f() # util.ShellCommandList
 
         # Create and run yosys.synth.f
-        synth_command_list = self._create_yosys_synth_f() # util.ShellCommandList
+        synth_command_list = self.create_yosys_synth_f() # util.ShellCommandList
 
         # Optinally create and run a sta.f:
-        sta_command_list = self._create_sta_f() # [] or util.ShellCommandList
+        sta_command_list = self.create_sta_f() # [] or util.ShellCommandList
 
         # We create a run_yosys.sh wrapping these scripts, but we do not run this one.
         util.write_shell_command_file(
@@ -246,7 +205,7 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
                             yosys_blackbox_list.append(line)
         return yosys_blackbox_list
 
-    def _create_yosys_synth_f(self) -> util.ShellCommandList:
+    def create_yosys_synth_f(self) -> util.ShellCommandList:
         # Create yosys.synth.f
         yosys_synth_f_path = os.path.join(self.full_work_dir, 'yosys.synth.f')
 
@@ -254,10 +213,6 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
         # yosys.synth.f script.
         yosys_blackbox_list = self._get_yosys_blackbox_list()
 
-        synth_command = self.args.get('yosys-synth', 'synth')
-        if self.args['flatten-all']:
-            synth_command += ' -flatten'
-
         if self.args['liberty-file'] and not os.path.exists(self.args['liberty-file']):
             self.error(f'--liberty-file={self.args["liberty-file"]} file does not exist')
 
@@ -273,20 +228,7 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
             for inst in yosys_blackbox_list:
                 lines.append('blackbox ' + inst)
 
-            lines += self.args.get('yosys-pre-synth', [])
-            lines.append(synth_command)
-
-            # TODO(drew): I need a blackbox flow here? Or a memory_libmap?
-            #   --> https://yosyshq.readthedocs.io/projects/yosys/en/latest/cmd/memory_libmap.html
-            # TODO(drew): can I run multiple liberty files?
-            if self.args['liberty-file']:
-                lines += [
-                    'dfflibmap -liberty ' + self.args['liberty-file'],
-                    #'memory_libmap -lib ' + self.args['liberty-file'], # Has to be unzipped?
-                    'abc -liberty  ' + self.args['liberty-file'],
-                ]
-
-            lines.append(f'write_verilog {self.yosys_v_path}')
+            lines += self.get_synth_command_lines()
             f.write('\n'.join(lines))
 
         synth_command_list = util.ShellCommandList(
@@ -296,74 +238,7 @@ class CommandSynthSlangYosys(CommandSynth, ToolSlangYosys):
         return synth_command_list
 
 
-    def _create_sta_f(self) -> list:
-
-        if not self.args['sta']:
-            return []
-
-        if not self.args['liberty-file']:
-            self.error('--sta is set, but need to also set --liberty-file=<file>')
-
-        if self.args['sdc-file']:
-            if not os.path.exists(self.args['sdc-file']):
-                self.error(f'--sdc-file={self.args["sdc-file"]} file does not exist')
-
-        if not self.sta_exe:
-            self.error(f'--sta is set, but "sta" was not found in PATH, see: {self._URL}')
-
-        sta_command_list = util.ShellCommandList(
-            [ self.sta_exe, '-no_init', '-exit', 'sta.f' ],
-            tee_fpath = 'sta.log'
-        )
-
-        # Need to create sta.f:
-        if self.args['sdc-file']:
-            sdc_path = self.args['sdc-file']
-        else:
-            # Need to create sdc.f:
-            sdc_path = 'sdc.f'
-            self._create_sdc_f()
-
-        with open(os.path.join(self.args['work-dir'], 'sta.f'), 'w',
-                  encoding='utf-8') as f:
-            lines = [
-                'read_liberty ' + self.args['liberty-file'],
-                'read_verilog ' + self.yosys_v_path,
-                'link_design ' + self.args['top'],
-                'read_sdc ' + sdc_path,
-                'report_checks',
-            ]
-            f.write('\n'.join(lines))
-
-        return util.ShellCommandList(
-            sta_command_list,
-            tee_fpath = 'sta.log'
-        )
-
-
-    def _create_sdc_f(self) -> None:
-        if self.args['sdc-file']:
-            # already exists from args, return b/c nothing to create.
-            return
-
-        with open(os.path.join(self.args['work-dir'], 'sdc.f'), 'w',
-                  encoding='utf-8') as f:
-            clock_name = self.args['clock-name']
-            period = self.args['clock-ns']
-            name_not_equal_clocks_str = f'NAME !~ "{clock_name}"'
-            lines = [
-                f'create_clock -add -name {clock_name} -period {period} [get_ports ' \
-                + '{' + clock_name + '}];',
-                f'set_input_delay -max {self.args["idelay-ns"]} -clock {clock_name}' \
-                + ' [get_ports * -filter {DIRECTION == IN && ' \
-                + name_not_equal_clocks_str + '}];',
-                f'set_output_delay -max {self.args["odelay-ns"]} -clock {clock_name}' \
-                + ' [get_ports * -filter {DIRECTION == OUT}];',
-            ]
-            f.write('\n'.join(lines))
-
-
-class CommandElabSlangYosys(CommandSynthSlangYosys):
+class CommandElabSlangYosys(CommandSynthSlangYosys): # pylint: disable=too-many-ancestors
     '''CommandSynthSlangYosys is a command handler for: eda synth --tool=slang_yosys
 
     Runs slang-yosys as elab only (does not run the synthesis portion), but is

opencos/tools/verilator.py

@@ -82,11 +82,12 @@ class VerilatorSim(CommandSim, ToolVerilator):
         })
 
         self.args_help.update({
-            'waves':    'Include waveforms, if possible for Verilator by applying' \
-            + ' simulation runtime arg +trace. User will need SV code to interpret the plusarg' \
-            + ' and apply $dumpfile("dump.fst").',
-            'dump-vcd': 'If using --waves, apply simulation runtime arg +trace=vcd. User' \
-            + ' will need SV code to interpret the plusarg and apply $dumpfile("dump.vcd").',
+            'waves':    ('Include waveforms, if possible for Verilator by applying'
+                         ' simulation runtime arg +trace. User will need SV code to interpret the'
+                         'plusarg and apply $dumpfile("dump.fst").'),
+            'dump-vcd': ('If using --waves, apply simulation runtime arg +trace=vcd. User'
+                         ' will need SV code to interpret the plusarg and apply'
+                         ' $dumpfile("dump.vcd").'),
             'lint-only': 'Run verilator with --lint-only, instead of --binary',
             'gui':       'Not supported for Verilator',
             'cc-mode':   'Run verilator with --cc, requires a sim_main.cpp or similar sources',
@@ -227,9 +228,10 @@ class VerilatorSim(CommandSim, ToolVerilator):
                 # +define+{k}={v}, but also for SystemVerilog plusargs
                 verilate_command_list += [ f'+define+{k}={sanitize_defines_for_sh(v)}' ]
 
-        if (len(self.files_sv) + len(self.files_v)) == 0:
-            self.error(f'{self.target=} {self.files_sv=} and {self.files_v=} are empty,',
-                       'cannot call verilator')
+        if not self.files_sv and not self.files_v:
+            if not self.args['stop-before-compile']:
+                self.error(f'{self.target=} {self.files_sv=} and {self.files_v=} are empty,',
+                           'cannot call verilator')
 
         verilate_command_list += list(self.files_sv) + list(self.files_v)
 

opencos/tools/vivado.py

@@ -720,7 +720,6 @@ class CommandUploadVivado(CommandUpload, ToolVivado):
             'host': "localhost",
             'port': 3121,
             'tcl-file': "upload.tcl",
-            'test-mode': False,
         })
         # TODO(drew): Add self.args_help.update({...})