Netlist Paths

Netlist Paths is a library and command-line tool for querying a Verilog netlist. It reads an XML representation of a design’s netlist, produced by Verilator, and provides facilities for inspecting variables and their type and dependency information. The library is written in C++ and has a Python interface allowing it to be integrated easily into scripts.

Compared with standard front-end EDA tools such as Synopsys Verdi and Spyglass, Netlist Paths is oriented towards command-line use for exploration of a design (rather than with a GUI), and for integration with Python infrastructure (rather than TCL) to build tools for analysing or debugging a design.

Indices and tables

Build and installation

The following dependencies must be installed:

  • C++ compiler supporting C++14

  • CMake (minimum 3.12.0)

  • Boost (minimum 1.65.0)

  • Python 3.8

  • Make

  • Autoconf

  • Flex

  • Bison

  • Doxygen (only if building the documentation)

To build and install netlist paths, configure the build system with CMake, then run Make:

➜ git submodule update --init --recursive
...
➜ mkdir Release
➜ cd Release
➜ cmake .. -DCMAKE_BUILD_TYPE=Release
...
➜ make -j8 install
...

Optionally, run the unit tests:

➜ ctest
...

To build the documentation add -DNETLIST_PATHS_BUILD_DOCS=1 to the cmake command, and before running the cmake step, install the dependencies in a virtualenv:

cd Release
➜ virtualenv -p python3 env
...
➜ source env/bin/activate
➜ pip install -r ../docs/requirements.txt

Once the build and install steps have completed, set PATH and PYTHONPATH appropriately to the bin and lib directories of the installation to make the command-line tools and Python modules accessible.

Getting started

Command-line tool

The easiest way to use Netlist Paths is with the netlist-paths command line tool, which provides ways to access the library’s functionalities. For example (assuming PATH includes your installation directory), to compile and view a list of named objects in the FSM example module:

➜ netlist-paths --compile examples/fsm.sv --dump-names
Name           Type DType        Width Direction Location
-------------- ---- ------------ ----- --------- ------------------
fsm.i_clk      VAR  logic        1     INPUT     examples/fsm.sv:3
fsm.i_finish   VAR  logic        1     INPUT     examples/fsm.sv:6
fsm.i_rst      VAR  logic        1     INPUT     examples/fsm.sv:4
fsm.i_start    VAR  logic        1     INPUT     examples/fsm.sv:5
fsm.i_wait     VAR  logic        1     INPUT     examples/fsm.sv:7
fsm.next_state VAR  packed union 3     NONE      examples/fsm.sv:31
fsm.o_state    VAR  [2:0] logic  3     OUTPUT    examples/fsm.sv:8
fsm.state_q    REG  packed union 3     NONE      examples/fsm.sv:28
i_clk          VAR  logic        1     INPUT     examples/fsm.sv:3
i_finish       VAR  logic        1     INPUT     examples/fsm.sv:6
i_rst          VAR  logic        1     INPUT     examples/fsm.sv:4
i_start        VAR  logic        1     INPUT     examples/fsm.sv:5
i_wait         VAR  logic        1     INPUT     examples/fsm.sv:7
o_state        VAR  [2:0] logic  3     OUTPUT    examples/fsm.sv:8

This output lists each of the variables in the design, their type (variable or register), the Verilog data type, with data type width, the direction of the variable (ports only) and the source location. This list can be filtered by also supplying a pattern (with the --regex flag to enable regular expression matching):

➜ netlist-paths --compile examples/fsm.sv --dump-names state --regex
Name           Type DType        Width Direction Location
-------------- ---- ------------ ----- --------- ------------------
fsm.next_state VAR  packed union 3     NONE      examples/fsm.sv:31
fsm.o_state    VAR  [2:0] logic  3     OUTPUT    examples/fsm.sv:8
fsm.state_q    REG  packed union 3     NONE      examples/fsm.sv:28
o_state        VAR  [2:0] logic  3     OUTPUT    examples/fsm.sv:8

