opencos-eda 0.3.3__tar.gz → 0.3.5__tar.gz

{opencos_eda-0.3.3/opencos_eda.egg-info → opencos_eda-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencos-eda
-Version: 0.3.3
+Version: 0.3.5
 Summary: A simple Python package for wrapping RTL simuliatons and synthesis
 Author-email: Simon Sabato <simon@cognichip.ai>, Drew Ranck <drew@cognichip.ai>
 Project-URL: Homepage, https://github.com/cognichip/opencos
@@ -9,8 +9,8 @@ License-File: LICENSE
 License-File: LICENSE.spdx
 Requires-Dist: mergedeep>=1.3.4
 Requires-Dist: peakrdl>=1.1.0
+Requires-Dist: psutil>=7.0.0
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: pytest>=8.3.5
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: schema>=0.7.7
 Requires-Dist: toml>=0.10.2
@@ -18,4 +18,12 @@ Requires-Dist: yamllint>=1.35.1
 Requires-Dist: PySerial>=3.5
 Requires-Dist: cocotb>=2.0
 Requires-Dist: supports_color>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pylint>=3.0.0; extra == "dev"
+Requires-Dist: pytest>=8.3.5; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocs-wavedrom-plugin; extra == "docs"
+Requires-Dist: mkdocs-plantuml; extra == "docs"
 Dynamic: license-file

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/deps/defaults.py

@@ -33,6 +33,7 @@ SUPPORTED_TARGET_TABLE_KEYS = set([
     'defines',
     'parameters',
     'incdirs',
+    'plusargs',
     'top',
     'deps',
     'reqs',

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/deps/deps_processor.py

@@ -77,7 +77,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         ).get('command_handler', {}).keys()
 
 
-    def apply_defines(self, defines_dict: dict):
+    def apply_defines(self, defines_dict: dict) -> None:
         '''Given defines_dict, applies them to our self.command_design_ref obj'''
         if not isinstance(defines_dict, dict):
             self.error(f"{defines_dict=} is not type dict, can't apply defines,",
@@ -95,7 +95,19 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 self.command_design_ref.process_plusarg(f'+define+{k}={v}')
 
 
-    def apply_parameters(self, parameters_dict: dict):
+    def apply_plusargs(self, plusargs_dict: dict) -> None:
+        '''Given plusarsg_dict, applies them to our self.command_design_ref obj'''
+        if not isinstance(plusargs_dict, dict):
+            self.error(f"{plusargs_dict=} is not type dict, can't apply plusargs,",
+                       f"in {self.caller_info}")
+        for k,v in plusargs_dict.items():
+            if v is None or v == '':
+                self.command_design_ref.process_plusarg(f'+{k}')
+            else:
+                self.command_design_ref.process_plusarg(f'+{k}={v}')
+
+
+    def apply_parameters(self, parameters_dict: dict) -> None:
         '''Given parameters_dict, applies them to our self.command_design_ref obj'''
         if not isinstance(parameters_dict, dict):
             self.error(f"{parameters_dict=} is not type dict, can't apply defines,",
@@ -110,7 +122,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 )
 
 
-    def apply_incdirs(self, incdirs_list:list):
+    def apply_incdirs(self, incdirs_list:list) -> None:
         '''Given incdirs_list, applies them to our self.command_design_ref obj'''
         if not isinstance(incdirs_list, (str, list)):
             self.error(f"{incdirs_list=} is not type str/list, can't apply incdirs",
@@ -290,7 +302,9 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 caller_info=self.caller_info
             )
 
-    def process_deps_entry(self):
+    def process_deps_entry( # pylint: disable=too-many-branches
+            self
+    ) -> list:
         '''Main entry point (after creating DepsProcessor obj) to resolve a deps target
 
         Example usage:
@@ -303,22 +317,6 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         This method will apply all target features to the CommandDesign ref object as
         we traverse.
 
-        Supported target keys:
-         -- tags (or equivalent, to support multiple define/incdir/deps for a target)
-            -- supports tag-name, with-tools, with-args, args, defines, incdirs, deps
-                 ** to be applied if a tool matches.
-            -- TODO(drew): other features in docs/DEPS.md not yet implemented.
-         -- multi: ignore-this-target: - commands (handled in eda.py CommandMulti.resolve_target)
-         -- Named eda commands
-            -- (partially done) sim or other eda commands (eda.py command specific things)
-                basically, check the command, and apply/merge values to 'entry'?
-         -- args
-         -- defines
-         -- incdirs
-         -- top.
-         -- commands (not in deps)
-         -- deps
-
         TODO(drew): This does not yet support conditional inclusions based on defines,
          like the old DEPS files did with pattern:
             SOME_DEFINE ?  dep_if_define_present : dep_if_define_not_present
@@ -344,6 +342,8 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                 remaining_deps_list += self.process_tags()
             elif key == 'defines':
                 self.process_defines()
+            elif key == 'plusargs':
+                self.process_plusargs()
             elif key == 'parameters':
                 self.process_parameters()
             elif key == 'incdirs':
@@ -520,6 +520,10 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
                         # apply defines:
                         self.apply_defines(value.get('defines', {}))
 
+                    if key == 'plusargs':
+                        # apply plusargs:
+                        self.apply_plusargs(value.get('plusargs', {}))
+
                     elif key == 'parameters':
                         self.apply_parameters(value.get('parameters', {}))
 
@@ -598,7 +602,7 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
         return ret_deps_added_from_tags
 
 
-    def process_defines(self):
+    def process_defines(self) -> None:
         '''Returns None, applies defines (dict, if any) from self.deps_entry to
         self.command_design_ref.'''
 
@@ -614,7 +618,28 @@ class DepsProcessor: # pylint: disable=too-many-instance-attributes
 
         self.apply_defines(entry_defines)
 
-    def process_parameters(self):
+
+    def process_plusargs(self) -> None:
+        '''Returns None, applies plusargs (dict, if any) from self.deps_entry to
+        self.command_design_ref.
+
+        These work w/ the same rules as defines (no value, or value int/str)
+        '''
+
+        # Plusargs:
+        # apply command specific plusargs, with higher priority than the a
+        # deps_entry['sim']['plusargs'] entry,
+        # do this with dict1.update(dict2):
+        entry_plusargs = {}
+        entry_plusargs.update(self.deps_entry.get('plusargs', {}))
+        entry_plusargs.update(self.entry_eda_command.get('plusargs', {}))
+        assert isinstance(entry_plusargs, dict), \
+            f'{entry_plusargs=} for in {self.caller_info} must be a dict'
+
+        self.apply_plusargs(entry_plusargs)
+
+
+    def process_parameters(self) -> None:
         '''Returns None, applies parameters (dict, if any) from self.deps_entry to
         self.command_design_ref.'''
 

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/deps_schema.py

@@ -17,6 +17,9 @@ my_target_name:
   incdirs:                           <---- incdirs, optional array (or string)
     - ./
 
+  plusargs:                          <---- plusargs, optional table
+    some_plusarg: 32
+
   top: tb                            <---- top, optional string
 
   deps:
@@ -63,6 +66,7 @@ my_target_name:
   defines:                           <---- defines, optional table
   parameters:                        <---- parameters, optional table
   incdirs:                           <---- incdirs, optional array (or string)
+  plusargs:                          <---- plusargs, optional table
   top: tb                            <---- top, optional string
   deps:                              <---- TARGET_DEPS_CONTENTS schema
     - some_file.sv                   <---- string file name
@@ -216,6 +220,9 @@ TARGET_EDA_COMMAND_ENTRY_TABLE = {
     Optional('defines'): {
         Optional(str): Or(str, int, type(None)),
     },
+    Optional('plusargs'): {
+        Optional(str): Or(str, int, type(None)),
+    },
     Optional('parameters'): {
         Optional(str): Or(str, int),
     },
@@ -241,6 +248,9 @@ TARGET_TAGS_TABLE = {
         Optional('defines'): {
             Optional(str): Or(str, int, type(None)),
         },
+        Optional('plusargs'): {
+            Optional(str): Or(str, int, type(None)),
+        },
         Optional('parameters'): {
             Optional(str): Or(str, int),
         },
@@ -262,6 +272,10 @@ TARGET_CONTENTS = Or(
         Optional('defines'): {
             Optional(str): Or(str, int, type(None)),
         },
+        # plusargs: table of key-value; value null or string
+        Optional('plusargs'): {
+            Optional(str): Or(str, int, type(None)),
+        },
         # parameters: table of key-value
         Optional('parameters'): {
             Optional(str): Or(str, int),
@@ -324,6 +338,9 @@ FILE_SIMPLIFIED = Schema(
                     Optional('defines'): {
                         Optional(str): Or(type(None), str),
                     },
+                    Optional('plusargs'): {
+                        Optional(str): Or(type(None), str),
+                    },
                     Optional('parameters'): {
                         Optional(str): str,
                     },

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/eda.py

@@ -23,7 +23,7 @@ from opencos import util, eda_config, eda_base
 from opencos.eda_base import Tool, which_tool, get_eda_exec
 from opencos.utils import vsim_helper, vscode_helper
 from opencos.utils.subprocess_helpers import subprocess_run_background
-from opencos.utils import status_constants, str_helpers
+from opencos.utils import status_constants, str_helpers, subprocess_helpers
 
 # Configure util:
 util.progname = "EDA"
@@ -50,7 +50,7 @@ def init_config(
     # For key DEFAULT_HANDLERS, we'll update config['command_handler'] with
     # the actual class using importlib (via opencos.util)
 
-    eda_config.tool_try_add_to_path(tool)
+    eda_config.update_config_auto_tool_order_for_tool(tool=tool, config=config)
 
     config['command_handler'] = {}
     for _cmd, str_class in config['DEFAULT_HANDLERS'].items():
@@ -163,10 +163,7 @@ def auto_tool_setup( # pylint: disable=too-many-locals,too-many-branches,too-man
       If so, updates config['auto_tools_order'][tool]['exe']
     '''
 
-
-    tool = eda_config.update_config_auto_tool_order_for_tool(
-        tool=tool, config=config
-    )
+    tool = eda_config.tool_arg_remove_path_information(tool)
 
     assert 'auto_tools_order' in config
     assert isinstance(config['auto_tools_order'], list)
@@ -275,9 +272,7 @@ def tool_setup(tool: str, config: dict, quiet: bool = False, auto_setup: bool =
 
     '''
 
-    tool = eda_config.update_config_auto_tool_order_for_tool(
-        tool=tool, config=config
-    )
+    tool = eda_config.tool_arg_remove_path_information(tool)
 
     if not quiet and not auto_setup:
         util.info(f"Setup for tool: '{tool}'")
@@ -389,6 +384,8 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
     if not is_interactive:
         # Run init_config() now, we deferred it in main(), but only run it
         # for this tool (or tool=None to figure it out)
+        # This will handle any --tool=<name>=/path/to/bin also, so don't have to
+        # run tool_setup(..) on its own.
         config = init_config(
             config, tool=parsed.tool,
             run_auto_tool_setup=run_auto_tool_setup
@@ -406,13 +403,8 @@ def process_tokens( # pylint: disable=too-many-branches,too-many-statements,too-
             for arg in unparsed:
                 if not arg.startswith('-'):
                     command = arg
-        if parsed.tool:
-            tool_setup(parsed.tool, config=config)
         return usage(tokens=unparsed, config=config, command=command, tool=parsed.tool)
 
-    if parsed.tool:
-        tool_setup(parsed.tool, config=config)
-
     deferred_tokens = unparsed
     if not command:
         util.error("Didn't get a command!")
@@ -504,6 +496,7 @@ def signal_handler(sig, frame) -> None: # pylint: disable=unused-argument
     '''Handles Ctrl-C, called by main_cli() if running from command line'''
     util.fancy_stop()
     util.info('Received Ctrl+C...', start='\nINFO: [EDA] ')
+    subprocess_helpers.cleanup_all()
     util.exit(-1)
 
 # **************************************************************

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/eda_base.py

@@ -594,6 +594,7 @@ class Command: # pylint: disable=too-many-public-methods
                 help_kwargs = {'help': f'default={value}'}
             else:
                 help_kwargs = {'help': f'{type(value).__name__} default={value}'}
+            help_kwargs['help'] = help_kwargs['help'].replace('%', '%%')
 
 
             # It's important to set the default=None on these, except for list types where default

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/eda_config.py

@@ -18,7 +18,10 @@ from opencos import util
 from opencos.utils.markup_helpers import yaml_safe_load, yaml_safe_writer
 
 class Defaults:
-    '''Defaults is a global placeholder for constants and supported features.'''
+    '''Defaults is a global namespace for constants and supported features.
+
+    Defaults.config_yml is set depending on search order for default eda_config[_defaults].yml
+    '''
 
     environ_override_config_yml = os.environ.get('EDA_CONFIG_YML', '')
     home_override_config_yml = os.path.join(
@@ -63,14 +66,15 @@ class Defaults:
         'simulate-args',
         'simulate-waves-args',
         'simulate-waivers',
+        'simulate-coverage-tcl',
         'coverage-args',
     ])
 
 EDA_OUTPUT_CONFIG_FNAME = 'eda_output_config.yml'
 
-if os.path.exists(Defaults.environ_override_config_yml):
+if os.path.isfile(Defaults.environ_override_config_yml):
     Defaults.config_yml = Defaults.environ_override_config_yml
-elif os.path.exists(Defaults.home_override_config_yml):
+elif os.path.isfile(Defaults.home_override_config_yml):
     Defaults.config_yml = Defaults.home_override_config_yml
 else:
     Defaults.config_yml = Defaults.opencos_config_yml
@@ -149,29 +153,9 @@ def update_config_auto_tool_order_for_tool(tool: str, config: dict) -> str:
     Input arg tool can be in the form (for example):
       tool='verlator', tool='verilator=/path/to/verilator.exe'
 
-    Performs no update if tool has no = in it. Returns tool (str) w/out = in it
+    Performs no update if tool has no = or : in it. Returns tool (str) w/out = in it
     '''
-    if not tool or '=' not in tool:
-        return tool
-
-    tool, user_exe = tool.split('=')[0:2]
-
-    user_exe = shutil.which(user_exe)
-
-    # try adding to $PATH if in form --tool=/path/to/exe
-    tool_try_add_to_path(tool)
-
-    if tool not in config['auto_tools_order'][0]:
-        return tool
-    if not user_exe:
-        return tool
-
-    old_exe = config['auto_tools_order'][0][tool].get('exe', str())
-    if isinstance(old_exe, list):
-        config['auto_tools_order'][0][tool]['exe'][0] = user_exe
-    else:
-        config['auto_tools_order'][0][tool]['exe'] = user_exe
-    return tool
+    return tool_try_add_to_path(tool=tool, config=config, update_config=True)
 
 
 def update_config_auto_tool_order_for_tools(tools: list, config: dict) -> list:
@@ -327,32 +311,92 @@ def write_eda_config_and_args(
     yaml_safe_writer(data=data, filepath=fullpath)
 
 
-def tool_try_add_to_path(tool: str) -> None:
-    '''Since we support --tool=<name>=/path/to/bin/exe, attempt to prepend $PATH
+def tool_arg_get_parts(tool: str) -> list:
+    '''Given a tool (str or None) that may be in form <name>=/path/to/something
+
+    Return the parts [<name>, <path>, ..]
+    '''
+    if not tool or ('=' not in tool and ':' not in tool):
+        return [tool]
+
+    if '=' in tool:
+        parts = tool.split('=')
+    else:
+        parts = tool.split(':')
+
+    return parts
+
+def tool_arg_remove_path_information(tool: str) -> str:
+    '''Given a tool (str or None) that may be in form <name>=/path/to/something
+
+    Return the <name> only
+    '''
+    if not tool:
+        return tool
+    return tool_arg_get_parts(tool)[0]
+
+
+def tool_try_add_to_path( # pylint: disable=too-many-branches
+        tool: str, config: dict, update_config: bool
+) -> str:
+    '''Since we support --tool=<name>=/path/to/bin[/exe], attempt to prepend $PATH
+
+    (also works for --tool=<name>:/path/to/bin[/exe] )
 
     with this information for this tool (which will nicely affect all subprocesses,
     but not wreck our original shell).'''
 
-    if not tool or '=' not in tool:
-        return
+    name_path_parts = tool_arg_get_parts(tool)
+    if len(name_path_parts) == 1:
+        return name_path_parts[0]
+
+    name, path_arg = name_path_parts[0:2]
+
+    if name not in config['auto_tools_order'][0]:
+        return name
+
+    config_exe = config['auto_tools_order'][0][name].get('exe', str())
+    if isinstance(config_exe, list):
+        orig_exe = config_exe[0]
+    else:
+        orig_exe = config_exe
 
-    name, exe = tool.split('=')
-    if os.path.isdir(name):
+    if path_arg and os.path.isfile(path_arg):
+        # Someone passes us --tool=<name>=/path/to/bin/exe, remove the exe from path:
+        path, exe = os.path.split(path_arg)
+    elif path_arg and os.path.isdir(path_arg):
         # Someone passes us --tool=<name>=/path/to/bin/ (did not have exe)
-        path = name
+        path, exe = path_arg, orig_exe
     else:
-        # Someone passes us --tool=<name>=/path/to/bin/exe, remove the exe.
-        path, _ = os.path.split(exe)
-    if not path:
-        return
+        path, exe = '', ''
+
+    if not path or not exe:
+        util.error(f'Can not find path or exe for --tool={tool}: {name=} path={path_arg}')
+        return name
 
     path = os.path.abspath(path)
     if os.path.isdir(path):
-        paths = os.environ['PATH'].split(':')
+        paths = os.environ.get('PATH', '').split(':')
         if path not in paths:
-            os.environ['PATH'] = path + ':' + os.environ['PATH']
             util.info(f'--tool={tool} has path information, prepending PATH with: {path}')
+            os.environ['PATH'] = path + ':' + os.environ.get('PATH', '')
         else:
             util.info(f'--tool={tool} has path information, but {path} already in $PATH')
-    if exe and os.path.isfile(exe):
-        util.info(f'--tool={tool} has path information, using exe {shutil.which(exe)}')
+
+    user_exe = os.path.join(path, exe)
+    if not os.access(user_exe, os.X_OK):
+        util.error(f'--tool setting for {tool}: {user_exe} is not an executable')
+        return name
+
+    user_exe = shutil.which(exe)
+
+    if update_config:
+        if isinstance(config_exe, list):
+            config['auto_tools_order'][0][name]['exe'][0] = user_exe
+        else:
+            config['auto_tools_order'][0][name]['exe'] = user_exe
+        util.debug(f'For {tool=}, auto_tools_order config updated')
+
+    util.debug(f'For {tool=}, final {user_exe=}')
+
+    return name

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/eda_config_defaults.yml

@@ -247,6 +247,9 @@ tools:
       +accb +accr +access +r+w
     coverage-args: |
       -acdb -acdb_cov sbfectapm
+    simulate-coverage-tcl:
+      - acdb save
+      - acdb report -db work.acdb -txt -o cov.txt
 
 
   modelsim_ase:

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/eda_tool_helper.py

@@ -68,3 +68,22 @@ def get_all_handler_commands(config=None, tools_loaded=None) -> dict:
                 all_handler_commands[command].append(tool)
 
     return all_handler_commands
+
+
+def get_handler_tool_version(tool: str, eda_command: str, config: dict) -> str:
+    '''Attempts to get a Command Handler's version given tool + eda_command'''
+
+    entry = config['auto_tools_order'][0].get(tool, {})
+    if not entry:
+        return ''
+
+    handler_name = entry.get('handlers', {}).get(eda_command, '')
+    if not handler_name:
+        return ''
+
+    module = util.import_class_from_string(handler_name)
+    obj = module(config=config)
+    if not getattr(obj, 'get_versions', None):
+        return ''
+
+    return obj.get_versions()

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/tests/helpers.py

@@ -16,6 +16,7 @@ from opencos.utils.subprocess_helpers import subprocess_run_background
 
 # Figure out what tools the system has available, without calling eda.main(..)
 config, tools_loaded = eda_tool_helper.get_config_and_tools_loaded()
+known_tool_versions = {}
 
 
 def eda_wrap_is_sim_fail(rc: int, quiet: bool = False) -> bool:
@@ -32,6 +33,16 @@ def eda_wrap_is_sim_fail(rc: int, quiet: bool = False) -> bool:
         status_constants.EDA_DEFAULT_ERROR
     )
 
+def handle_tool_version(tool: str, eda_command: str, cfg: dict = config) -> None:
+    '''Attempts to use a command handler for tool + eda_command and we'll
+    track the version globally'''
+
+    if not known_tool_versions.get(tool, ''):
+        handler_version = eda_tool_helper.get_handler_tool_version(
+            tool=tool, eda_command=eda_command, config=cfg
+        )
+        known_tool_versions[tool] = handler_version
+
 def can_run_eda_command(*commands, cfg: dict = config) -> bool:
     '''Returns True if we have any installed tool that can run: eda <command>'''
     runnable = []
@@ -50,10 +61,36 @@ def can_run_eda_command(*commands, cfg: dict = config) -> bool:
             if entry and entry.get('disable-auto', False):
                 # This tool cannot automatically run our command.
                 return False
+            # While we're here, set known tool versions.
+            handle_tool_version(tool=tool, eda_command=command, cfg=cfg)
 
         runnable.append(True)
     return runnable and all(runnable)
 
+def can_uvm(tool: str) -> bool:
+    '''Returns True if we can run UVM, per tool'''
+
+    if tool not in tools_loaded:
+        return False
+
+    if tool == 'verilator':
+        # requires UVM_HOME to be set with uvm_pkg.sv existing.
+        uvm_home = os.environ.get('UVM_HOME', '')
+        uvm_pkg = os.path.join(uvm_home, 'uvm_pkg.sv')
+        if not all((os.path.isdir(uvm_home), os.path.isfile(uvm_pkg))):
+            return False
+
+        handle_tool_version(tool=tool, eda_command='sim', cfg=config)
+        version_list = known_tool_versions.get('verilator', '').split('.')
+        if int(version_list[0]) < 5 or \
+           (int(version_list[0]) == 5 and int(version_list[1]) < 42):
+            return False
+
+        return True
+
+    # default return False:
+    return False
+
 def can_run_eda_sim(cfg: dict = config) -> bool:
     '''Returns True if we have any installed tool that can run: eda sim'''
     return can_run_eda_command('sim', cfg=cfg)

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/tests/test_eda.py

@@ -100,9 +100,19 @@ class TestsRequiresVerilator( # pylint: disable=too-many-public-methods
     def test_args_sim_tool_with_path(self):
         '''Test for calling a tool as --tool=<tool>=</path/to/tool-exe>'''
         verilator_fullpath = shutil.which('verilator')
+        verilator_path, _ = os.path.split(verilator_fullpath)
+
         chdir_remove_work_dir('../../lib/tests')
         rc = eda_sim_wrap('--tool', f'verilator={verilator_fullpath}', 'oclib_fifo_test')
-        print(f'{rc=}')
+        assert rc == 0
+
+        rc = eda_sim_wrap('--tool', f'verilator:{verilator_fullpath}', 'oclib_fifo_test')
+        assert rc == 0
+
+        rc = eda_sim_wrap('--tool', f'verilator={verilator_path}', 'oclib_fifo_test')
+        assert rc == 0
+
+        rc = eda_sim_wrap('--tool', f'verilator:{verilator_fullpath}', 'oclib_fifo_test')
         assert rc == 0
 
     def test_args_sim_with_coverage(self):

{opencos_eda-0.3.3 → opencos_eda-0.3.5}/opencos/tools/iverilog.py

@@ -160,6 +160,10 @@ class CommandSimIverilog(CommandSim, ToolIverilog):
         cmd_list += self.tool_config.get('simulate-args', '').split()
         if self.args['waves']:
             cmd_list += self.tool_config.get('simulate-waves-args', '').split()
+        for x in self.args['sim-plusargs']:
+            if x[0] != '+':
+                x = f'+{x}'
+            cmd_list.append(x)
         return [ util.ShellCommandList(cmd_list, tee_fpath='sim.log') ]
 
     def get_post_simulate_command_lists(self, **kwargs) -> list: