fusesoc 2.3__tar.gz → 2.4__tar.gz

{fusesoc-2.3 → fusesoc-2.4}/.github/workflows/ci.yml

@@ -23,21 +23,28 @@ jobs:
         # https://github.com/olofk/fusesoc/issues/528
         #- { icon: 🧊, name: windows-latest }
         pyver:
-          - '3.6'
           - '3.7'
           - '3.8'
           - '3.9'
           - '3.10'
-          - '3.11.0-alpha - 3.11.0'
+          - '3.11'
+          - '3.12'
+        exclude:
+          #Fails because github can't find an arm64 image for Python 3.7???
+          - os: {name: macos-latest}
+            pyver: '3.7'
+          #Fails because one test expects a different output during an exception
+          - os: {name: macos-latest}
+            pyver: '3.8'
     runs-on: ${{ matrix.os.name }}
     name: ${{ matrix.os.icon }} ${{ matrix.os.name }} | ${{ matrix.pyver }}
     steps:
 
     - name: 🧰 Repository Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     - name: 🐍 Set up Python ${{ matrix.pyver }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.pyver }}
 

{fusesoc-2.3 → fusesoc-2.4}/.github/workflows/lint.yml

@@ -9,6 +9,6 @@ jobs:
   pre-commit:
     runs-on: ubuntu-20.04
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-python@v4
+    - uses: actions/checkout@v4
+    - uses: actions/setup-python@v5
     - uses: pre-commit/action@v2.0.0

{fusesoc-2.3 → fusesoc-2.4}/NEWS

@@ -1,3 +1,19 @@
+2.4 2024-10-02 Olof Kindgren <olof.kindgren@gmail.com>
+======================================================
+* Add conflict handling for virtual cores
+* Connect generated cores in EDAM dependency graph
+* Support implicit name in library add command
+* Migrate from setup.py to pyproject.toml
+* Add support for EDAM filter plugins
+
+Contributors:
+Alexander Williams <awill@opentitan.org>
+Alfred E Neuman <quinky@gmx.ch>
+Daniel Copley <djcopley@users.noreply.github.com>
+Jelle van der Waa <jelle@vdwaa.nl>
+Olof Kindgren <olof.kindgren@gmail.com>
+Phillipe Jean-Jumeau <pljeanjumeau@gmail.com>
+
 2.3 2023-11-17 Olof Kindgren <olof.kindgren@gmail.com>
 ======================================================
 * Add CLI to read/write config settings

{fusesoc-2.3 → fusesoc-2.4}/PKG-INFO

@@ -1,25 +1,33 @@
 Metadata-Version: 2.1
 Name: fusesoc
-Version: 2.3
-Summary: FuseSoC is a package manager and a set of build tools for HDL (Hardware Description Language) code.
-Home-page: https://github.com/olofk/fusesoc
-Author: Olof Kindgren
-Author-email: olof.kindgren@gmail.com
-License: BSD-2-Clause
-Keywords: VHDL,verilog,hdl,rtl,synthesis,FPGA,simulation,Xilinx,Altera
+Version: 2.4
+Summary: Award-winnning package manager and build abstraction tool for HDL code
+Author-email: Olof Kindgren <olof@award-winning.me>
+Maintainer-email: Olof Kindgren <olof@award-winning.me>
+Project-URL: Homepage, https://fusesoc.net
+Project-URL: Documentation, https://fusesoc.readthedocs.io
+Project-URL: Repository, https://github.com/olofk/fusesoc
+Project-URL: Issues, https://github.com/olofk/fusesoc/issues
+Project-URL: Changelog, https://github.com/olofk/fusesoc/blob/main/NEWS
+Keywords: VHDL,verilog,hdl,rtl,synthesis,FPGA,simulation,ASIC
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Topic :: Utilities
 Classifier: Topic :: Software Development :: Build Tools
 Classifier: License :: OSI Approved :: BSD License
-Requires-Python: >=3.6, <4
+Requires-Python: <4,>=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: edalize>=0.4.1
+Requires-Dist: pyparsing>=2.3.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: simplesat>=0.8.0
+Requires-Dist: fastjsonschema
+Requires-Dist: jsonschema2md
 
 # FuseSoC
 
 [![CI status](https://github.com/olofk/fusesoc/workflows/CI/badge.svg)](https://github.com/olofk/fusesoc/actions?query=workflow%3ACI)
 [![image](https://img.shields.io/pypi/dm/fusesoc.svg?label=PyPI%20downloads)](https://pypi.org/project/fusesoc/)
-[![LibreCores](https://www.librecores.org/olofk/FuseSoC/badge.svg?style=flat)](https://www.librecores.org/olofk/FuseSoC)
 
 ## Introduction
 

{fusesoc-2.3 → fusesoc-2.4}/README.md

@@ -2,7 +2,6 @@
 
 [![CI status](https://github.com/olofk/fusesoc/workflows/CI/badge.svg)](https://github.com/olofk/fusesoc/actions?query=workflow%3ACI)
 [![image](https://img.shields.io/pypi/dm/fusesoc.svg?label=PyPI%20downloads)](https://pypi.org/project/fusesoc/)
-[![LibreCores](https://www.librecores.org/olofk/FuseSoC/badge.svg?style=flat)](https://www.librecores.org/olofk/FuseSoC)
 
 ## Introduction
 

{fusesoc-2.3 → fusesoc-2.4}/doc/source/conf.py

@@ -36,7 +36,12 @@ copyright = f"2018-{datetime.now().year}, Olof Kindgren"
 author = "Olof Kindgren"
 
 # The full version, including alpha/beta/rc tags.
-release = fusesoc.__version__
+try:
+    from fusesoc.version import version as __version__
+except ImportError:
+    __version__ = "unknown"
+
+release = __version__
 # The short X.Y version.
 v_major, v_minor = LooseVersion(release).version[:2]
 version = f"{v_major}.{v_minor}"

fusesoc-2.4/doc/source/user/build_system/filters.rst

@@ -0,0 +1,99 @@
+.. _ug_build_system_filters:
+
+Filters: Make system-wide modifications to the EDAM structure
+=============================================================
+
+The last thing FuseSoC does before handing over to Edalize, is to prepare an EDAM file containing a description of the complete system and everything that the EDA tools need to know. It is sometimes useful to make system-wide changes after the system is assembled, and this is where filters come in. Filters are additional tasks that can be run to analyze and modify the EDAM structure, and through that structure the filters have access to the complete dependency tree and all source files.
+
+FuseSoC ships with a few built-in filters for generally useful tasks:
+
+* autotype: Sets file types according to the file name prefix for files that don't have an explicit file type set.
+* custom: Runs the command specified with the environment variable `FUSESOC_CUSTOM_FILTER`. Two arguments are passed to the command. The first specifies the EDAM (yaml) file the custom command is supposed to read. The second specifies the name of the file that the filter should use to return the modified EDAM struct.
+* dot: Creates a GraphViz dot file of the dependency tree
+
+All filters are run from the work root directory.
+
+.. note::
+    Technically, an Edalize frontend can perform the exact same task as a FuseSoC EDAM filter. The difference is more philosophical in that a filter can be seen as something that fixes up the system before it is ready to be consumed by an EDA tool, while an Edalize frontend typically *is* an EDA tool. The filters will also possibly have access to more FuseSoC internals in the future.
+
+Using filters
+-------------
+
+There are three way to enable which filters to be applied. These three options have various use-cases.
+
+Filters in targets
+~~~~~~~~~~~~~~~~~~
+
+Filters specified in a target section of a core are typically required for the the build to work. In order to enable a filter for a target, add a list of filters using the `filters` key.
+
+.. code-block:: yaml
+
+   # An excerpt from a core file.
+   targets:
+     sim:
+       # ...
+       filters: [autotype, dot] # Apply the autotype and dot filters in that order
+
+Filters in the configuration file
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Filters can be set in the configuration file as a list of space-separated strings in the `main` section. These can be set with the fusesoc config cli, e.g. `fusesoc config filters "filter1 filter2"`. Filters set in the config file are typically used when all targets of the cores in the workspace need some filter to be applied, or just as a convenienence for users who like to have som particular filter always enabled. These filters are applied after the ones from the core file targets.
+
+Filters on the command-line
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+It is also possible to set filters on the command-line. This is typically used for one-off filters, e.g. to generate some debug info. They are enabled with the `--filter` parameters, e.g. `fusesoc run --filter=dot --target=sim ...`. The `--filter` parameter can be specified multiple times to add more filters. Filters on the command-line are applied after the ones from the configuration file.
+
+
+Creating additional filters
+---------------------------
+
+A filter is a Python module that contains a class with the same name as the module, but capitalized. The class needs to implement a function called `run` which takes the EDAM struct as the first argumen and the work root as the second argument. The function needs to return the new EDAM struct even if it is unmodified.
+
+Filter template::
+
+    import logging
+    import os
+
+    logger = logging.getLogger(__name__)
+
+
+    class Customfilter:
+        def run(self, edam, work_root):
+            # Print file sizes of all verilog files in the system
+            for f in edam["files"]:
+                if f["file_type"].startswith("verilogSource"):
+                    size = os.path.getsize(os.path.join(work_root, f["name"]))
+                    print(f"{f['name']} is {size} bytes")
+
+            # Add an additional parameter
+            edam["parameters"]["my_number"] = {"datatype" : "int",
+                                               "paramtype": "vlogdefine",
+                                               "default" : 5446}
+
+            # Change the system name
+            edam["name"] = "bestsystemever"
+
+            # Return modified EDAM struct
+            return edam
+
+FuseSoC implements support for implicit namespace packages (https://peps.python.org/pep-0420/) This means that subclasses that logically belong to FuseSoC can be distributed over several physical locations and is something we can take advantage of to add new filters outside of the FuseSoC code base.
+
+In order to do that we will create a directory structure that mirrors the structure of FuseSoC like the example below::
+
+  externalplugin/
+      fusesoc/
+          filters/
+	      customfilter.py
+	      anothercustomfilter.py
+
+There are two common options for making the above `customfilter.py` and `anothercustomfilter.py` available to FuseSoC.
+
+The first way is to add the `externalplugin` path to ``PYTHONPATH``. The other is to add a `setup.py` in the `externalplugin` directory and install the filter plugin with pip as with other Python packages.
+
+A `setup.py` in its absolutely most minimal form is listed below and is enough to install the plugin as a package in development mode using ``pip install --user -e .`` from the `externalplugin` directory.::
+
+  from setuptools import setup
+  setup()
+
+A real `setup.py` like the one used by FuseSoC normally contains a lot more information.

{fusesoc-2.3 → fusesoc-2.4}/doc/source/user/build_system/index.rst

@@ -35,6 +35,7 @@ A full reference documentation on the CAPI2 core file format can be found in the
    core_files.rst
    eda_flows.rst
    dependencies.rst
+   filters.rst
    flags.rst
    generators.rst
    hooks.rst

fusesoc-2.4/doc/source/user/knowledgebase.rst

@@ -0,0 +1,119 @@
+*****************************
+Common Problems and Solutions
+*****************************
+
+Making changes to cores in a library
+====================================
+
+A common situation is that a user wants to use their own copy of a core,
+instead of the one provided by a library, for example to fix a bug or
+add new functionality. The following steps can be used to achieve this:
+
+**Example.** Replace a core in a library with a user-specified version
+
+#. Create a new directory to keep the user-copies of the cores (this
+   directory will be referred to as ``$corelib`` from now on)
+#. Download the core source (the repository or URL can be found in the
+   ``[provider]`` section of the original core)
+#. *If the downloaded core already contains a .core file, this step is
+   ignored* Copy the original .core file to the root of the downloaded
+   core. Edit the file and remove the ``[provider]`` section. (This will
+   stop FuseSoC from downloading the core and use files from the
+   directory containing the .core file instead)
+#. Add ``$corelib`` to the end of your library search path, either by
+   editing ``fusesoc.conf`` or by adding ``--cores-root=$corelib`` to
+   the command-line arguments
+#. Verify that the new core is found by running fusesoc core-info $core. Check
+   the output to see that “Core root:” is set to the directory where the core
+   was downloaded
+
+Dependency tree for a core with optional components
+===================================================
+
+Many cores have a part that is only used in some flows. This could for example be a BFM, VIP or some kind of behavioral model that is only used in simulation flows. Or it could be timing constraints for synthesis. As long as these are only by the core itself, it's easiest to put them into different filesets and let each simulation or synthesis target pick the right subset of filesets.
+
+A more complicated situation arises when a user uses this core as a dependency and wants to have different filesets for different flows in the toplevel core. In this case, it is typically better to split out the optional part into its own cores and have the toplevel filesets depend on the different cores.
+
+**Example** Let's assume a core (comp) comes with a BFM. We want to use the BFM when doing block-level simulations of the core and when doing full system simulations which uses this core. We don't want to have the BFM present when doing full system synthesis. The most general solution is to split out the BFM to a separate core file. The following example shows a setup with a component (comp.core) that has a BFM (comp_bfm.core) which is used inside a larger system (top.core). The component has a testbench target (sim) and the larger system has two testbenches (tb1 and tb2) which both uses the BFM and the component. The larger system can also be synthesized without the BFM.
+
+.. image:: optional_deps.png
+  :alt: Alternative text
+
+.. code-block:: yaml
+   :caption: comp_bfm.core
+
+    CAPI=2:
+
+    name : ::comp_bfm:0
+
+    filesets:
+      bfm:
+        files: {comp_bfm.sv : {file_type : systemVerilogSource}}
+
+    targets:
+      default:
+        filesets : [bfm]
+
+.. code-block:: yaml
+   :caption: comp.core
+
+    CAPI=2:
+
+    name : ::comp:0
+
+    filesets:
+      rtl:
+        files: {comp.sv : {file_type : systemVerilogSource}}
+
+      tb_files:
+        files: {comp_tb.sv : {file_type : systemVerilogSource}}
+        depend: [comp_bfm]
+
+    targets:
+      default:
+        filesets : [rtl]
+
+      sim:
+        filesets : [rtl, tb_files]
+
+.. code-block:: yaml
+   :caption: top.core
+
+    CAPI=2:
+
+    name : ::top:0
+
+    filesets:
+      rtl:
+        files: {top.sv : {file_type : systemVerilogSource}}
+        depend: [comp]
+
+      tb_common:
+        files: {tb_common.sv : {file_type : systemVerilogSource}}
+        depend: [comp_bfm]
+
+      tb1_files:
+        files: {tb1.sv : {file_type : systemVerilogSource}}
+
+      tb2_files:
+        files: {tb1.sv : {file_type : systemVerilogSource}}
+
+      synth_files:
+        files: {constraints.sdc : {file_type : SDC}}
+
+    targets:
+      sim: &sim
+        filesets : [rtl, tb_files]
+
+      tb1:
+        <<: *sim
+        filesets_append : [tb1_files]
+
+      tb2:
+        <<: *sim
+        filesets_append : [tb2_files]
+
+      synth:
+        filesets : [rtl, synth_files]
+
+An alternative solution to the above, is to use flags, as described in :ref:`ug_build_system_flags`, where the inclusion of the optional files are controlled by flags. These flags can be assigned default values in the top level targets for convenience.

{fusesoc-2.3 → fusesoc-2.4}/fusesoc/capi2/core.py

@@ -13,7 +13,7 @@ from filecmp import cmp
 
 from fusesoc import utils
 from fusesoc.capi2.coredata import CoreData
-from fusesoc.provider import get_provider
+from fusesoc.provider.provider import get_provider
 from fusesoc.vlnv import Vlnv
 
 logger = logging.getLogger(__name__)
@@ -172,8 +172,14 @@ class Core:
                     # Special case for tool as we get it from default_tool
                     flags["tool"] = str(target["default_tool"])
 
+        else:
+            raise RuntimeError(f"'{self.name}' has no target '{target_name}'")
         return flags
 
+    def get_filters(self, flags):
+        target_name, target = self._get_target(flags)
+        return target.get("filters", [])
+
     def get_flow(self, flags):
         self._debug("Getting flow for flags {}".format(str(flags)))
         flow = None

{fusesoc-2.3 → fusesoc-2.4}/fusesoc/capi2/json_schema.py

@@ -110,7 +110,7 @@ capi2_schema = """
           "additionalProperties": false,
           "required": [
             "name",
-            "repo",
+            "repo"
           ]
         },
         {
@@ -272,7 +272,7 @@ capi2_schema = """
               }
             }
           },
-          "additionalProperties": false,
+          "additionalProperties": false
         }
       },
       "additionalProperties": false
@@ -375,7 +375,7 @@ capi2_schema = """
               }
             }
           },
-          "additionalProperties": false,
+          "additionalProperties": false
         }
       }
     },
@@ -386,7 +386,7 @@ capi2_schema = """
         "^.+$": {
           "patternProperties": {
             "^default_tool$": {
-              "description": "Default tool to use unless overridden with ``--tool=``",
+              "description": "Default tool to use unless overridden with ``--tool=`` This key is used by the Edalize Tool API and is ignored if the Flow API is used instead.",
               "type": "string"
             },
             "^description$": {
@@ -394,11 +394,11 @@ capi2_schema = """
               "type": "string"
             },
             "^flow$": {
-              "description": "Edalize backend flow to use for target",
+              "description": "Edalize backend flow to use for target. Setting this key enables the flow API instead of the legacy Tool API.",
               "type": "string"
             },
             "^flow_options$": {
-              "description": "Tool- and flow-specific options",
+              "description": "Tool- and flow-specific options. Used by the Flow API. The Edalize documentation contains information on available options for different flows (https://edalize.readthedocs.io/en/latest/edam/api.html#flow-options)",
               "type": "object",
               "patternProperties": {
                 "^.+$": {
@@ -458,7 +458,7 @@ capi2_schema = """
               "additionalProperties": false
             },
             "^tools$": {
-              "description": "Tool-specific options for target",
+              "description": "Tool-specific options for target. Used by the legacy Tool API. The contents of this section is handled by Edalize, and a list of available tool options for each tool can be found in the Edalize documentation (https://edalize.readthedocs.io/en/latest/edam/api.html#tool-options)",
               "type": "object",
               "patternProperties": {
                 "^.+$": {
@@ -508,6 +508,13 @@ capi2_schema = """
                 "type": "string"
               }
             },
+            "^filters(_append)?$": {
+              "description": "EDAM filters to apply",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
             "^generate(_append)?$": {
               "description": "Parameterized generators to run for this target with optional parametrization",
               "type": "array",

{fusesoc-2.3 → fusesoc-2.4}/fusesoc/config.py

@@ -153,6 +153,16 @@ class Config:
         else:
             return val
 
+    @property
+    def filters(self):
+        return self._cp.get(
+            Config.default_section, "filters", fallback=""
+        ).split() + getattr(self, "args_filters", [])
+
+    @filters.setter
+    def filters(self, val):
+        self._set_default_section("filters", val)
+
     @property
     def build_root(self):
         return self._arg_or_val("args_build_root", self._get_build_root())
@@ -263,7 +273,7 @@ class Config:
             self._cp.write(conf_file)
 
     def add_library(self, library):
-        from fusesoc.provider import get_provider
+        from fusesoc.provider.provider import get_provider
 
         section_name = "library." + library.name
 

{fusesoc-2.3 → fusesoc-2.4}/fusesoc/coremanager.py

@@ -113,6 +113,35 @@ class CoreDB:
     def solve(self, top_core, flags):
         return self._solve(top_core, flags)
 
+    def _get_conflict_map(self):
+        """Return a map of cores to their conflicts
+
+        Only one core that implements a virtual VLNV may be selected in a
+        dependency tree. For each core that implements a virtual VLNV, create a
+        set representing all other cores that implement one of the same virtual
+        VLNVs. In the resulting package definitions, these must get "conflicts"
+        constraints.
+        """
+        conflict_map = {}
+        virtual_map = {}
+        for core_data in self._cores.values():
+            core = core_data["core"]
+            _virtuals = core.get_virtuals()
+            for virtual in _virtuals:
+                for simple in virtual.simpleVLNVs():
+                    virtual_pkg = self._package_name(simple)
+                    # FIXME: The real package should include version info
+                    real_pkg = self._package_name(core.name)
+                    virtual_set = virtual_map.setdefault(virtual_pkg, set())
+                    virtual_set.add(real_pkg)
+        for virtual_pkg, virtual_set in virtual_map.items():
+            for real_pkg in virtual_set:
+                conflict_set = conflict_map.setdefault(real_pkg, set())
+                conflict_set |= virtual_set
+        for real_pkg, conflict_set in conflict_map.items():
+            conflict_set.remove(real_pkg)
+        return conflict_map
+
     def _solve(self, top_core, flags={}, only_matching_vlnv=False):
         def eq_vln(this, that):
             return (
@@ -130,6 +159,8 @@ class CoreDB:
         repo = Repository()
         _flags = flags.copy()
         cores = [x["core"] for x in self._cores.values()]
+        conflict_map = self._get_conflict_map()
+
         for core in cores:
             if only_matching_vlnv:
                 if not any(
@@ -153,6 +184,10 @@ class CoreDB:
             if _virtuals:
                 _s = "; provides ( {} )"
                 package_str += _s.format(self._parse_virtual(_virtuals))
+            conflict_set = conflict_map.get(self._package_name(core.name), set())
+            if len(conflict_set) > 0:
+                _s = "; conflicts ( {} )"
+                package_str += _s.format(", ".join(list(conflict_set)))
 
             # Add dependencies only if we want to build the whole dependency
             # tree.

{fusesoc-2.3 → fusesoc-2.4}/fusesoc/edalizer.py

@@ -9,6 +9,7 @@ import os
 import pathlib
 import shutil
 from filecmp import cmp
+from importlib import import_module
 
 from fusesoc import utils
 from fusesoc.capi2.coreparser import Core2Parser
@@ -49,7 +50,7 @@ class Edalizer:
         system_name=None,
         resolve_env_vars=False,
     ):
-        logger.debug("Building EDA API")
+        logger.debug("Building EDAM structure")
 
         self.toplevel = toplevel
         self.flags = flags
@@ -89,6 +90,20 @@ class Edalizer:
         """Get a list of all cores found by fusesoc"""
         return self.core_manager.db.find()
 
+    def apply_filters(self, global_filters):
+        filters = self.edam.get("filters", []) + global_filters
+        for f in filters:
+            try:
+                filter_class = getattr(
+                    import_module(f"fusesoc.filters.{f}"), f.capitalize()
+                )
+                logger.info(f"Applying filter {f}")
+                self.edam = filter_class().run(self.edam, self.work_root)
+            except ModuleNotFoundError:
+                logger.warning(f"Ignoring unknown EDAM filter '{f}'")
+            except Exception as e:
+                logger.error(f"Filter error: {str(e)}")
+
     def run(self):
         """Run all steps to create a EDAM file"""
 
@@ -102,7 +117,7 @@ class Edalizer:
         # to the list of available cores.
         self.run_generators()
 
-        # Create EDA API file contents
+        # Create EDAM file contents
         self.create_edam()
 
         return self.edam
@@ -148,7 +163,16 @@ class Edalizer:
                     self.work_root if not self.export_root else None,
                     resolve_env_vars=self.resolve_env_vars,
                 )
-                for gen_core in _ttptttg.generate():
+                try:
+                    gen_cores = _ttptttg.generate()
+                except RuntimeError as e:
+                    logger.error(e)
+                    raise RuntimeError(
+                        f"Failed to run generator '{ttptttg_data['name']}'"
+                    )
+                    gen_cores = []
+                for gen_core in gen_cores:
+                    core.direct_deps.append(str(gen_core.name))
                     gen_core.pos = _ttptttg.pos
                     self._resolved_or_generated_cores.append(gen_core)
                     if self.export_root and not (
@@ -199,7 +223,7 @@ class Edalizer:
         for core in self.cores:
             snippet = {}
 
-            logger.debug("Collecting EDA API parameters from {}".format(str(core.name)))
+            logger.debug("Collecting EDAM parameters from {}".format(str(core.name)))
             _flags = self._core_flags(core)
 
             # Extract direct dependencies
@@ -223,6 +247,9 @@ class Edalizer:
                     self.flags["tool"]: core.get_tool_options(_flags)
                 }
 
+            # Extract EDAM filters
+            snippet["filters"] = core.get_filters(_flags)
+
             # Extract flow options
             snippet["flow_options"] = core.get_flow_options(_flags)
 
@@ -282,14 +309,8 @@ class Edalizer:
         top_core = self.resolved_cores[-1]
         self.edam = {
             "version": "0.2.1",
-            "dependencies": {},
-            "files": [],
-            "hooks": {},
             "name": self.system_name or top_core.name.sanitized_name,
-            "parameters": {},
-            "tool_options": {},
             "toplevel": top_core.get_toplevel(self.flags),
-            "vpi": [],
         }
 
         for snippet in first_snippets + snippets + last_snippets:
@@ -355,7 +376,7 @@ class Edalizer:
                     )
                 param_type_map[name.replace("-", "_")] = _paramtype
             else:
-                logging.warn(
+                logging.warning(
                     "Parameter '{}' has unsupported type '{}' for requested backend".format(
                         name, _paramtype
                     )
@@ -480,16 +501,16 @@ class Edalizer:
 
         return flow_options
 
-    def parse_args(self, backend_class, backendargs, edam):
+    def parse_args(self, backend_class, backendargs):
         # First we need to see which flow options are set,
         # in order to know which tool options that are relevant
         # for this configuration of the flow
         if hasattr(backend_class, "get_flow_options"):
             self.activated_flow_options = self._parse_flow_options(
-                backend_class, backendargs, edam
+                backend_class, backendargs, self.edam
             )
 
-        parser = self._build_parser(backend_class, edam)
+        parser = self._build_parser(backend_class, self.edam)
         parsed_args = parser.parse_args(backendargs)
 
         args_dict = {}