opencos-eda 0.3.3__py3-none-any.whl → 0.3.6__py3-none-any.whl

opencos/tools/cocotb.py

@@ -10,7 +10,9 @@ import subprocess
 from opencos import util
 from opencos.eda_base import Tool
 from opencos.commands import CommandSim
+from opencos.utils import status_constants
 from opencos.utils.str_helpers import sanitize_defines_for_sh
+from opencos.tools import verilator # For default waivers.
 
 
 class ToolCocotb(Tool):
@@ -76,6 +78,8 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             'tcl-file': None,
             'cocotb-test-module': None,
             'cocotb-test-runner': 'python',
+            'cocotb-test-runner-file': '',
+            'cocotb-test-run-dir': None, # If None, use self.args['work-dir']
             'cocotb-simulator': 'verilator',
             'cocotb-makefile': False,
             'cocotb-python-runner': True,
@@ -86,17 +90,25 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             'waves': 'Include waveforms by setting COCOTB_ENABLE_WAVES=1',
             'cocotb-test-module': 'Python test module name (e.g., test_my_design)',
             'cocotb-test-runner': 'Test runner to use: python (default) or pytest',
-            'cocotb-simulator': ('Simulator backend: verilator (default), icarus, etc.'
-                                 ' Note that iverilog will convert to icarus here'),
+            'cocotb-test-runner-file': 'Bring your own test_runner.py file',
+            'cocotb-test-run-dir': (
+                'Directory where cocotb-test-runner will run, if unset uses default eda.work/(name)'
+            ),
+            'cocotb-simulator': (
+                'Simulator backend: verilator (default), icarus, etc.'
+                ' Note that iverilog will convert to icarus here'
+            ),
             'cocotb-makefile': 'Use traditional Makefile system instead of Python runner',
             'cocotb-python-runner': 'Use Python-based runner system (default, cocotb 1.8+)',
-            'cocotb-standalone-makefile': ('Use provided Makefile as-is, '
-                                          'run make in source directory'),
+            'cocotb-standalone-makefile': (
+                'Use provided Makefile as-is, run make in source directory'
+            ),
         })
 
         self.cocotb_command_lists = []
         self.cocotb_test_files = []
 
+
     def set_tool_defines(self):
         ToolCocotb.set_tool_defines(self)
 
@@ -155,12 +167,13 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
             simulate_sh_fname='cocotb_test.sh'
         )
 
+
     def _find_cocotb_test_files(self):
         '''Find Python test files that contain cocotb tests'''
         self.cocotb_test_files = []
 
         # Look for test files in the current directory and deps
-        for file_path in self.files_non_source:
+        for file_path in self.files_non_source + self.files_py:
             if (file_path.endswith('.py') and
                 ('test' in file_path.lower() or 'tb' in file_path.lower())):
                 # Check if it's a cocotb test file
@@ -193,8 +206,19 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
     def _prepare_python_runner_system(self):
         '''Prepare cocotb using the Python-based runner system (cocotb 1.8+)'''
 
-        # Create a Python runner script
-        runner_script = self._create_python_runner_script()
+        # Create a Python runner script, or use from --cocotb-test-runner-file
+        if self.args['cocotb-test-runner-file']:
+
+            runner_script = self.args['cocotb-test-runner-file']
+            if not os.path.isfile(self.args['cocotb-test-runner-file']):
+                self.error(
+                    "File does not exist, for: --cocotb-test-runner-file=",
+                    f"{self.args['cocotb-test-runner-file']}",
+                    error_code=status_constants.EDA_GENERAL_FILE_NOT_FOUND
+                )
+                return
+        else:
+            runner_script = self._create_python_runner_script()
 
         if self.args['cocotb-test-runner'] == 'pytest':
             # Use pytest to run the tests
@@ -212,28 +236,41 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         # Set environment variables
         env_vars = self._get_cocotb_env_vars()
 
-        # Create command with environment variables
-        command_list = self._create_env_command(env_vars) + cmd_list
-        self.cocotb_command_lists = [util.ShellCommandList(command_list,
-                                                          tee_fpath='cocotb_test.log')]
+        # Create command with environment variables, needs to be list-of-(cmd_list)
+        self.cocotb_command_lists = [
+            util.ShellCommandList(
+                self._create_env_command(env_vars) + cmd_list,
+                tee_fpath='cocotb_test.log',
+                # If someone wanted to run this from a specific dir, then
+                # run it from there.
+                work_dir=self.args['cocotb-test-run-dir']
+            )
+        ]
 
     def _prepare_makefile_system(self):
         '''Prepare cocotb using the traditional Makefile system'''
 
         makefile_path = os.path.join(self.args['work-dir'], 'Makefile')
+        self.files_makefile.append(makefile_path)
         with open(makefile_path, 'w', encoding='utf-8') as f:
             f.write(self._create_makefile_content())
 
         cmd_list = self._create_shell_command_with_success('make -f Makefile')
-        self.cocotb_command_lists = [util.ShellCommandList(cmd_list,
-                                                          tee_fpath='cocotb_makefile.log')]
+        self.cocotb_command_lists = [
+            util.ShellCommandList(
+                cmd_list, tee_fpath='cocotb_makefile.log',
+                # If someone wanted to run this from a specific dir, then
+                # run it from there.
+                work_dir=self.args['cocotb-test-run-dir']
+            )
+        ]
 
     def _prepare_standalone_makefile_system(self):
         '''Use provided Makefile as-is, run make in source directory'''
 
         # Find the Makefile in our dependencies
         makefile_path = None
-        for file_path in self.files_non_source:
+        for file_path in self.files_non_source + self.files_makefile:
             if os.path.basename(file_path).lower() == 'makefile':
                 makefile_path = file_path
                 break
@@ -241,10 +278,19 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
         if not makefile_path:
             self.error('No Makefile found in deps for --cocotb-standalone-makefile')
 
+        if any(value for key,value in self.args.items() if key.startswith('export')):
+            util.warning(f'Using an --export arg with Cocotb standalong Makefile {makefile_path}',
+                         'is not fully supported')
+
         makefile_dir = os.path.dirname(os.path.abspath(makefile_path))
-        cmd_list = self._create_shell_command_with_success(f'cd {makefile_dir} && make')
-        self.cocotb_command_lists = [util.ShellCommandList(
-            cmd_list, tee_fpath='cocotb_standalone.log')]
+        cmd_list = self._create_shell_command_with_success('make')
+        self.cocotb_command_lists = [
+            util.ShellCommandList(
+                cmd_list,
+                tee_fpath='cocotb_standalone.log',
+                work_dir=makefile_dir
+            )
+        ]
 
     def _get_test_module_name(self) -> str:
         '''Get the test module name from args or detected files'''
@@ -280,8 +326,22 @@ class CommandSimCocotb(CommandSim, ToolCocotb):
 
         return script_path
 
+
     def _generate_runner_script_content(self, test_module: str, hdl_sources: list) -> str:
         '''Generate the content for the Python runner script'''
