#include <modtools.h>

Collaboration diagram for ModWalker:

Data Structures
struct	PortBit

Public Member Functions
void	add_wire (RTLIL::Wire *wire)

void	add_cell_port (RTLIL::Cell *cell, RTLIL::IdString port, std::vector< RTLIL::SigBit > bits, bool is_output, bool is_input)

void	add_cell (RTLIL::Cell *cell)

	ModWalker ()

	ModWalker (RTLIL::Design design, RTLIL::Module module, CellTypes *filter_ct=NULL)

void	setup (RTLIL::Design design, RTLIL::Module module, CellTypes *filter_ct=NULL)

template<typename T >
bool	get_drivers (std::set< PortBit > &result, RTLIL::SigBit bit) const

template<typename T >
bool	get_consumers (std::set< PortBit > &result, RTLIL::SigBit bit) const

template<typename T >
bool	get_inputs (std::set< RTLIL::SigBit > &result, RTLIL::SigBit bit) const

template<typename T >
bool	get_outputs (std::set< RTLIL::SigBit > &result, RTLIL::SigBit bit) const

template<typename T >
bool	get_drivers (std::set< PortBit > &result, const T &bits) const

template<typename T >
bool	get_consumers (std::set< PortBit > &result, const T &bits) const

template<typename T >
bool	get_inputs (std::set< RTLIL::SigBit > &result, const T &bits) const

template<typename T >
bool	get_outputs (std::set< RTLIL::SigBit > &result, const T &bits) const

bool	get_drivers (std::set< PortBit > &result, RTLIL::SigSpec signal) const

bool	get_consumers (std::set< PortBit > &result, RTLIL::SigSpec signal) const

bool	get_inputs (std::set< RTLIL::SigBit > &result, RTLIL::SigSpec signal) const

bool	get_outputs (std::set< RTLIL::SigBit > &result, RTLIL::SigSpec signal) const

template<typename T >
bool	has_drivers (const T &sig) const

template<typename T >
bool	has_consumers (const T &sig) const

template<typename T >
bool	has_inputs (const T &sig) const

template<typename T >
bool	has_outputs (const T &sig) const

bool	has_drivers (RTLIL::SigSpec sig) const

bool	has_consumers (RTLIL::SigSpec sig) const

bool	has_inputs (RTLIL::SigSpec sig) const

bool	has_outputs (RTLIL::SigSpec sig) const

Data Fields
RTLIL::Design *	design

RTLIL::Module *	module

CellTypes	ct

SigMap	sigmap

std::map< RTLIL::SigBit, std::set< PortBit > >	signal_drivers

std::map< RTLIL::SigBit, std::set< PortBit > >	signal_consumers

std::set< RTLIL::SigBit >	signal_inputs

std::set< RTLIL::SigBit >	signal_outputs

std::map< RTLIL::Cell *, std::set< RTLIL::SigBit > >	cell_outputs

std::map< RTLIL::Cell *, std::set< RTLIL::SigBit > >	cell_inputs

Detailed Description

Definition at line 181 of file modtools.h.

Constructor & Destructor Documentation

ModWalker::ModWalker ( )

inline

Definition at line 256 of file modtools.h.

                 : design(NULL), module(NULL)
     {
     }

ModWalker::ModWalker	(	RTLIL::Design *	design,
		RTLIL::Module *	module,
		CellTypes *	filter_ct = `NULL`
	)

inline

Definition at line 260 of file modtools.h.

     {
         setup(design, module, filter_ct);
     }

Here is the call graph for this function:

Member Function Documentation

void ModWalker::add_cell ( RTLIL::Cell * cell )

inline

