Edalize Documentation
             Release 0.1.3
            Olof Kindgren
                 May 18, 2023
                                                                                                   USER GUIDE
1 Edalize User Guide                                                                                                  3
  1.1 Configure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     3
  1.2 Build . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     3
  1.3 Run . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     3
2 Edalize Developer Guide                                                                                             5
  2.1 Development Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .       5
  2.2 Testing edalize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     6
  2.3 Extending Edalize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .       7
3 EDA Metadata                                                                                                       13
  3.1 File . . . . .   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
  3.2 Hook . . . .     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
  3.3 Parameter . .    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
  3.4 Tool options     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
  3.5 VPI . . . . .    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4 edalize package                                                                                                    21
  4.1 Submodules . . . . . . . .       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
  4.2 edalize.edatool module . . .     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
  4.3 edalize.ghdl module . . . .      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
  4.4 edalize.icarus module . . .      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
  4.5 edalize.icestorm module . .      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
  4.6 edalize.ise module . . . . .     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
  4.7 edalize.isim module . . . .      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
  4.8 edalize.modelsim module .        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
  4.9 edalize.openfpga module . .      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
  4.10 edalize.quartus module . . .    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
  4.11 edalize.rivierapro module .     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
  4.12 edalize.symbiyosys module       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
  4.13 edalize.spyglass module . .     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
  4.14 edalize.trellis module . . . .  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
  4.15 edalize.vcs module . . . . .    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
  4.16 edalize.verilator module . .    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
  4.17 edalize.vivado module . . .     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
  4.18 edalize.vunit module . . . .    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
  4.19 edalize.vunit_hooks module      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
  4.20 edalize.xcelium module . .      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
  4.21 edalize.xsim module . . . .     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
  4.22 edalize.reporting module . .    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
                                                                                                                      i
   4.23  edalize.vivado_reporting module    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
   4.24  edalize.quartus_reporting module   . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
   4.25  edalize.ise_reporting module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
   4.26  Module contents . . . . . . . . .  . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5  Index                                                                                                            31
6  Search Page                                                                                                      33
Python Module Index                                                                                                 35
Index                                                                                                               37
ii
                                                                           Edalize Documentation, Release 0.1.3
Edalize is an abstraction library that presents a common interface for different EDA tools. It supports many different
EDA tools and combinations of tools working together, called flows. A flow could e.g. be an FPGA bitstream flow
where one EDA tool is used for synthesis, another one for place & route and a third one to convert the P&R database
into an image that can be loaded into the FPGA. Another example could be a simulation flow, where the simulator itself
is just one tool, but where a code conversion tool is used to preprocess the input to the simulator, e.g. ghdl to convert
VHDL to Verilog for tools that don’t handle the former well enough.
The Edalize User Guide will guide you through how to use the Edalize API to set up and configure EDA flows and use
them in your project.
The Edalize Developer Guide describes how to work with Edalize to fix bugs, improve the current tools and flows or
extend with new ones.
USER GUIDE                                                                                                             1
Edalize Documentation, Release 0.1.3
2                                    USER GUIDE
                                                                                                             CHAPTER
                                                                                                                 ONE
                                                                                 EDALIZE USER GUIDE
The Edalize User Guide will guide you through how to use Edalize to set up and configure EDA flows and use them in
your project.
The Edalize flow is divided into three stages called configure, build and run. The three chapters will be looking at these
stages in detail.
1.1 Configure
1.2 Build
1.3 Run
                                                                                                                         3
Edalize Documentation, Release 0.1.3
4                                    Chapter 1. Edalize User Guide
                                                                                                              CHAPTER
                                                                                                                 TWO
                                                                    EDALIZE DEVELOPER GUIDE
This Developer Guide is for users who intend to work on Edalize itself and explains how to set up Edalize in development
mode, run tests and how to add new features.
2.1 Development Setup
2.1.1 Setup development environment
Note: If you have already installed Edalize, remove it first using pip3 uninstall edalize.
To develop Edalize and test the changes, the edalize package needs to be installed in editable or development mode. In
this mode, the edalize command is linked to the source directory, and changes made to the source code are immedi-
ately visible when calling edalize.
# Install all Python packages required to develop edalize
pip3 install --user -r dev-requirements.txt
# Install Git pre-commit hooks, e.g. for the code formatter and lint tools
pre-commit install
# Install the edalize package in editable mode
pip3 install --user -e .
Note: All commands above use Python 3 and install software only for the current user. If, after this installation, the
edalize command cannot be found adjust your PATH environment variable to include ~/.local/bin.
After this installation is completed, you can
     • edit files in the source directory and re-run edalize to immediately see the changes,
     • run the unit tests as outlined in the section below, and
     • use linter and automated code formatters.
                                                                                                                      5
Edalize Documentation, Release 0.1.3
2.1.2 Formatting and linting code
The Edalize code comes with tooling to automatically format code to conform to our expectations. These tools are
installed and called through a tool called pre-commit. No setup is required: whenever you do a git commit, the
necessary tools are called and your code is automatically formatted and checked for common mistakes.
To check the whole source code pre-commit can be run directly:
# check and fix all files
pre-commit run -a
2.2 Testing edalize
To run the tests, call pytest.
2.2.1 Mocks for commands
We provide mocks (stand-ins) for all tools that we want to exercise in tests (located in tests/mock_commands/). These
mocks are very simplified “models” of the actual tool, and are called instead of the actual tool. They are prepended to
PATH by the setup code in the edalize_common.make_edalize_test() pytest fixture.
In the easiest case, these mocks just write out the commandline they were called with (into a file <tool>.cmd).
In a more complex test setup (e.g. for vcs),
     • if a tool is creating files, we create it too (the file to create is taken from a tool option given)
     • we make the file executable
     • we set the access and modified times of generated files to the current time
2.2.2 Testcases
To define a testcase, use the edalize_common.make_edalize_test() pytest factory fixture. This defines a fac-
tory that you can call to set up a mocked-up backend appropriately. See the documentation for edalize_common.
TestFixture for details of the supported keywords.
The backend attribute of the returned fixture has configure(), build() and run() methods. The testcase should
call these in order, setting up files as necessary between calls and checking whether the results match by calling the
fixture’s compare_files() method.
If the environment variable GOLDEN_RUN is set, the compare_files() method copies the generated files are copied
to become the new reference files, rather than checking their contents.
6                                                                                   Chapter 2. Edalize Developer Guide
                                                                            Edalize Documentation, Release 0.1.3
2.2.3 Helper Module
edalize_common
2.3 Extending Edalize
Edalize comes with support for a large number of tools and flows, but there are always more. This section will look at
how to add more tools and flows to Edalize, either as contributions to the official Edalize distribution, or as code that
can live outside of the Edalize code base. The process for these two alternative ways of extending Edalize is mostly the
same, but Using external tools or flows describes the extra steps for the latter use-case.
2.3.1 Adding a new tool
In order to add support for a new EDA tool, a corresponding tool class needs to be defined. A tool class needs to expose
which configuration options that are available, together with functions for describing what EDAM output that is created
from a given input EDAM description. If there is a need to create any configuration or project files that the EDA tool
itself will use, then a function can be defined for that as well. A tool that implemnts the run phase (e.g. simulators)
also wants to define a function to setup run-time arguments, otherwise that can be left out. These are typically the
functions and variables that a tool class wants to implement, but more advanced uses can also fully override the main
three phases configure, build and run if needed.
Tool template:
import os
from edalize.tools.edatool import Edatool
from edalize.utils import EdaCommands
class Customtool(Edatool):
      description = "Custom tool"
      TOOL_OPTIONS = {
            "custom_tool_options": {
                  "type": "str",
                  "desc": "Additional options for custom tool",
                  "list": True,
            },
      }
      def setup(self, edam):
            super().setup(edam)
            used_files = []
            unused_files = []
            for f in self.files:
                  # This custom tool only operates on files with file names
                  # that have an odd length
                  if len(f["name"]) % 2:
                       used_files.append(f["name"])
                  else:
                                                                                                    (continues on next page)
2.3. Extending Edalize                                                                                                    7
Edalize Documentation, Release 0.1.3
                                                                                            (continued from previous page)
                     unused_files.append(f)
           #f"{f['name']} is a {f.get('file_type')} file")
           # Copy the input EDAM and replace the files with the list
           # of unused files + the files that this tool creates
           output_file = self.name + ".count"
           self.edam = edam.copy()
           self.edam["files"] = unused_files
           self.edam["files"].append(
                {
                     "name": output_file,
                     "file_type": "some_kind_of_file",
                }
           )
           # Define a configuration file to be written
           self.config_file = self.name + '.cfg'
           # Define the command(s) to run the actual EDA tool
           # This example just uses wc to count the number of
           # charactes, words and lines of the source files
           # and writes the results to a file
           commands = EdaCommands()
           commands.add(
                ["wc"]
                + self.tool_options.get("custom_tool_options", [])
                + used_files
                + [self.config_file, ">", output_file],
                [output_file],
                used_files,
           )
           # Define the default output product of this tool
           commands.set_default_target(output_file)
           self.commands = commands
     def write_config_files(self):
           with open(os.path.join(self.work_root, self.config_file,), "w") as cfg_file:
                cfg_file.write("This is a config file for custom tool\n")
description
      A short text description of the tool.
TOOL_OPTIONS
      A dict of available tool options.
setup(edam)
      A function that is run to create the output EDAM from a given input EDAM.
write_config_files
      A function that is called during the configure phase to write out any special configuration files needed by the
      tool.
8                                                                         Chapter 2. Edalize Developer Guide
                                                                            Edalize Documentation, Release 0.1.3