+
+        if shutil.which('verilator'):
+            # TODO(drew): this shortcuts if verilator is truly usable,
+            # consider using eda_tool_helper to get "tools_loaded", which
+            # is not set in self.config['tools_loaded'] when --tool=cocotb.
+            # Would need minor refactor for eda.py methods auto_tools_order,
+            # tool_setup to go into eda_tool_helper.py, and those methods would
+            # need hooks to be non-destructive to config.
+            tmp_verilator_obj = verilator.VerilatorSim(config=self.config)
+            verilator_waivers = tmp_verilator_obj.get_verilator_tool_config_waivers()
+        else:
+            verilator_waivers = []
+
         return f'''#!/usr/bin/env python3
 """
 Cocotb test runner script generated by opencos
@@ -337,6 +397,8 @@ def run_cocotb_test():
 
         if simulator == "verilator":
             build_args.extend({list(self.args.get('verilate-args', []))!r})
+            build_args.extend({list(self.args.get('compile-args', []))!r})
+            build_args.extend({list(verilator_waivers)!r})
 
         # Build the design
         runner.build(
@@ -449,9 +511,20 @@ include $(shell cocotb-config --makefiles)/Makefile.sim
         '''Get environment variables for cocotb execution'''
         env_vars = {}
 
+        top = self.args.get('top', 'top')
+
         # Basic cocotb configuration
-        env_vars['SIM'] = self.args['cocotb-simulator']
-        env_vars['TOPLEVEL'] = self.args.get('top', 'top')
+        env_vars.update({
+            'SIM': self.args['cocotb-simulator'],
+            'TOPLEVEL': top,
+            'COCOTB_TOPLEVEL': top,
+        })
+
+        if test_module := self.args['cocotb-test-module']:
+            env_vars.update({
+                'MODULE': test_module,
+                'COCOTB_TEST_MODULES': test_module,
+            })
 
         # Enable waves if requested
         if self.args.get('waves', False):
@@ -464,8 +537,8 @@ include $(shell cocotb-config --makefiles)/Makefile.sim
             env_vars['COCOTB_LOG_LEVEL'] = 'INFO'
 
         # Random seed
-        if self.args.get('seed'):
-            env_vars['COCOTB_RANDOM_SEED'] = str(self.args['seed'])
+        if seed := self.args.get('seed'):
+            env_vars['COCOTB_RANDOM_SEED'] = str(seed)
 
         return env_vars
 

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:

opencos/tools/riviera.py

@@ -13,6 +13,7 @@ import subprocess
 from opencos import util
 from opencos.tools.modelsim_ase import ToolModelsimAse, CommandSimModelsimAse
 from opencos.utils.str_helpers import sanitize_defines_for_sh
+from opencos.utils import status_constants
 
 class ToolRiviera(ToolModelsimAse):
     '''ToolRiviera used by opencos.eda for --tool=riviera'''
@@ -61,6 +62,7 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
             'gui': False,
             'waves-fst': True,
             'waves-vcd': False,
+            'coverage-tcl': '',
         })
         self.args_help.update({
             'waves-fst': (
@@ -70,6 +72,10 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
             ),
             'waves-vcd': 'If using --waves, apply simulation runtime arg +trace=vcd',
             'waves': 'Save a .asdb offline wavefile, can be used with --waves-fst or --waves-vcd',
+            'coverage-tcl': (
+                'bring your own .tcl file to run in Riviera (vsim) for coverage. The default'
+                ' tcl steps are (from tool config in --config-yml):   '
+            ) + '; '.join(self.tool_config.get('simulate-coverage-tcl', [])),
         })
 
     def set_tool_defines(self):
@@ -183,7 +189,9 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
 
 
 
-    def write_vsim_dot_do(self, dot_do_to_write: list) -> None:
+    def write_vsim_dot_do( # pylint: disable=too-many-branches
+            self, dot_do_to_write: list
+    ) -> None:
         '''Writes files(s) based on dot_do_to_write(list of str)
 
         list arg values can be empty (all) or have items 'all', 'sim', 'lint', 'vlog'.'''
@@ -278,18 +286,21 @@ class CommandSimRiviera(CommandSimModelsimAse, ToolRiviera):
             "}",
         ]
 
+        vsim_dot_do_lines += [
+            "run -all;",
+        ]
         if self.args['coverage']:
-            vsim_dot_do_lines += [
-                "run -all;",
-                "acdb save",
-                "acdb report -db work.acdb -txt -o cov.txt",
-                # Note - could try:
-                ##"cover report -o cov.report.txt -fullverbose -all_columns",
-            ]
-        else:
-            vsim_dot_do_lines += [
-                "run -all;",
-            ]
+            if self.args['coverage-tcl']:
+                tclfile = os.path.abspath(self.args['coverage-tcl'])
+                if not os.path.isfile(tclfile):
+                    self.error(f'--coverage-tcl file not found: {tclfile}',
+                               error_code=status_constants.EDA_COMMAND_OR_ARGS_ERROR)
+                vsim_dot_do_lines += [
+                    f'source {tclfile}'
+                ]
+            else:
+                # default TCL for coverage:
+                vsim_dot_do_lines += self.tool_config.get('simulate-coverage-tcl', [])
 
 
         vsim_dot_do_lines += [

opencos/tools/verilator.py

@@ -83,6 +83,7 @@ class VerilatorSim(CommandSim, ToolVerilator):
             'lint-only': False,
             'cc-mode': False,
             'verilator-coverage-args': [],
+            'uvm': False,
             'x-assign': '',
             'x-initial': '',
         })
@@ -116,6 +117,15 @@ class VerilatorSim(CommandSim, ToolVerilator):
                          ' where valid string values are: 0, unique, fast.'
                          ' Also conditinally adds to verilated exe call:'
                          ' +verilator+rand+reset+[0,2] for arg values 0, unique|fast'),
+            'uvm': (
+                'Warns on Verilator < 5.042, or missing $UVM_HOME environment var set (or in'
+                ' .env, $UVM_HOME/uvm_pkg.sv should exist), and will run verilator with args:'
+                ' -Wno-fatal +define+UVM_NO_DPI'
+            ),
+            'verilator-coverage-args': (
+                'Requires --coverage, args to be applied to verilator_coverage, which runs'
+                ' after running the compiled executable simulation'
+            ),
         })
 
         self.verilate_command_lists = []
@@ -212,12 +222,19 @@ class VerilatorSim(CommandSim, ToolVerilator):
 
         verilate_command_list = self._get_start_verilator_command_list(lint_only=lint_only)
 
-        verilate_command_list += self._get_verilator_tool_config_waivers()
+        # Handle UVM things (return args), but also handles uvm_pkg.sv in self.files_sv:
+        # since we run this 2x (lint-only and normal) only do warnings for one of them:
+        verilate_command_list += self._verilator_args_uvm(
+            warnings=(not lint_only), add_uvm_pkg_if_found=True
+        )
+
+        verilate_command_list += self.get_verilator_tool_config_waivers()
 
         verilate_command_list += self._verilator_args_defaults_cflags_nproc()
 
         verilate_command_list += self._get_verilator_waves_args(lint_only=lint_only)
 
+
         if self.args.get('coverage', True):
             verilate_command_list += self.tool_config.get(
                 'compile-coverage-args', '--coverage').split()
@@ -391,7 +408,10 @@ class VerilatorSim(CommandSim, ToolVerilator):
 
         return verilate_command_list
 
-    def _get_verilator_tool_config_waivers(self) -> list:
+    def get_verilator_tool_config_waivers(self) -> list:
+        '''Returns list of args to verilator for waviers, from --compile-waivers and
+
+        --config-yml for tool: (config)'''
 
         # Add compile waivers from self.config (tools.verilator.compile-waivers list):
         # list(set(mylist)) to get unique.
@@ -486,6 +506,75 @@ class VerilatorSim(CommandSim, ToolVerilator):
         return verilate_args
 
 
+    def _verilator_support_uvm_pkg_fpath(self, add_if_found: bool = True) -> bool:
+        '''Returns False if we could not find a suitable uvm_pkg.sv to use, or if --no-uvm.
+
+        This will also auto-add uvm_pkg.sv from $UVM_HOME/uvm_pkg.sv if not present in
+        self.files already (adds to front of self.files_sv)
+        '''
+
+        if not self.args['uvm']:
+            return False
+
+        for fname, exists in self.files.items():
+            if exists and os.path.split(fname)[1] == 'uvm_pkg.sv':
+                # already present in our source files (assume someone doing it manually
+                # or via DEPS)
+                return True
+
+        uvm_home = os.environ.get('UVM_HOME', '')
+        if not uvm_home:
+            return False
+
+        uvm_pkg_fpath = os.path.join(uvm_home, 'uvm_pkg.sv')
+        if add_if_found and os.path.isfile(uvm_pkg_fpath):
+            uvm_pkg_fpath = os.path.abspath(uvm_pkg_fpath)
+            util.info(f'For --uvm, adding to source files: {uvm_pkg_fpath}')
+            self.files[uvm_pkg_fpath] = True
+            self.files_sv.insert(0, uvm_pkg_fpath)
+            self.files_caller_info[uvm_pkg_fpath] = 'verilator.py'
+            util.info(f'For --uvm, adding +incdir+: {uvm_home}')
+            self.incdirs.append(os.path.abspath(uvm_home))
+            return True
+
+        return False
+
+
+    def _verilator_args_uvm(
+            self, warnings: bool = True, add_uvm_pkg_if_found: bool = True
+    ) -> list:
+        '''Returns list of args to be added to verilator (compile) step if --uvm present
+
+        Warnings on potential issues (Veriltor version, missing uvm_pkg.sv).
+        Optionally adds uvm_pkg.sv to source files.
+        '''
+
+        # Handle --uvm args:
+        if not self.args['uvm']:
+            return []
+
+        if warnings:
+
+            # prefers Verilator >= v5.042, $UVM_HOME to be set, or warning.
+            version_list = self._VERSION.split('.')
+            if int(version_list[0]) < 5 or \
+               (int(version_list[0]) == 5 and int(version_list[1]) < 42):
+                util.warning(f'Verilator version is {self._VERSION}, --uvm set prefers Verilator',
+                             'version > v5.042')
+
+            if not os.environ.get('UVM_HOME', ''):
+                util.warning('--uvm set, however env (or .env or --env-file) $UVM_HOME is not set')
+
+        uvm_pkg_found = self._verilator_support_uvm_pkg_fpath(add_if_found=add_uvm_pkg_if_found)
+        if warnings and not uvm_pkg_found:
+            util.warning(
+                '--uvm set, however no suitable uvm_pkg.sv is source files,',
+                f'nor in $UVM_HOME/uvm_pkg.sv. $UVM_HOME={os.environ.get("UVM_HOME", "")}'
+            )
+
+        return ['-Wno-fatal', '+define+UVM_NO_DPI']
+
+
     def artifacts_add(self, name: str, typ: str, description: str) -> None:
         '''Override from Command.artifacts_add, so we can catch known file
 

opencos/tools/vivado.py

@@ -272,6 +272,7 @@ class CommandSimVivado(CommandSim, ToolVivado):
             xsim_plusargs_list.append('--testplusarg')
             if x[0] == '+':
                 x = x[1:]
+            x = x.replace('"', '\\\"') # we have to preserve " in the value.
             xsim_plusargs_list.append(f'\"{x}\"')
 
         # execute snapshot