There is similar behaviour with --dump-nets, --dump-ports, --dump-regs to select only net, port or register variable types respectively.

Note that the --compile flag causes Verilator to be run to create the XML netlist, and is useful for compiling simple examples. Execution of Verilator can be seen with verbose output:

➜ netlist-paths --compile examples/fsm.sv --verbose
info: Running ".../bin/np-verilator_bin" +1800-2012ext+.sv --bbox-sys --bbox-unsup
  --xml-only --flatten --error-limit 10000 --xml-output l9pvjzq6 examples/fsm.sv
...

The -I and -D arguments can be used with --compile to add include directories and macro definitions respectively for Verilator, but for more complex invocations, Verilator can just be run separately and the path to the XML output provided to netlist-paths as an argument.

Python module

The functionality of Netlist Paths can be accessed in Python, using the py_netlist_paths module, which is is a wrapper around the C++ library. Full details of the API can be found in Python API reference, and for the C++ library in C++ API reference. As a simple example, the Python Netlist Paths library can be used interactively, first by creating an XML netlist file (and making sure the library install directory is a search path for Python modules:

➜ netlist-paths --compile examples/fsm.sv --output fsm.xml
➜ export PYTHONPATH=/path/to/netlist-paths/install/lib:$PYTHONPATH

A new Netlist object can then be created, specifying the XML file as an argument, and the list of named objects can be retrieved as above using the get_named_vertices() method:

➜ python3
Python 3.9.0 (default, Dec  6 2020, 18:02:34)
[Clang 12.0.0 (clang-1200.0.32.27)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from py_netlist_paths import Netlist
>>> netlist = Netlist('fsm.xml')
>>> for v in netlist.get_reg_vertices():
...     print(v.get_name())
...
fsm.state_q

This can then easily be turned into a script to create a tool that reports registers in a design:

import argparse
import sys
from py_netlist_paths import Netlist

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('netlist_file')
    args = parser.parse_args()
    netlist = np.Netlist(args.netlist_file)
    for register in netlist.get_reg_vertices():
        print('{} {}'.format(register.get_name(), register.get_dtype_str()))

This example tool can be run from the examples directory:

➜ netlist-paths --compile examples/fsm.sv --output fsm.xml
➜ python3 -m examples.list_registers -h
usage: list_registers.py [-h] netlist_file

positional arguments:
  netlist_file

optional arguments:
  -h, --help    show this help message and exit
➜ python3 -m examples.list_registers fsm.xml
fsm.state_q packed union

Contributing

Contributions are welcome, please follow the LLVM coding standards.

C++ API reference

DType

class netlist_paths::DType

Base class for data types.

Subclassed by netlist_paths::ArrayDType, netlist_paths::BasicDType, netlist_paths::EnumDType, netlist_paths::MemberDType, netlist_paths::RefDType, netlist_paths::StructDType, netlist_paths::UnionDType

Public Functions

inline virtual const std::string toString(const std::string suffix = "") const

Return the string representation of the data type.

Parameters

suffix – A suffix to allow unpacked array range specifications to be appended with the inner-most dimension on the LHS and outermost on the RHS.

Returns

A string representation of the data type.

Exception

class Exception : public exception

Base class for netlist_paths exceptions.

Subclassed by netlist_paths::XMLException

class XMLException : public netlist_paths::Exception

An exception from XML elaboration.

Options

class netlist_paths::Options

A class encapsulating options.

Public Functions

inline void setMatchWildcard()

Set matching to use wildcards.

inline void setMatchRegex()

Set matching to use regular expressions.

inline void setMatchExact()

Set matching to be exact.

inline void setIgnoreHierarchyMarkers()

Set matching to ignore hierarchy markers (only with wildcard or regular expression matching modes). Hierarchy markers are ‘.’, ‘/’ and ‘_’.

inline void setRespectHierarchyMarkers()

Set matching to respect hierarchy markers (ie not to ignore them, only with wildcard or regular expression matching modes).

inline void setMatchOneVertex()

Set matching to identify one vertex, and for it to be an error if more than one vertex is matched.

inline void setMatchAnyVertex()

Set matching to identify multiple vertices, and for just one to be chosen arbitrarily.

inline void setVerbose()

Enable verbose output.

inline void setDebug()

Enable debug output (including verbose messages).

inline void setQuiet()

Supress verbose and debug messages.

Public Static Functions

static inline Options &getInstance()

Return a reference to the Options object.

static inline Options *getInstancePtr()

Return a pointer to the Options object.

Netlist

class netlist_paths::Netlist

Wrapper for Python to manage the netlist object.

Public Functions

Netlist(const std::string &filename)

Construct a new netlist from an XML file.

Parameters

filename – A path to the XML netlist file.

const std::string getVertexDTypeStr(const std::string &name, VertexNetlistType vertexType = VertexNetlistType::ANY) const

Lookup the data type string of a single vertex.

Parameters
  • name – A pattern specifying a name to match.

  • vertexType – The type of the vertex to lookup.

Returns

A string representing the data type.

size_t getVertexDTypeWidth(const std::string &name, VertexNetlistType vertexType = VertexNetlistType::ANY) const

Lookup the data type width of a single vertex.

Parameters
  • name – A pattern specifying a name to match.

  • vertexType – The type of the vertex to lookup.

Returns

The width of the data type.

size_t getDTypeWidth(const std::string &name) const

Lookup the width of a data type by name.

Parameters

name – A pattern specifying a name to match.

Returns

The width of the data type.

bool startpointExists(const std::string &name) const

Return true if a single startpoint matching a pattern exists.

Parameters

name – A pattern specifying a name to match.

Returns

True if the startpoint exists.

bool endpointExists(const std::string &name) const

Return true if a single endpoint matching a pattern ‘name’ exists.

Parameters

name – A pattern specifying a name to match.

Returns

True if the endpoint exists.

bool anyStartpointExists(const std::string &name) const

Return true if any startpoint matching a pattern ‘name’ exists.

Parameters

name – A pattern specifying a name to match.

Returns

True if any startpoint exists.

bool anyEndpointExists(const std::string &name) const

Return true if any endpoint matching a pattern ‘name’ exists.

Parameters

name – A pattern specifying a name to match.

Returns

True if any endpoint exists.

bool regExists(const std::string &name) const

Return true if a single register matching a pattern ‘name’ exists.

Parameters

name – A pattern specifying a name to match.

Returns

True if the register exists.

bool anyRegExists(const std::string &name) const

Return true if any register matching a pattern ‘name’ exists.

Parameters

name – A pattern specifying a name to match.

Returns

True if any register exists.

bool pathExists(Waypoints waypoints) const

Return a Boolean to indicate whether any path exists between two points.

Parameters

waypoints – A waypoints object constraining the path.

Returns

True if a path exists.

std::vector<Vertex*> getAnyPath(Waypoints waypoints) const

Return any path between two points.

Parameters

waypoints – A waypoints object constraining the path.

Returns

A path if one exists, otherwise an empty vector.

std::vector<std::vector<Vertex*>> getAllPaths(Waypoints waypoints) const

Return all paths between two points, useful for testing.

Parameters

waypoints – A waypoints object constraining the path.

Returns

All paths matching the waypoints, otherwise an empty vector.

std::vector<std::vector<Vertex*>> getAllFanOut(const std::string startName) const

Return a vector of paths fanning out from a particular start point.

Parameters

startName – A pattern matching a start point.

Returns

All paths fanning out from the matching startpoint, otherwise an empty vector.

std::vector<std::vector<Vertex*>> getAllFanIn(const std::string endName) const

Return a vector of paths fanning out from a particular start point.

Parameters

endName – A pattern matching an end point.

Returns

All paths fanning in to the matching endpoint, otherwise an empty vector.

std::vector<std::reference_wrapper<const Vertex>> getNamedVertices(const std::string pattern = std::string()) const

Return a sorted list of unique named vertices in the netlist for searching.

Parameters

pattern – A pattern to match vertices against.

Returns

A vector of Vertex references.

inline std::vector<Vertex*> getNamedVerticesPtr(const std::string pattern = std::string()) const

Return a vector of pointers to vertices that have names.

inline std::vector<Vertex*> getNetVerticesPtr(const std::string pattern = std::string()) const

Return a vector of pointers to net vertices.

Parameters

pattern – A pattern to match vertices against.

Returns

A vector of pointers to Vertex objects.

inline std::vector<Vertex*> getPortVerticesPtr(const std::string pattern = std::string()) const

Return a vector of pointers to port vertices.

Parameters

pattern – A pattern to match vertices against.

Returns

A vector of pointers to Vertex objects.

inline std::vector<Vertex*> getRegVerticesPtr(const std::string pattern = std::string()) const

Return a vector of pointers to register vertices.

Parameters

pattern – A pattern to match vertices against.

Returns

A vector of pointers to Vertex objects.

inline void dumpDotFile(const std::string &outputFilename) const

Write a dot-file represenation of the netlist graph to a file.

Parameters

outputFilename – The file to write the dot output to.

inline bool isEmpty() const

Return true if the netlist is empty.

RunVerilator

class netlist_paths::RunVerilator

A class that provides facilities to run Verilator and produce XML netlists.

Public Functions

RunVerilator()

Default constructor. Locate the Netlist Paths Verilator executable relative to the location of the Netlist Paths library.

RunVerilator(const std::string &verilatorLocation)

Constructor, providing a path to a Verilator executable.

Parameters

verilatorLocation – The location of the Netlists Paths Verilator executable (np-verilator_bin).

int run(const std::vector<std::string> &includes, const std::vector<std::string> &defines, const std::vector<std::string> &inputFiles, const std::string &outputFile) const

Run Verilator.

Parameters
  • includes – A vector of search paths for include files.

  • defines – A vector of macro definitions.

  • inputFiles – A vector of source file paths.

  • outputFile – A path specifying an output file.

int run(const std::string &inputFile, const std::string &outputFile) const

Run Verilator with a single source file and no other options.

Parameters
  • inputFile – A source file path.

  • outputFile – A path specifying an output file.

Vertex

class netlist_paths::Vertex

A class representing a vertex in the netlist graph.

Public Functions

inline Vertex(VertexAstType type, Location location)

Construct a logic vertex.

Parameters
  • type – The AST type of the logic statement.

  • location – The source location of the logic statement.

inline Vertex(VertexAstType type, VertexDirection direction, Location location, std::shared_ptr<DType> dtype, const std::string &name, bool isParam, const std::string &paramValue, bool publicVisibility)

Construct a variable vertex.

Parameters
  • type – The AST type of the variable.

  • direction – The direction of the variable type.

  • location – The source location of the variable declaration.

  • dtype – The data type of the variable.

  • name – The name of the variable.

  • isParam – A flag indicating the variable is a parameter.

  • paramValue – The value of the parameter variable.

  • publicVisibility – A flag indicating the variable has public visibility.

inline Vertex(const Vertex &v)

Copy constructor.

inline std::string getBasename() const

Given a hierarchical variable name, eg a.b.c, return the last component c.

Returns

The last heirarchical component of a variable name.

inline bool isGraphType(VertexNetlistType type) const

Match this vertex against different graph types.

Parameters

type – A categorisation of a vertex.

Returns

Whether the vertex matches the specified type.

inline bool compareLessThan(const Vertex &b) const

Less than comparison between two Vertex objects.

inline bool compareEqual(const Vertex &b) const

Equality comparison between two vertex objects.

inline bool isTop() const

Return true if the vertex is in the top scope.

inline bool isPublic() const

Return true if the vertex has public visibility.

inline bool isSrcReg() const

Return true if the vertex is a source register.

inline bool isDstReg() const

Return true if the vertex is a destination register.

inline bool isLogic() const

Return true if the vertex is a logic statement.

inline bool isParameter() const

Return true if the vertex is a parameter variable.

inline bool isNet() const

Return true if the vertex is a net variable.

inline bool isReg() const

Return true if the vertex is a register variable.

inline bool isSrcRegAlias() const

Return true if the vertex is an alias of a source register variable.

inline bool isDstRegAlias() const

Return true if the vertex is an alias of a destination register variable.

inline bool isPort() const

Return true if the vertex is a port variable.

inline bool isStartPoint() const

Return true if the vertex is a valid start point for a path.

  • Source register

  • Alias of a source register

  • A top input or inout port

inline bool isEndPoint() const

Return true if the vertex is a valid end point for a path.

  • Destination register

  • Alias of a destination register

  • A top output or inout port

inline bool isMidPoint() const

Return true if the vertex is a valid mid point for a path.

inline bool canIgnore() const

Return true if the vertex has been introduced by Verilator.

inline bool isNamed() const

Return true if the vertex has a name that should be included in reports.

inline std::string toString() const

Return a string description of this vertex.

Public Static Functions

static inline bool determineIsTop(const std::string &name)

Return whether a variable name is in the top scope.

A variable is in the ‘top’ scope when has one or two hierarchical components. For example, module.name or name is top level, but module.submodule.name is not.

Parameters

name – The name of a variable.

Returns

Whether the variable is in the top scope.

enum netlist_paths::VertexAstType

Vertex types corresponding to the Verilator XML AST format.

Values:

enumerator LOGIC
enumerator ASSIGN
enumerator ASSIGN_ALIAS
enumerator ASSIGN_DLY
enumerator ASSIGN_W
enumerator ALWAYS
enumerator INITIAL
enumerator INSTANCE
enumerator SRC_REG
enumerator DST_REG
enumerator SEN_GATE
enumerator SEN_ITEM
enumerator VAR
enumerator WIRE
enumerator PORT
enumerator SRC_REG_ALIAS
enumerator DST_REG_ALIAS
enumerator C_FUNC
enumerator INVALID
enum netlist_paths::VertexNetlistType

Vertex categorisation within the netlist graph, used for selecting collections of vertices with particular properties.

Values:

enumerator REG
enumerator DST_REG
enumerator SRC_REG
enumerator SRC_REG_ALIAS
enumerator DST_REG_ALIAS
enumerator NET
enumerator LOGIC
enumerator PORT
enumerator START_POINT
enumerator MID_POINT
enumerator END_POINT
enumerator IS_NAMED
enumerator ANY
enum netlist_paths::VertexDirection

The direction of a variable, applying only to ports.

Values:

enumerator NONE
enumerator INPUT
enumerator OUTPUT
enumerator INOUT

Waypoints

class netlist_paths::Waypoints

A class representing a set of waypoints to constrain a search for a path.

Public Functions

inline Waypoints()

Construct an empty Waypoints object.

inline Waypoints(const std::string start, const std::string end)

Construct a Waypoints object with patterns matching start and finish points.

Parameters
  • start – A pattern specifying a start point.

  • end – A pattern specifying an end point.

inline void addStartPoint(const std::string name)

Set a named start point.

Parameters

name – A pattern specifying a start point.

inline void addEndPoint(const std::string name)

Set a named end point.

Parameters

name – A pattern specifying an end point.

inline void addThroughPoint(const std::string name)

Add a through point.

Parameters

name – A pattern specifying a mid point.

inline void addAvoidPoint(const std::string name)

Add a point to avoid.

Parameters

name – A pattern specifying a mid point to avoid.

inline const std::vector<std::string> &getWaypoints() const

Access the waypoints.

Returns

An ordered vector of patterns for each waypoint.

inline const std::vector<std::string> &getAvoidPoints() const

Access the avoid points.

Returns

An ordered vector of patterns for each avoid point.

Python API reference

DType

class py_netlist_paths.DType
get_name((DType)arg1)str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_name(netlist_paths::DType {lvalue})

get_width((DType)arg1)int :
C++ signature :

unsigned long get_width(netlist_paths::DType {lvalue})

to_str((DType)arg1, (str)arg2)str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > to_str(netlist_paths::DType {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

Options

class py_netlist_paths.Options
static get_instance()Options :
C++ signature :

netlist_paths::Options* get_instance()

set_debug((Options)arg1)None :
C++ signature :

void set_debug(netlist_paths::Options {lvalue})

set_ignore_hierarchy_markers((Options)arg1)None :
C++ signature :

void set_ignore_hierarchy_markers(netlist_paths::Options {lvalue})

set_match_any_vertex((Options)arg1)None :
C++ signature :

void set_match_any_vertex(netlist_paths::Options {lvalue})

set_match_exact((Options)arg1)None :
C++ signature :

void set_match_exact(netlist_paths::Options {lvalue})

set_match_one_vertex((Options)arg1)None :
C++ signature :

void set_match_one_vertex(netlist_paths::Options {lvalue})

set_match_regex((Options)arg1)None :
C++ signature :

void set_match_regex(netlist_paths::Options {lvalue})

set_match_wildcard((Options)arg1)None :
C++ signature :

void set_match_wildcard(netlist_paths::Options {lvalue})

set_respect_hierarchy_markers((Options)arg1)None :
C++ signature :

void set_respect_hierarchy_markers(netlist_paths::Options {lvalue})

set_verbose((Options)arg1)None :
C++ signature :

void set_verbose(netlist_paths::Options {lvalue})

Netlist

class py_netlist_paths.Netlist
any_endpoint_exists((Netlist)arg1, (str)arg2)bool :
C++ signature :

bool any_endpoint_exists(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

any_reg_exists((Netlist)arg1, (str)arg2)bool :
C++ signature :

bool any_reg_exists(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

any_startpoint_exists((Netlist)arg1, (str)arg2)bool :
C++ signature :

bool any_startpoint_exists(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

dump_dot_file((Netlist)arg1, (str)arg2)None :
C++ signature :

void dump_dot_file(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

endpoint_exists((Netlist)arg1, (str)arg2)bool :
C++ signature :

bool endpoint_exists(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

get_all_fanin_paths((Netlist)arg1, (str)arg2)PathList :
C++ signature :

std::vector<std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> >, std::allocator<std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > > > get_all_fanin_paths(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

get_all_fanout_paths((Netlist)arg1, (str)arg2)PathList :
C++ signature :

std::vector<std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> >, std::allocator<std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > > > get_all_fanout_paths(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

get_all_paths((Netlist)arg1, (Waypoints)arg2)PathList :
C++ signature :

std::vector<std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> >, std::allocator<std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > > > get_all_paths(netlist_paths::Netlist {lvalue},netlist_paths::Waypoints)

get_any_path((Netlist)arg1, (Waypoints)arg2)Path :
C++ signature :

std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > get_any_path(netlist_paths::Netlist {lvalue},netlist_paths::Waypoints)

get_dtype_width((Netlist)arg1, (str)arg2)int :
C++ signature :

unsigned long get_dtype_width(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

get_named_vertices((Netlist)arg1[, (str)arg2])Path :
C++ signature :

std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > get_named_vertices(netlist_paths::Netlist {lvalue} [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >])

get_net_vertices((Netlist)arg1[, (str)arg2])Path :
C++ signature :

std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > get_net_vertices(netlist_paths::Netlist {lvalue} [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >])

get_port_vertices((Netlist)arg1[, (str)arg2])Path :
C++ signature :

std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > get_port_vertices(netlist_paths::Netlist {lvalue} [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >])

get_reg_vertices((Netlist)arg1[, (str)arg2])Path :
C++ signature :

std::vector<netlist_paths::Vertex*, std::allocator<netlist_paths::Vertex*> > get_reg_vertices(netlist_paths::Netlist {lvalue} [,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >])

get_vertex_dtype_str((Netlist)arg1, (str)arg2[, (object)arg3])str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_vertex_dtype_str(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,netlist_paths::VertexNetlistType])

get_vertex_dtype_width((Netlist)arg1, (str)arg2[, (object)arg3])int :
C++ signature :

unsigned long get_vertex_dtype_width(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > [,netlist_paths::VertexNetlistType])

path_exists((Netlist)arg1, (Waypoints)arg2)bool :
C++ signature :

bool path_exists(netlist_paths::Netlist {lvalue},netlist_paths::Waypoints)

reg_exists((Netlist)arg1, (str)arg2)bool :
C++ signature :

bool reg_exists(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

startpoint_exists((Netlist)arg1, (str)arg2)bool :
C++ signature :

bool startpoint_exists(netlist_paths::Netlist {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

Waypoints

class py_netlist_paths.Waypoints
add_avoid_point((Waypoints)arg1, (str)arg2)None :
C++ signature :

void add_avoid_point(netlist_paths::Waypoints {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

add_finish_point((Waypoints)arg1, (str)arg2)None :
C++ signature :

void add_finish_point(netlist_paths::Waypoints {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

add_start_point((Waypoints)arg1, (str)arg2)None :
C++ signature :

void add_start_point(netlist_paths::Waypoints {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

add_through_point((Waypoints)arg1, (str)arg2)None :
C++ signature :

void add_through_point(netlist_paths::Waypoints {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

RunVerilator

class py_netlist_paths.RunVerilator
run((RunVerilator)arg1, (str)arg2, (str)arg3)int :
C++ signature :

int run(netlist_paths::RunVerilator {lvalue},std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >,std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)

Vertex

class py_netlist_paths.Vertex
can_ignore((Vertex)arg1)bool :
C++ signature :

bool can_ignore(netlist_paths::Vertex {lvalue})

get_ast_type_str((Vertex)arg1)str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_ast_type_str(netlist_paths::Vertex {lvalue})

get_direction_str((Vertex)arg1)str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_direction_str(netlist_paths::Vertex {lvalue})

get_dtype((Vertex)arg1)DType :
C++ signature :

netlist_paths::DType* get_dtype(netlist_paths::Vertex {lvalue})

get_dtype_str((Vertex)arg1)str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_dtype_str(netlist_paths::Vertex {lvalue})

get_dtype_width((Vertex)arg1)int :
C++ signature :

unsigned long get_dtype_width(netlist_paths::Vertex {lvalue})

get_location_str((Vertex)arg1)str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_location_str(netlist_paths::Vertex {lvalue})

get_name((Vertex)arg1)str :
C++ signature :

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > get_name(netlist_paths::Vertex {lvalue})

is_end_point((Vertex)arg1)bool :
C++ signature :

bool is_end_point(netlist_paths::Vertex {lvalue})

is_logic((Vertex)arg1)bool :
C++ signature :

bool is_logic(netlist_paths::Vertex {lvalue})

is_mid_point((Vertex)arg1)bool :
C++ signature :

bool is_mid_point(netlist_paths::Vertex {lvalue})

is_net((Vertex)arg1)bool :
C++ signature :

bool is_net(netlist_paths::Vertex {lvalue})

is_parameter((Vertex)arg1)bool :
C++ signature :

bool is_parameter(netlist_paths::Vertex {lvalue})

is_port((Vertex)arg1)bool :
C++ signature :

bool is_port(netlist_paths::Vertex {lvalue})

is_public((Vertex)arg1)bool :
C++ signature :

bool is_public(netlist_paths::Vertex {lvalue})

is_reg((Vertex)arg1)bool :
C++ signature :

bool is_reg(netlist_paths::Vertex {lvalue})

is_start_point((Vertex)arg1)bool :
C++ signature :

bool is_start_point(netlist_paths::Vertex {lvalue})

is_top((Vertex)arg1)bool :
C++ signature :

bool is_top(netlist_paths::Vertex {lvalue})