2.3.2 Adding a new flow
In order to combine existing tools in a new way, a flow class needs to be created. A flow needs to implement the
functions, configure, build and run for the three stages of Edalize as well as the get_tool_options class function. It also
needs the class variable argtypes defined.
argtypes
      is a list of parameter types used to indicate which ones that are supported in this flow. The legal values are
      cmdlinearg for command-line arguments, generic for VHDL generics, plusarg for Verilog plusargs, vlogparam
      for Verilog parameters and vlogdefine for Verilog `defines.
get_tool_options(flow_options)
      This function is responsible for returning a dict of all options from all tools in the flow. As the flow options often
      contain options that affect the flow graph (e.g. frontends), this function needs to take the applied set of flow
      options into consideration when returning the list of tools. The Edatool class contains a helper function called
      `get_filtered_tool_options`that can be used to pick out the right tool options given a list of tools and optionally a
      dict of options for each tool that has been already defined by the flow and are therefore unavailable to the user.
configure
      The configure function writes out any tool-specific project or configuration files needed as well as the graph
      execution configuration file (i.e. Makefile).
build
      Calls the previously defined graph execution configuration file to build the default target
run(args)
      For flows that implement the run phase, this is used to call the run target in the graph execution configuration
      file.
Flow template:
from edalize.flows.edaflow import Edaflow
class Customexternalflow(Edaflow):
     argtypes = ["plusarg", "vlogdefine", "vlogparam"]
     FLOW_DEFINED_TOOL_OPTIONS = {
            "secondcustomtool": {"some_option": "some_value", "other_option": []},
     }
     @classmethod
     def get_tool_options(cls, flow_options):
        # Add any frontends used in this flow
        flow = flow_options.get("frontends", []).copy()
        # Add the main tool flow
        flow.append("firstcustomtool")
        flow.append("secondcustomtool")
        return cls.get_filtered_tool_options(flow, cls.FLOW_DEFINED_TOOL_OPTIONS)
     def configure(self):
            print("Configuring custom flow")
     def build(self):
            print("Building with custom flow")
                                                                                                        (continues on next page)
2.3. Extending Edalize                                                                                                        9
Edalize Documentation, Release 0.1.3
                                                                                           (continued from previous page)
     def run(self, args):
           print("Running custom flow")
Many flows can inherit the configure, build and run phases and instead just define functions for configuring the flow
and setting the default target, as can be seen in the generic flow below.
Generic flow template:
import os.path
from importlib import import_module
from edalize.flows.edaflow import Edaflow, FlowGraph
class Generic(Edaflow):
     """Run an arbitrary tool"""
     argtypes = ["cmdlinearg", "generic", "plusarg", "vlogdefine", "vlogparam"]
     FLOW_DEFINED_TOOL_OPTIONS = {
     }
     FLOW_OPTIONS = {
           "frontends": {
                "type": "str",
                "desc": "Tools to run before main tool",
                "list": True,
           },
           "tool": {
                "type": "str",
                "desc": "Select tool",
           },
     }
     @classmethod
     def get_tool_options(cls, flow_options):
           flow = flow_options.get("frontends", []).copy()
           tool = flow_options.get("tool")
           if not tool:
                raise RuntimeError("Flow 'generic' requires flow option 'tool' to be set")
           flow.append(tool)
           return cls.get_filtered_tool_options(flow, cls.FLOW_DEFINED_TOOL_OPTIONS)
     def configure_flow(self, flow_options):
           # Check for mandatory flow option "tool"
           tool = self.flow_options.get("tool", "")
           if not tool:
                raise RuntimeError("Flow 'generic' requires flow option 'tool' to be set")
           # Apply flow-defined tool options if any
           fdto = self.FLOW_DEFINED_TOOL_OPTIONS.get(tool, {})
                                                                                                  (continues on next page)
10                                                                        Chapter 2. Edalize Developer Guide
                                                                            Edalize Documentation, Release 0.1.3
                                                                                                 (continued from previous page)
           # Start flow graph dict
           flow = {tool : {"fdto" : fdto}}
           # Apply frontends
           deps = []
           for frontend in flow_options.get("frontends", []):
                flow[frontend] = {"deps" : deps}
                deps = [frontend]
           # Connect frontends to main tool
           flow[tool]["deps"] = deps
           # Create and return flow graph object
           return FlowGraph.fromdict(flow)
     def configure_tools(self, graph):
           super().configure_tools(graph)
           # Set flow default target from the main tool's default target
           tool = self.flow_options.get("tool")
           self.commands.default_target = graph.get_node(tool).inst.commands.default_target
The generic flow can be used to run any single tool class together with a list of frontends. It implements the config-
ure_flow and configure_tools functions instead of the three main phases.
configure_flow(flow_options)
      This function is used to setup the flow graph. It returns a FlowGraph object that describes which tools to be run
      and their dependendcies on each other. For convenience, the FlowGraph class contains a function to create a
      flow graph from a dict where the key is the name of the tool and the value is a dict in itself containing keys to list
      dependencies (deps) and any flow-defined tool options (fdto). An example from the icestorm flow can be seen
      here.
      icestorm flow graph as a dict:
      {
            "yosys" : {
                 "fdto" : {"arch": "ice40", "output_format": "json"}},
            "nextpnr" : {
                 "deps" : ["yosys"],
                 "fdto" : {"arch": "ice40"}},
            "icepack" : {
                 "deps" : ["nextpnr"]},
            "icetime" : {
                 "deps" : ["nextpnr"]},
      }
configure_tools(nodes)
      configure_tools can be used to set the default target of the flow as well as add in any extra commands to be run
      that are not described in a tool class. This function needs to call configure_tools from the super class first.
2.3. Extending Edalize                                                                                                      11
Edalize Documentation, Release 0.1.3
2.3.3 Using external tools or flows
Edalize implements support for implicit namespace packages (https://peps.python.org/pep-0420/) This means that sub-
classes that logically belong to Edalize can be distributed over several physical locations and is something we can take
advantage of to add new flows or tools outside of the Edalize code base.
In order to do that we will create a directory structure that mirrors the structure of Edalize like the example below:
externalplugin/
     edalize/
           tools/
                 customexternaltool.py
           flows/
                 customexternalflow.py
The names of the tools and flows are not important and it is possible to have multiple tools or flows in these directories.
There are two common options for making the above customexternaltool.py and customexternalflow.py available to
Edalize.
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 plugin tools and flows 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 Edalize normally contains a lot more information.
12                                                                             Chapter 2. Edalize Developer Guide
                                                                                                               CHAPTER
                                                                                                               THREE
                                                                                               EDA METADATA
The EDAM (EDA Metadata) API is a data structure with the intention to describe all input parameters that an EDA
tool will need to run synthesis or build a simulation model from a set of HDL files. The data described in EDAM
is tool-agnostic, with the option to supply tool-specific parameters when required. The data structure itself is a tree
structure with lists and dictionaries using simple data types as strings and integers for the actual values, and is suitable
for (de)serialization with YAML or JSON.
Most keys are optional. The ones which are required are marked accordingly
  Field         Type            Description
  Name
  files         List of File    Contains all the HDL source files, constraint files, vendor IP description files, memory
                                initialization files etc. for the project.
  hooks         Hook            A dictionary of extra commands to execute at various stages of the project build/run.
  name          String          Required Name of the project
  parame-       Dict of Pa-     Specifies build- and run-time parameters, such as plusargs, VHDL generics, Verilog
  ters          rameter         defines etc.
  tool_optionsTool       Op-    A dictionary of tool-specific options.
                tions
  toplevel      List       of   Toplevel module(s) for the project.
                String
  vpi           List of VPI     VPI modules to build for the project.
3.1 File
A file has a name, which is the absolute path or the relative path to the working directory. It also has a type, which
describes the intended usage of the file. Different EDA tools handle different subsets of files and are expected to ignore
files that are not applicable to them, but might issue a warning. By specifying user as the file type, the backends will
explicitly ignore the file. The valid file types are based on the IP-XACT 2014 standard, with some additional file types
added. The file types not covered by IP-XACT are listed below
     • QIP : Intel Quartus IP file
     • UCF : Xilinx ISE constraint file
     • verilogSource-2005 : Verilog 200 source
     • vhdlSource-2008 : VHDL 2008 source
     • xci : Xilinx Vivado IP file
     • xdc : Xilinx Vivado constraint file
                                                                                                                         13
Edalize Documentation, Release 0.1.3
  Field       Type Description
  Name
  name        String Required File name with (absolute or relative) path
  file_type String Required File type
  is_include_file
              Bool Indicates if this file should be treated as an include file (default false)
  in-         String When is_include_file is true, the directory containing the file will be added to the include path.
  clude_path          include_path allows setting an explicit directory to use instead
  logi-       String Logical name (e.g. VHDL/SystemVerilog library) of the file
  cal_name
3.2 Hook
Hooks are scripts that can be registered to execute during various phases of Edalize. The Hook structure contains a key
for each of the four defined stages, and the value of each key is a list of Script to be executed.
The four defined stages are
                                       Key            Description
                                       pre_build      Executed before calling build
                                       post_build     Executed after calling build
                                       pre_run        Executed before calling run
                                       post_run       Executed after calling run
3.2.1 Script
           Field Name       Type               Description
           cmd              List of String     Command to execute
           env              Dict of String     Additional environment variables to set before launching script
           name             String             User-friendly name of the script
3.3 Parameter
A parameter is used for build- and run-time parameters, such as Verilog plusargs, VHDL generics, Verilog defines,
Verilog parameters or any extra command-line options that should be sent to the simulation model. Different tools
support different subsets of parameters. The list below describes valid parameter types
     • cmdlinearg : Command-line argument to be sent to a running simulation model
     • generic : VHDL generic to be set at elaboration-time
     • plusarg : Verilog plusarg to be set at run-time
     • vlogdefine : Verilog define to be set at compile-time
     • vlogparam : Verilog toplevel parameter to be set at compile-time
14                                                                                          Chapter 3. EDA Metadata
                                                                            Edalize Documentation, Release 0.1.3
 Field     Type            Description
 Name
 datatype String           Required Data type of the parameter. Valid values are bool, file, int, str. file is similar to
                           str, but the value is treated as a path and converted to an absolute path
 default   Specified       Default value to use if user does not provide a value during the configure or run stages
           by datatype
 de-       String          User-friendly description of the parameter
 scrip-
 tion
 param-    String          Required Type of parameter. Valid values are cmdlinearg, generic, plusarg, vlogparam,
 type                      vlogdefine
3.4 Tool options
Tool options are used to set tool-specific options. Each key corresponds to a specific EDA tool.
                             Field Name       Type      Description
                             ghdl             String    Options for GHDL
                             icarus           String    Options for Icarus Verilog
                             icestorm         String    Options for Project IceStorm
                             ise              String    Options for Xilinx ISE
                             isim             String    Options for Xilinx iSim
                             modelsim         String    Options for Mentor ModelSim
                             openfpga         String    Options for OpenFPGA OpenFPGA
                             quartus          String    Options for Intel Quartus
                             rivierapro       String    Options for Aldec RivieraPro
                             spyglass         String    Options for Synposys SpyGlass
                             trellis          String    Options for Project Trellis
                             vcs              String    Options for Synopsys VCS
                             verilator        String    Options for Verilator
                             vivado           String    Options for Xilinx Vivado
                             vunit            String    Options for VUnit
                             xcelium          String    Options for Cadence Xcelium
                             xsim             String    Options for Xilinx XSim
3.4. Tool options                                                                                                       15
Edalize Documentation, Release 0.1.3
3.4.1 ghdl
          Field Name         Type              Description
          analyze_options    List of String    Extra options used for the GHDL analyze stage (ghdl -a)
          run_options        List of String    Extra options used when running GHDL simulations (ghdl -r)
3.4.2 icarus
         Field Name         Type              Description
         iverilog_options   List of String    Extra options for compilation with iverilog
         timescale          String            Default (Verilog) timescale to use before user sets one explicitly
3.4.3 icestorm
   Field Name             Type               Description
   arachne_pnr_options    List of String     Options for ArachnePNR Place & Route
   nextpnr_options        List of String     Options for NextPNR Place & Route
   pnr                    String             Select P&R tool. Valid values are arachne and next. Default is arachne
   yosys_synth_options    List of String     Options for Yosys Synthesis
3.4.4 ise
        Field Name             Type      Description
        family                 String    FPGA family e.g. spartan6, virtex5
        device                 String    Device identifier e.g. xc6slx45
        package                String    Device package e.g. csg324
        speed                  String    Device speed grade e.g. -2
        board_device_index     String    Specifies the FPGA’s device number in the JTAG chain, starting at 1.
3.4.5 isim
                Field Name      Type              Description
                fuse_options    List of String    Extra options for compilation with fuse
                isim_options    List of String    Extra options for running compiled simulation model
16                                                                                       Chapter 3. EDA Metadata
                                                                          Edalize Documentation, Release 0.1.3
3.4.6 modelsim
                Field Name        Type           Description
                vlog_options      List of String Extra options for each Verilog file compiled with vlog
                vsim_options      List of String Extra options for running the simulation with vsim
3.4.7 openfpga
The following environment variables need to be sourced before running any simulation on SOFA (Skywater Open-
source FPGA) IPs:
     • OPENFPGA_PATH: directory of the OpenFPGA framework Github repo (documentation)
     • SOFA_PATH: directory of the SOFA eFPGA IPs Github repo
  Field         Type          Description
  Name
  arch          String        FPGA architecture e.g. sofa-hd, sofa-chd, sofa-qlhd and sofa-plus-hd
  task_options List      of   Extra options for running the task simulation with OpenFPGA framework (see the
                String        OpenFPGA documentation)
3.4.8 quartus
  Field     Type Description
  Name
  board_device_index
            List     Specifies the FPGA’s device number in the JTAG chain. The device index specifies the device
            of       where the flash programmer looks for the Nios® II JTAG debug module. JTAG devices are num-
            String bered relative to the JTAG chain, starting at 1. Use the tool jtagconfig to determine the index.
  family String FPGA family e.g. Cyclone IV E
  device String Device identifier. e.g. EP4CE55F23C8 or 5CSXFC6D6F31C8ES
  quar-     List     Extra command-line options for Quartus
  tus_options
            of
            String
  dse_options
            List     Command-line options for Design Space Explorer
            of
            String
3.4.9 rivierapro
                Field Name        Type           Description
                vlog_options      List of String Extra options for each Verilog file compiled with vlog
                vsim_options      List of String Extra options for running the simulation with vsim
3.4. Tool options                                                                                                   17
Edalize Documentation, Release 0.1.3
3.4.10 spyglass
 Field      Type     Default                Description
 Name
 method-    String   GuideWare/             Selected methodology
 ology               latest/block/
                     rtl_handoff
 goals      List     [ 'lint/               Selected goals
            of       lint_rtl'
            String   ]
 rule_parameters
            List     []                     Options passed with set_option to Spyglass, e.g. “handlememory yes”
            of                              to prevent error SYNTH_5273 on generic RAM descriptions
            String
 spy-       List     []                     Rule parameters passed with set_parameter to Spyglass, e.g.
 glass_parameters
            of                              handle_static_caselabels yes to allow localparam to be used in
            String                          case labels (e.g. in state machines)
3.4.11 trellis
                   Field Name               Type              Description
                   nextpnr_options          List of String    Options for NextPNR Place & Route
                   yosys_synth_options      List of String    Options for Yosys Synthesis
3.4.12 vcs
                     Field Name      Type              Description
                     vcs_options     List of String    Compile time options passed to vcs
                     run_options     List of String    Runtime options passed to the simulation
3.4.13 verilator
 Field        Type       Description
 Name
 cli_parser   String     If cli_parser is set to managed, Edalize will parse all command-line options. Otherwise,
                         they are sent directly to the compiled simulation model.
 libs         List of    Extra options to be passed as -LDFLAGS when linking the C++ testbench
              String
 mode         String     cc runs Verilator in regular C++ mode. sc runs in SystemC mode. lint-only only performs
                         linting on the Verilog code
 verila-      List of    Extra options to be passed when verilating model
 tor_options String
18                                                                                     Chapter 3. EDA Metadata
                                                                           Edalize Documentation, Release 0.1.3
3.4.14 vivado
         Field Name      Type       Description
         part            String     Device identifier. e.g. xc7a35tcsg324-1
         jobs            Integer    Number of jobs. Useful for parallelizing OOC (Out Of Context) syntheses.
3.4.15 vunit
  Field Type        Description
  Name
  vu-      List     Extra options for the VUnit test runner
  nit_options
           of
           String
  add_libraries
           List     A list of framework libraries to add. Allowed values include “array_util”, “com”, “json4hdl”,
           of       “osvvm”, “random”, “verification_components”
           String
  vu-      String   Name of the Python file exporting a VUnitRunner class (must derive from edalize.
  nit_runner        vunit_hooks.VUnitHooks) that is used to configure and execute test. This allows very cus-
                    tomized test control via VUnit’s Python-interfaces.
In case a more advanced VUnit configuration or execution of the testbench is necessary, the option vunit_runner
can be used to specify the filename of a Python script which can hook into the construction, parametrization, and
execution of the test runner. For this to work, the Python script must export a class VUnitRunner(vunit_hooks.
VUnitHooks) which derives from (and optionally overrides) the behavior of vunit_hooks.VUnitHooks.
from   edalize.vunit_hooks import VUnitHooks
from   vunit import VUnit
from   vunit.ui import Library, Results
from   typing import Mapping, Collection
class VUnitRunner(VUnitHooks):
      """Example of custom VUnit instrumentation."""
      def create(self) -> VUnit:
           """Customized creation of the test runner"""
           vu = VUnit.from_argv()
           vu.enable_check_preprocessing()
           return vu
      def handle_library(self, logical_name: str, vu_lib: Library):
           """Override this to customize each library, e.g. with additional simulator␣
 ˓→options.
           This hook will be invoked for each library, after all source files have been␣
 ˓→added.
           :param logical_name: The logical name of the library
           :param vu_lib: The vunit.ui.Library instance, configured with all sources of␣
 ˓→this `logical_name`
           """
           # e.g. you can access and customize test-bench entities of this library:
                                                                                                (continues on next page)
3.4. Tool options                                                                                                    19
Edalize Documentation, Release 0.1.3
                                                                                               (continued from previous page)
          if logical_name == "my_tb_library_name":
               entity = vu_lib.entity("my_toplevel_tb")
               entity.set_generic("message", "Test message")
               entity.add_config(name="TestConfig1",
                                      generics=dict(CLK_FREQ=10000000))
               entity.add_config(name="TestConfig2",
                                      generics=dict(CLK_FREQ=54687500))
    def main(self, vu: VUnit):
          """Override this for final parametrization of the :class:`VUnit` instance (after␣
˓→all libraries have been added),
          or for custom invocation of VUnit
          """
          def post_run_handler(results: Results):
               results.merge_coverage(file_name="coverage_data")
          vu.main(post_run=post_run_handler)
3.4.16 xcelium
              Field Name           Type              Description
              xmvlog_options       List of String    Extra options for compilation with xmvlog
              xmvhdl_options       List of String    Extra options for compilation with xmvhdl
              xmsim_options        List of String    Extra options for running simulation with with xsim
              xrun_options         List of String    Extra options for invocation with with xrun
3.4.17 xsim
               Field Name         Type              Description
               xelab_options      List of String    Extra options for compilation with xelab
               xsim_options       List of String    Extra options for running simulation with with xsim
3.4.18 toplevel
Name of the top level module/entity
3.5 VPI
Each Vpi object contains information on how to build the corresponding VPI library
                             Field Name        Type             Description
                             include_dirs      List of String   Extra include directories
                             libs              List of String   Extra libraries
                             name              String           Name of VPI library
                             src_files         List of String   Source files for VPI library
20                                                                                         Chapter 3. EDA Metadata
                                                                                       CHAPTER
                                                                                        FOUR
                                                                             EDALIZE PACKAGE
4.1 Submodules
4.2 edalize.edatool module
class edalize.edatool.Edatool(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: object
     build()
     build_main(target=None)
     build_post()
     build_pre()
     configure(args=[])
     configure_main()
     configure_post()
     configure_pre()
     classmethod get_doc(api_ver)
     parse_args(args, paramtypes)
     render_template(template_file, target_file, template_vars={})
          Render a Jinja2 template for the backend.
          The template file is expected in the directory templates/BACKEND_NAME.
     run(args={})
     run_main()
     run_post()
     run_pre(args=None)
     set_default_target(target)
                                                                                            21
Edalize Documentation, Release 0.1.3
class edalize.edatool.FileAction(option_strings, dest, nargs=None, const=None, default=None,
                                           type=None, choices=None, required=False, help=None, metavar=None)
     Bases: Action
edalize.edatool.get_edatool(name)
edalize.edatool.get_edatools()
edalize.edatool.jinja_filter_param_value_str(value, str_quote_style='', bool_is_str=False)
     Convert a parameter value to string suitable to be passed to an EDA tool.
     Rules:
        • Booleans are represented as 0/1 or “true”/”false” depending on the bool_is_str argument
        • Strings are either passed through or enclosed in the characters specified in str_quote_style (e.g. ‘”’ or ‘"’)
        • Everything else (including int, float, etc.) are converted using the str() function.
edalize.edatool.subprocess_run_3_9(*popenargs, input=None, capture_output=False, timeout=None,
                                              check=False, **kwargs)
edalize.edatool.walk_tool_packages()
4.3 edalize.ghdl module
class edalize.ghdl.Ghdl(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['vlogparam', 'generic']
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
4.4 edalize.icarus module
class edalize.icarus.Icarus(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['plusarg', 'vlogdefine', 'vlogparam']
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
22                                                                                     Chapter 4. edalize package
                                                           Edalize Documentation, Release 0.1.3
4.5 edalize.icestorm module
class edalize.icestorm.Icestorm(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['vlogdefine', 'vlogparam']
     build_post()
     build_pre()
     configure_main()
     classmethod get_doc(api_ver)
4.6 edalize.ise module
class edalize.ise.Ise(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     MAKEFILE_TEMPLATE = '#Auto generated by Edalize\ninclude config.mk\n\nall:
     $(TOPLEVEL).bit\n\n$(TOPLEVEL).bit: $(NAME)_run.tcl
     $(NAME).xise\n\t$(EDALIZE_LAUNCHER) xtclsh $^\n\n$(NAME).xise:
     $(NAME).tcl\n\t$(EDALIZE_LAUNCHER) xtclsh $<\n'
     PGM_FILE_TEMPLATE = '\n# Batch script for programming the device using a JTAG
     interface.\n# Used with:\n# $ impact -batch {pgm_file}\n\nsetMode -bscan\nsetCable
     -port auto\nidentify\nassignFile -p {board_device_index} -file {bit_file}\nprogram
     -p {board_device_index}\nsaveCDF -file {cdf_file}\nquit\n'
     TCL_FILE_TEMPLATE = '#Auto generated by Edalize\nproc project_new_exist_ok name {{\n
     if {{ [catch {{ project new $name }}] }} {{\n project open $name\n }}\n}}\n\nproc
     xfile_add_exist_ok name {{\n if {{ [catch {{ xfile get [file tail $name] name }}] }}
     {{\n xfile add $name\n }}\n}}\n\nproject_new_exist_ok {design}\nproject set family
     "{family}"\nproject set device {device}\nproject set package {package}\nproject set
     speed {speed}\nproject set "Generate Detailed MAP Report" true\n'
     TCL_RUN_FILE_TEMPLATE = '#Auto generated by Edalize\nproject open $::argv\nprocess
     run "Generate Programming File"\n'
     argtypes = ['vlogdefine', 'vlogparam', 'generic']
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
4.5. edalize.icestorm module                                                                 23
Edalize Documentation, Release 0.1.3
4.7 edalize.isim module
class edalize.isim.Isim(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     CONFIG_MK_TEMPLATE = '#Auto generated by Edalize\nTARGET = {target}\nTOPLEVEL =
     {toplevel}\n\nVLOG_DEFINES = {vlog_defines}\nVLOG_INCLUDES =
     {vlog_includes}\nVLOG_PARAMS = {vlog_params}\n\nFUSE_OPTIONS
     =\t{fuse_options}\nISIM_OPTIONS =\t{isim_options}\n\nEXTRA_OPTIONS ?=
     {extra_options}\n'
     MAKEFILE_TEMPLATE = '#Auto generated by Edalize\ninclude config.mk\n\nall:
     $(TARGET)\n\n$(TARGET):\n\tfuse $(TOPLEVEL) -prj $(TARGET).prj -o $(TARGET)
     $(VLOG_DEFINES) $(VLOG_INCLUDES) $(VLOG_PARAMS) $(FUSE_OPTIONS)\n\nrun:
     $(TARGET)\n\t./$(TARGET) -tclbatch run_$(TARGET).tcl $(ISIM_OPTIONS)
     $(EXTRA_OPTIONS)\n\nrun-gui: $(TARGET)\n\t./$(TARGET) -gui $(ISIM_OPTIONS)
     $(EXTRA_OPTIONS)\n'
     RUN_TCL_TEMPLATE = '#Auto generated by Edalize\nwave log -r /\nrun all\nquit\n'
     argtypes = ['plusarg', 'vlogdefine', 'vlogparam']
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
4.8 edalize.modelsim module
class edalize.modelsim.Modelsim(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['plusarg', 'vlogdefine', 'vlogparam', 'generic']
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
4.9 edalize.openfpga module
class edalize.openfpga.Openfpga(edam=None, work_root=None, eda_api=None, verbose=False)
     Bases: Edatool
     This calls the parent constructor, but also identifies whether the current system has correctly set the following
     environment variables:
        • OPENFPGA_PATH: directory of the OpenFPGA framework, available here: https://github.com/lnis-uofu/
          OpenFPGA
        • SOFA_PATH: directory of the SOFA eFPGA IPs, available here: https://github.com/lnis-uofu/SOFA
24                                                                                   Chapter 4. edalize package
                                                                           Edalize Documentation, Release 0.1.3
     argtypes = ['plusarg', 'vlogdefine', 'vlogparam']
     build_main()
     configure_main()
           Configuration is the first phase of the build.
           This writes an OpenFPGA task file for SOFA/SOFA+ architectures, which will generate the according
           OpenFPGA flow. It first collects all verilog sources, top_module and then writes them into the task file.
           Note: OpenFPGA flow may uses Yosys/VPR backend for Synthesis and P&R, respectively.
     classmethod get_doc(api_ver)
     run_main()
           Run the FPGA simulation.
edalize.openfpga.logger = <Logger edalize.openfpga (WARNING)>
     OpenFPGA Flow Backend.
     A core (usually the system core) can add the following files:
         • Benchmark RTL sources (Yosys supports only Verilog file type) and module name
         • The target FPGA architecture name, made with OpenFPGA fabric flow (SOFA,. . . )
         • Source the required environment variables: OPENFPGA_PATH, SOFA_PATH
         • Optional parameters: task options (’–debug’, . . . )
4.10 edalize.quartus module
class edalize.quartus.Quartus(edam=None, work_root=None, eda_api=None, verbose=False)
     Bases: Edatool
     Initial setup of the class.
     This calls the parent constructor, but also identifies whether the current system is using a Standard or Pro edition
     of Quartus.
     argtypes = ['vlogdefine', 'vlogparam', 'generic']
     build_main()
     configure_main()
           Configuration is the first phase of the build.
           This writes the project TCL files and Makefile. It first collects all sources, IPs and constraints and then
           writes them to the TCL file along with the build steps.
     file_type(f )
     classmethod get_doc(api_ver)
     isPro = False
     makefile_template = {False:             'quartus-std-makefile.j2', True:
     'quartus-pro-makefile.j2'}
4.10. edalize.quartus module                                                                                           25
Edalize Documentation, Release 0.1.3
     qsys_file_filter(f )
     run_main()
          Program the FPGA.
     src_file_filter(f )
4.11 edalize.rivierapro module
class edalize.rivierapro.Rivierapro(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['plusarg', 'vlogdefine', 'vlogparam']
     build_main()
     build_pre()
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
4.12 edalize.symbiyosys module
class edalize.symbiyosys.Symbiyosys(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['vlogdefine', 'vlogparam']
     build_main()
     configure_main()
     static get_doc(api_ver)
     run_main()
     tool_options = {'lists':   {'tasknames':  'String'}}
4.13 edalize.spyglass module
class edalize.spyglass.Spyglass(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['vlogdefine', 'vlogparam']
26                                                                  Chapter 4. edalize package
                                                                        Edalize Documentation, Release 0.1.3
     configure_main()
          Configuration is the first phase of the build.
          This writes the project TCL files and Makefile. It first collects all sources, IPs and constraints and then
          writes them to the TCL file along with the build steps.
     src_file_filter(f )
     tool_options = {'lists': {'goals': 'String', 'rule_parameters': 'String',
     'spyglass_options': 'String'}, 'members': {'methodology': 'String'}}
     tool_options_defaults = {'goals': ['lint/lint_rtl'], 'methodology':
     'GuideWare/latest/block/rtl_handoff', 'rule_parameters': [], 'spyglass_options':
     []}
4.14 edalize.trellis module
class edalize.trellis.Trellis(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['vlogdefine', 'vlogparam']
     configure_main()
     classmethod get_doc(api_ver)
4.15 edalize.vcs module
class edalize.vcs.Vcs(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['plusarg', 'vlogdefine', 'vlogparam']
     configure_main()
     run_main()
     tool_options = {'lists':           {'run_options':       'String', 'vcs_options':           'String'}}
4.16 edalize.verilator module
class edalize.verilator.Verilator(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['cmdlinearg', 'plusarg', 'vlogdefine', 'vlogparam']
     build_main()
     check_managed_parser()
     configure_main()
4.14. edalize.trellis module                                                                                       27
Edalize Documentation, Release 0.1.3
     classmethod get_doc(api_ver)
     run_main()
4.17 edalize.vivado module
class edalize.vivado.Vivado(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     Vivado Backend.
     A core (usually the system core) can add the following files:
        • Standard design sources
        • Constraints: Supply xdc files with file_type=xdc or unmanaged constraints with file_type SDC
        • IP: Supply the IP core xci file with file_type=xci and other files (like .prj) as file_type=user
     argtypes = ['vlogdefine', 'vlogparam', 'generic']
     build_main()
     build_post()
     build_pre()
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
          Program the FPGA.
          For programming the FPGA a vivado tcl script is written that searches for the correct FPGA board and then
          downloads the bitstream. The tcl script is then executed in Vivado’s batch mode.
4.18 edalize.vunit module
class edalize.vunit.Vunit(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     argtypes = ['cmdlinearg']
     build_main()
     configure_main()
     classmethod get_doc(api_ver)
     get_vunit_runner_path(src_files)
     run_main()
     src_file_filter(f )
28                                                                                      Chapter 4. edalize package
                                                                          Edalize Documentation, Release 0.1.3
      src_file_vhdl_standard_filter(f )
      testrunner = 'run.py'
      testrunner_template = 'run.py.j2'
4.19 edalize.vunit_hooks module
This module exports VUnitHooks which can be used to implement advanced VUnit test cases.
class edalize.vunit_hooks.VUnitHooks
      Bases: object
      Derive the VUnitRunner instance from this class and override its member functions if necessary.
      create()
           Override this function to specify custom instantiation of VUnit.
                Return type
                    VUnit
      handle_library(logical_name, vu_lib)
           Override this to customize each library, e.g. with additional simulator options.
      main(vu)
           Override this for final parametrization of the VUnit instance, or for custom invocation of VUnit.
class edalize.vunit_hooks.VUnitRunner
      Bases: VUnitHooks
      The default runner which will be used if no vunit_runner.py is specified.
4.20 edalize.xcelium module
class edalize.xcelium.Xcelium(edam=None, work_root=None, eda_api=None, verbose=True)
      Bases: Edatool
      argtypes = ['plusarg', 'vlogdefine', 'vlogparam', 'generic']
      configure_main()
      classmethod get_doc(api_ver)
      run_main()
4.19. edalize.vunit_hooks module                                                                             29
Edalize Documentation, Release 0.1.3
4.21 edalize.xsim module
class edalize.xsim.Xsim(edam=None, work_root=None, eda_api=None, verbose=True)
     Bases: Edatool
     CONFIG_MK_TEMPLATE = '#Auto generated by Edalize\nTARGET = {target}\nTOPLEVEL =
     {toplevel}\n\nVLOG_DEFINES = {vlog_defines}\nVLOG_INCLUDES =
     {vlog_includes}\nGEN_PARAMS = {gen_params}\n\nXELAB_OPTIONS
     =\t{xelab_options}\nXSIM_OPTIONS = {xsim_options}\n'
     MAKEFILE_TEMPLATE = '#Auto generated by Edalize\ninclude config.mk\n\nall:
     xsim.dir/$(TARGET)/xsimk\n\nxsim.dir/$(TARGET)/xsimk:\n\txelab $(TOPLEVEL) -prj
     $(TARGET).prj -snapshot $(TARGET) $(VLOG_DEFINES) $(VLOG_INCLUDES) $(GEN_PARAMS)
     $(XELAB_OPTIONS)\n\nrun: xsim.dir/$(TARGET)/xsimk\n\txsim -R $(XSIM_OPTIONS)
     $(TARGET) $(EXTRA_OPTIONS)\n\nrun-gui: xsim.dir/$(TARGET)/xsimk\n\txsim --gui
     $(XSIM_OPTIONS) $(TARGET) $(EXTRA_OPTIONS)\n'
     argtypes = ['plusarg', 'vlogdefine', 'vlogparam', 'generic']
     configure_main()
     classmethod get_doc(api_ver)
     run_main()
4.22 edalize.reporting module
4.23 edalize.vivado_reporting module
4.24 edalize.quartus_reporting module
4.25 edalize.ise_reporting module
4.26 Module contents
30                                                                   Chapter 4. edalize package
CHAPTER
   FIVE
 INDEX
      31
Edalize Documentation, Release 0.1.3
32                                   Chapter 5. Index
      CHAPTER
          SIX
SEARCH PAGE
            33
Edalize Documentation, Release 0.1.3
34                                   Chapter 6. Search Page
                        PYTHON MODULE INDEX
e
edalize, 30
edalize.edatool, 21
edalize.ghdl, 22
edalize.icarus, 22
edalize.icestorm, 23
edalize.ise, 23
edalize.isim, 24
edalize.modelsim, 24
edalize.openfpga, 24
edalize.quartus, 25
edalize.rivierapro, 26
edalize.spyglass, 26
edalize.symbiyosys, 26
edalize.trellis, 27
edalize.vcs, 27
edalize.verilator, 27
edalize.vivado, 28
edalize.vunit, 28
edalize.vunit_hooks, 29
edalize.xcelium, 29
edalize.xsim, 30
                                          35
Edalize Documentation, Release 0.1.3
36                                   Python Module Index
                                                                                                     INDEX
A                                                              method), 27
argtypes (edalize.ghdl.Ghdl attribute), 22             CONFIG_MK_TEMPLATE (edalize.isim.Isim attribute), 24
argtypes (edalize.icarus.Icarus attribute), 22         CONFIG_MK_TEMPLATE (edalize.xsim.Xsim attribute), 30
argtypes (edalize.icestorm.Icestorm attribute), 23     configure() (edalize.edatool.Edatool method), 21
argtypes (edalize.ise.Ise attribute), 23               configure_main() (edalize.edatool.Edatool method),
argtypes (edalize.isim.Isim attribute), 24                     21
argtypes (edalize.modelsim.Modelsim attribute), 24     configure_main() (edalize.ghdl.Ghdl method), 22
argtypes (edalize.openfpga.Openfpga attribute), 24     configure_main() (edalize.icarus.Icarus method), 22
argtypes (edalize.quartus.Quartus attribute), 25       configure_main() (edalize.icestorm.Icestorm method),
argtypes (edalize.rivierapro.Rivierapro attribute), 26         23
argtypes (edalize.spyglass.Spyglass attribute), 26     configure_main() (edalize.ise.Ise method), 23
argtypes (edalize.symbiyosys.Symbiyosys attribute), 26 configure_main() (edalize.isim.Isim method), 24
argtypes (edalize.trellis.Trellis attribute), 27       configure_main()            (edalize.modelsim.Modelsim
argtypes (edalize.vcs.Vcs attribute), 27                       method), 24
argtypes (edalize.verilator.Verilator attribute), 27   configure_main()             (edalize.openfpga.Openfpga
argtypes (edalize.vivado.Vivado attribute), 28                 method), 25
argtypes (edalize.vunit.Vunit attribute), 28           configure_main() (edalize.quartus.Quartus method),
argtypes (edalize.xcelium.Xcelium attribute), 29               25
argtypes (edalize.xsim.Xsim attribute), 30             configure_main()          (edalize.rivierapro.Rivierapro
                                                               method), 26
B                                                      configure_main() (edalize.spyglass.Spyglass method),
                                                               26
build() (edalize.edatool.Edatool method), 21
                                                       configure_main()        (edalize.symbiyosys.Symbiyosys
build_main() (edalize.edatool.Edatool method), 21
                                                               method), 26
build_main() (edalize.openfpga.Openfpga method), 25
                                                       configure_main() (edalize.trellis.Trellis method), 27
build_main() (edalize.quartus.Quartus method), 25
                                                       configure_main() (edalize.vcs.Vcs method), 27
build_main() (edalize.rivierapro.Rivierapro method),
                                                       configure_main() (edalize.verilator.Verilator method),
        26
                                                               27
build_main() (edalize.symbiyosys.Symbiyosys method),
                                                       configure_main() (edalize.vivado.Vivado method), 28
        26
                                                       configure_main() (edalize.vunit.Vunit method), 28
build_main() (edalize.verilator.Verilator method), 27
                                                       configure_main() (edalize.xcelium.Xcelium method),
build_main() (edalize.vivado.Vivado method), 28
                                                               29
build_main() (edalize.vunit.Vunit method), 28
                                                       configure_main() (edalize.xsim.Xsim method), 30
build_post() (edalize.edatool.Edatool method), 21
                                                       configure_post() (edalize.edatool.Edatool method),
build_post() (edalize.icestorm.Icestorm method), 23
                                                               21
build_post() (edalize.vivado.Vivado method), 28
                                                       configure_pre() (edalize.edatool.Edatool method), 21
build_pre() (edalize.edatool.Edatool method), 21
                                                       create() (edalize.vunit_hooks.VUnitHooks method), 29
build_pre() (edalize.icestorm.Icestorm method), 23
build_pre() (edalize.rivierapro.Rivierapro method), 26
build_pre() (edalize.vivado.Vivado method), 28
                                                       E
                                                       edalize
C                                                          module, 30
                                                       edalize.edatool
check_managed_parser() (edalize.verilator.Verilator
                                                                                                             37
Edalize Documentation, Release 0.1.3
    module, 21                                         get_doc() (edalize.isim.Isim class method), 24
edalize.ghdl                                           get_doc() (edalize.modelsim.Modelsim class method),
    module, 22                                                   24
edalize.icarus                                         get_doc() (edalize.openfpga.Openfpga class method),
    module, 22                                                   25
edalize.icestorm                                       get_doc() (edalize.quartus.Quartus class method), 25
    module, 23                                         get_doc() (edalize.rivierapro.Rivierapro class method),
edalize.ise                                                      26
    module, 23                                         get_doc()       (edalize.symbiyosys.Symbiyosys        static
edalize.isim                                                     method), 26
    module, 24                                         get_doc() (edalize.trellis.Trellis class method), 27
edalize.modelsim                                       get_doc() (edalize.verilator.Verilator class method), 27
    module, 24                                         get_doc() (edalize.vivado.Vivado class method), 28
edalize.openfpga                                       get_doc() (edalize.vunit.Vunit class method), 28
    module, 24                                         get_doc() (edalize.xcelium.Xcelium class method), 29
edalize.quartus                                        get_doc() (edalize.xsim.Xsim class method), 30
    module, 25                                         get_edatool() (in module edalize.edatool), 22
edalize.rivierapro                                     get_edatools() (in module edalize.edatool), 22
    module, 26                                         get_vunit_runner_path()                (edalize.vunit.Vunit
edalize.spyglass                                                 method), 28
    module, 26                                         Ghdl (class in edalize.ghdl), 22
edalize.symbiyosys                                     GOLDEN_RUN, 6
    module, 26
edalize.trellis                                        H
    module, 27                                         handle_library() (edalize.vunit_hooks.VUnitHooks
edalize.vcs                                                      method), 29
    module, 27
edalize.verilator                                      I
    module, 27                                         Icarus (class in edalize.icarus), 22
edalize.vivado                                         Icestorm (class in edalize.icestorm), 23
    module, 28                                         Ise (class in edalize.ise), 23
edalize.vunit                                          Isim (class in edalize.isim), 24
    module, 28                                         isPro (edalize.quartus.Quartus attribute), 25
edalize.vunit_hooks
    module, 29                                         J
edalize.xcelium
                                                       jinja_filter_param_value_str() (in module edal-
    module, 29
                                                                 ize.edatool), 22
edalize.xsim
    module, 30
Edatool (class in edalize.edatool), 21
                                                       L
environment variable                                   logger (in module edalize.openfpga), 25
    GOLDEN_RUN, 6
    PATH, 6                                            M
                                                       main() (edalize.vunit_hooks.VUnitHooks method), 29
F                                                      MAKEFILE_TEMPLATE (edalize.ise.Ise attribute), 23
file_type() (edalize.quartus.Quartus method), 25       MAKEFILE_TEMPLATE (edalize.isim.Isim attribute), 24
FileAction (class in edalize.edatool), 21              makefile_template (edalize.quartus.Quartus at-
                                                                 tribute), 25
G                                                      MAKEFILE_TEMPLATE (edalize.xsim.Xsim attribute), 30
get_doc() (edalize.edatool.Edatool class method), 21   Modelsim (class in edalize.modelsim), 24
get_doc() (edalize.ghdl.Ghdl class method), 22         module
get_doc() (edalize.icarus.Icarus class method), 22          edalize, 30
get_doc() (edalize.icestorm.Icestorm class method), 23      edalize.edatool, 21
get_doc() (edalize.ise.Ise class method), 23                edalize.ghdl, 22
38                                                                                                         Index
                                                                     Edalize Documentation, Release 0.1.3
    edalize.icarus, 22                                  run_main() (edalize.xsim.Xsim method), 30
    edalize.icestorm, 23                                run_post() (edalize.edatool.Edatool method), 21
    edalize.ise, 23                                     run_pre() (edalize.edatool.Edatool method), 21
    edalize.isim, 24                                    RUN_TCL_TEMPLATE (edalize.isim.Isim attribute), 24
    edalize.modelsim, 24
    edalize.openfpga, 24                                S
    edalize.quartus, 25                                 set_default_target()              (edalize.edatool.Edatool
    edalize.rivierapro, 26                                        method), 21
    edalize.spyglass, 26                                Spyglass (class in edalize.spyglass), 26
    edalize.symbiyosys, 26                              src_file_filter() (edalize.quartus.Quartus method),
    edalize.trellis, 27                                           26
    edalize.vcs, 27                                     src_file_filter()               (edalize.spyglass.Spyglass
    edalize.verilator, 27                                         method), 27
    edalize.vivado, 28                                  src_file_filter() (edalize.vunit.Vunit method), 28
    edalize.vunit, 28                                   src_file_vhdl_standard_filter()                     (edal-
    edalize.vunit_hooks, 29                                       ize.vunit.Vunit method), 28
    edalize.xcelium, 29                                 subprocess_run_3_9() (in module edalize.edatool), 22
    edalize.xsim, 30                                    Symbiyosys (class in edalize.symbiyosys), 26
O                                                       T
Openfpga (class in edalize.openfpga), 24                TCL_FILE_TEMPLATE (edalize.ise.Ise attribute), 23
                                                        TCL_RUN_FILE_TEMPLATE (edalize.ise.Ise attribute), 23
P                                                       testrunner (edalize.vunit.Vunit attribute), 29
parse_args() (edalize.edatool.Edatool method), 21       testrunner_template (edalize.vunit.Vunit attribute),
PATH, 6                                                           29
PGM_FILE_TEMPLATE (edalize.ise.Ise attribute), 23       tool_options (edalize.spyglass.Spyglass attribute), 27
                                                        tool_options (edalize.symbiyosys.Symbiyosys at-
Q                                                                 tribute), 26
qsys_file_filter()             (edalize.quartus.Quartus tool_options (edalize.vcs.Vcs attribute), 27
         method), 25                                    tool_options_defaults (edalize.spyglass.Spyglass at-
Quartus (class in edalize.quartus), 25                            tribute), 27
                                                        Trellis (class in edalize.trellis), 27
R
render_template() (edalize.edatool.Edatool method),
                                                        V
         21                                             Vcs (class in edalize.vcs), 27
Rivierapro (class in edalize.rivierapro), 26            Verilator (class in edalize.verilator), 27
run() (edalize.edatool.Edatool method), 21              Vivado (class in edalize.vivado), 28
run_main() (edalize.edatool.Edatool method), 21         Vunit (class in edalize.vunit), 28
run_main() (edalize.ghdl.Ghdl method), 22               VUnitHooks (class in edalize.vunit_hooks), 29
run_main() (edalize.icarus.Icarus method), 22           VUnitRunner (class in edalize.vunit_hooks), 29
run_main() (edalize.ise.Ise method), 23
run_main() (edalize.isim.Isim method), 24               W
run_main() (edalize.modelsim.Modelsim method), 24       walk_tool_packages() (in module edalize.edatool), 22
run_main() (edalize.openfpga.Openfpga method), 25
run_main() (edalize.quartus.Quartus method), 26         X
run_main() (edalize.rivierapro.Rivierapro method), 26   Xcelium (class in edalize.xcelium), 29
run_main() (edalize.symbiyosys.Symbiyosys method),      Xsim (class in edalize.xsim), 30
         26
run_main() (edalize.vcs.Vcs method), 27
run_main() (edalize.verilator.Verilator method), 28
run_main() (edalize.vivado.Vivado method), 28
run_main() (edalize.vunit.Vunit method), 28
run_main() (edalize.xcelium.Xcelium method), 29
Index                                                                                                          39