Definition at line 243 of file modtools.h.

     {
         if (ct.cell_known(cell->type)) {
             for (auto &conn : cell->connections())
                 add_cell_port(cell, conn.first, sigmap(conn.second),
                         ct.cell_output(cell->type, conn.first),
                         ct.cell_input(cell->type, conn.first));
         } else {
             for (auto &conn : cell->connections())
                 add_cell_port(cell, conn.first, sigmap(conn.second), true, true);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void ModWalker::add_cell_port	(	RTLIL::Cell *	cell,
		RTLIL::IdString	port,
		std::vector< RTLIL::SigBit >	bits,
		bool	is_output,
		bool	is_input
	)

inline

Definition at line 227 of file modtools.h.

     {
         for (int i = 0; i < int(bits.size()); i++)
             if (bits[i].wire != NULL) {
                 PortBit pbit = { cell, port, i };
                 if (is_output) {
                     signal_drivers[bits[i]].insert(pbit);
                     cell_outputs[cell].insert(bits[i]);
                 }
                 if (is_input) {
                     signal_consumers[bits[i]].insert(pbit);
                     cell_inputs[cell].insert(bits[i]);
                 }
             }
     }

Here is the caller graph for this function:

void ModWalker::add_wire ( RTLIL::Wire * wire )

inline

Definition at line 210 of file modtools.h.

     {
         if (wire->port_input) {
             std::vector<RTLIL::SigBit> bits = sigmap(wire);
             for (auto bit : bits)
                 if (bit.wire != NULL)
                     signal_inputs.insert(bit);
         }
 
         if (wire->port_output) {
             std::vector<RTLIL::SigBit> bits = sigmap(wire);
             for (auto bit : bits)
                 if (bit.wire != NULL)
                     signal_outputs.insert(bit);
         }
     }

Here is the caller graph for this function:

template<typename T >

bool ModWalker::get_consumers	(	std::set< PortBit > &	result,
		RTLIL::SigBit	bit
	)		const

inline

Definition at line 301 of file modtools.h.

     {
         bool found = false;
         if (signal_consumers.count(bit)) {
             const std::set<PortBit> &r = signal_consumers.at(bit);
             result.insert(r.begin(), r.end());
             found = true;
         }
         return found;
     }

Here is the caller graph for this function:

template<typename T >

bool ModWalker::get_consumers	(	std::set< PortBit > &	result,
		const T &	bits
	)		const

inline

Definition at line 346 of file modtools.h.

     {
         bool found = false;
         for (RTLIL::SigBit bit : bits)
             if (signal_consumers.count(bit)) {
                 const std::set<PortBit> &r = signal_consumers.at(bit);
                 result.insert(r.begin(), r.end());
                 found = true;
             }
         return found;
     }

bool ModWalker::get_consumers	(	std::set< PortBit > &	result,
		RTLIL::SigSpec	signal
	)		const

inline

Definition at line 386 of file modtools.h.

     {
         std::vector<RTLIL::SigBit> bits = sigmap(signal);
         return get_consumers(result, bits);
     }

Here is the call graph for this function:

template<typename T >

bool ModWalker::get_drivers	(	std::set< PortBit > &	result,
		RTLIL::SigBit	bit
	)		const

inline

Definition at line 289 of file modtools.h.

     {
         bool found = false;
         if (signal_drivers.count(bit)) {
             const std::set<PortBit> &r = signal_drivers.at(bit);
             result.insert(r.begin(), r.end());
             found = true;
         }
         return found;
     }

Here is the caller graph for this function:

template<typename T >

bool ModWalker::get_drivers	(	std::set< PortBit > &	result,
		const T &	bits
	)		const

inline

Definition at line 333 of file modtools.h.

     {
         bool found = false;
         for (RTLIL::SigBit bit : bits)
             if (signal_drivers.count(bit)) {
                 const std::set<PortBit> &r = signal_drivers.at(bit);
                 result.insert(r.begin(), r.end());
                 found = true;
             }
         return found;
     }

bool ModWalker::get_drivers	(	std::set< PortBit > &	result,
		RTLIL::SigSpec	signal
	)		const

inline

Definition at line 380 of file modtools.h.

     {
         std::vector<RTLIL::SigBit> bits = sigmap(signal);
         return get_drivers(result, bits);
     }

Here is the call graph for this function:

template<typename T >

bool ModWalker::get_inputs	(	std::set< RTLIL::SigBit > &	result,
		RTLIL::SigBit	bit
	)		const

inline

Definition at line 313 of file modtools.h.

     {
         bool found = false;
         if (signal_inputs.count(bit))
             result.insert(bit), found = true;
         return found;
     }

Here is the caller graph for this function:

template<typename T >

bool ModWalker::get_inputs	(	std::set< RTLIL::SigBit > &	result,
		const T &	bits
	)		const

inline

Definition at line 359 of file modtools.h.

     {
         bool found = false;
         for (RTLIL::SigBit bit : bits)
             if (signal_inputs.count(bit))
                 result.insert(bit), found = true;
         return found;
     }

bool ModWalker::get_inputs	(	std::set< RTLIL::SigBit > &	result,
		RTLIL::SigSpec	signal
	)		const

inline

Definition at line 392 of file modtools.h.

     {
         std::vector<RTLIL::SigBit> bits = sigmap(signal);
         return get_inputs(result, bits);
     }

Here is the call graph for this function:

template<typename T >

bool ModWalker::get_outputs	(	std::set< RTLIL::SigBit > &	result,
		RTLIL::SigBit	bit
	)		const

inline

Definition at line 322 of file modtools.h.

     {
         bool found = false;
         if (signal_outputs.count(bit))
             result.insert(bit), found = true;
         return found;
     }

Here is the caller graph for this function:

template<typename T >

bool ModWalker::get_outputs	(	std::set< RTLIL::SigBit > &	result,
		const T &	bits
	)		const

inline

Definition at line 369 of file modtools.h.

     {
         bool found = false;
         for (RTLIL::SigBit bit : bits)
             if (signal_outputs.count(bit))
                 result.insert(bit), found = true;
         return found;
     }

bool ModWalker::get_outputs	(	std::set< RTLIL::SigBit > &	result,
		RTLIL::SigSpec	signal
	)		const

inline

Definition at line 398 of file modtools.h.

     {
         std::vector<RTLIL::SigBit> bits = sigmap(signal);
         return get_outputs(result, bits);
     }

Here is the call graph for this function:

template<typename T >

bool ModWalker::has_consumers ( const T & sig ) const

inline

Definition at line 413 of file modtools.h.

                                                   {
         std::set<PortBit> result;
         return get_consumers(result, sig);
     }

Here is the call graph for this function:

bool ModWalker::has_consumers ( RTLIL::SigSpec sig ) const

inline

Definition at line 437 of file modtools.h.

                                                       {
         std::set<PortBit> result;
         return get_consumers(result, sig);
     }

Here is the call graph for this function:

template<typename T >

bool ModWalker::has_drivers ( const T & sig ) const

inline

Definition at line 407 of file modtools.h.

                                                 {
         std::set<PortBit> result;
         return get_drivers(result, sig);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool ModWalker::has_drivers ( RTLIL::SigSpec sig ) const

inline

Definition at line 432 of file modtools.h.

                                                     {
         std::set<PortBit> result;
         return get_drivers(result, sig);
     }

Here is the call graph for this function:

template<typename T >

bool ModWalker::has_inputs ( const T & sig ) const

inline

Definition at line 419 of file modtools.h.

                                                {
         std::set<RTLIL::SigBit> result;
         return get_inputs(result, sig);
     }

Here is the call graph for this function:

bool ModWalker::has_inputs ( RTLIL::SigSpec sig ) const

inline

Definition at line 442 of file modtools.h.

                                                    {
         std::set<RTLIL::SigBit> result;
         return get_inputs(result, sig);
     }

Here is the call graph for this function:

template<typename T >

bool ModWalker::has_outputs ( const T & sig ) const

inline

Definition at line 425 of file modtools.h.

                                                 {
         std::set<RTLIL::SigBit> result;
         return get_outputs(result, sig);
     }

Here is the call graph for this function:

bool ModWalker::has_outputs ( RTLIL::SigSpec sig ) const

inline

Definition at line 447 of file modtools.h.

                                                     {
         std::set<RTLIL::SigBit> result;
         return get_outputs(result, sig);
     }

Here is the call graph for this function:

void ModWalker::setup	(	RTLIL::Design *	design,
		RTLIL::Module *	module,
		CellTypes *	filter_ct = `NULL`
	)

inline

Definition at line 265 of file modtools.h.

     {
         this->design = design;
         this->module = module;
 
         ct.clear();
         ct.setup(design);
         sigmap.set(module);
 
         signal_drivers.clear();
         signal_consumers.clear();
         signal_inputs.clear();
         signal_outputs.clear();
 
         for (auto &it : module->wires_)
             add_wire(it.second);
         for (auto &it : module->cells_)
             if (filter_ct == NULL || filter_ct->cell_known(it.second->type))
                 add_cell(it.second);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

std::map<RTLIL::Cell*, std::set<RTLIL::SigBit> > ModWalker::cell_inputs

Definition at line 208 of file modtools.h.

std::map<RTLIL::Cell*, std::set<RTLIL::SigBit> > ModWalker::cell_outputs

Definition at line 208 of file modtools.h.

CellTypes ModWalker::ct

Definition at line 201 of file modtools.h.

RTLIL::Design* ModWalker::design

Definition at line 198 of file modtools.h.

RTLIL::Module* ModWalker::module

Definition at line 199 of file modtools.h.

SigMap ModWalker::sigmap

Definition at line 202 of file modtools.h.

std::map<RTLIL::SigBit, std::set<PortBit> > ModWalker::signal_consumers

Definition at line 205 of file modtools.h.

std::map<RTLIL::SigBit, std::set<PortBit> > ModWalker::signal_drivers

Definition at line 204 of file modtools.h.

std::set<RTLIL::SigBit> ModWalker::signal_inputs

Definition at line 206 of file modtools.h.

std::set<RTLIL::SigBit> ModWalker::signal_outputs

Definition at line 206 of file modtools.h.

The documentation for this struct was generated from the following file:

modtools.h

Data Structures

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation