RTLIL::Module Struct Reference

#include <rtlil.h>

Inheritance diagram for RTLIL::Module:

Collaboration diagram for RTLIL::Module:

Public Member Functions
RTLIL_ATTRIBUTE_MEMBERS	Module ()
virtual	~Module ()
virtual RTLIL::IdString	derive (RTLIL::Design *design, std::map< RTLIL::IdString, RTLIL::Const > parameters)
virtual size_t	count_id (RTLIL::IdString id)
virtual void	check ()
virtual void	optimize ()
void	connect (const RTLIL::SigSig &conn)
void	connect (const RTLIL::SigSpec &lhs, const RTLIL::SigSpec &rhs)
void	new_connections (const std::vector< RTLIL::SigSig > &new_conn)
const std::vector < RTLIL::SigSig > &	connections () const
void	fixup_ports ()
template<typename T >
void	rewrite_sigspecs (T functor)
void	cloneInto (RTLIL::Module *new_mod) const
virtual RTLIL::Module *	clone () const
bool	has_memories () const
bool	has_processes () const
bool	has_memories_warn () const
bool	has_processes_warn () const
std::vector< RTLIL::Wire * >	selected_wires () const
std::vector< RTLIL::Cell * >	selected_cells () const
template<typename T >
bool	selected (T *member) const
RTLIL::Wire *	wire (RTLIL::IdString id)
RTLIL::Cell *	cell (RTLIL::IdString id)
RTLIL::ObjRange< RTLIL::Wire * >	wires ()
RTLIL::ObjRange< RTLIL::Cell * >	cells ()
void	remove (const std::set< RTLIL::Wire * > &wires)
void	remove (RTLIL::Cell *cell)
void	rename (RTLIL::Wire *wire, RTLIL::IdString new_name)
void	rename (RTLIL::Cell *cell, RTLIL::IdString new_name)
void	rename (RTLIL::IdString old_name, RTLIL::IdString new_name)
void	swap_names (RTLIL::Wire *w1, RTLIL::Wire *w2)
void	swap_names (RTLIL::Cell *c1, RTLIL::Cell *c2)
RTLIL::IdString	uniquify (RTLIL::IdString name)
RTLIL::IdString	uniquify (RTLIL::IdString name, int &index)
RTLIL::Wire *	addWire (RTLIL::IdString name, int width=1)
RTLIL::Wire *	addWire (RTLIL::IdString name, const RTLIL::Wire *other)
RTLIL::Cell *	addCell (RTLIL::IdString name, RTLIL::IdString type)
RTLIL::Cell *	addCell (RTLIL::IdString name, const RTLIL::Cell *other)
RTLIL::Cell *	addNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addPos (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addNeg (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addOr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addXor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addReduceAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addReduceOr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addReduceXor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addShl (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addShr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addSshl (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addSshr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addShift (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addShiftx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addLt (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addLe (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addEq (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addNe (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addEqx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addNex (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addGe (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addGt (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addAdd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addSub (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addMul (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addDiv (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addMod (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addPow (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool a_signed=false, bool b_signed=false)
RTLIL::Cell *	addLogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addLogicAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addLogicOr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y, bool is_signed=false)
RTLIL::Cell *	addMux (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s, RTLIL::SigSpec sig_y)
RTLIL::Cell *	addPmux (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s, RTLIL::SigSpec sig_y)
RTLIL::Cell *	addSlice (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_y, RTLIL::Const offset)
RTLIL::Cell *	addConcat (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_y)
RTLIL::Cell *	addLut (RTLIL::IdString name, RTLIL::SigSpec sig_i, RTLIL::SigSpec sig_o, RTLIL::Const lut)
RTLIL::Cell *	addAssert (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_en)
RTLIL::Cell *	addSr (RTLIL::IdString name, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr, RTLIL::SigSpec sig_q, bool set_polarity=true, bool clr_polarity=true)
RTLIL::Cell *	addDff (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity=true)
RTLIL::Cell *	addDffe (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity=true, bool en_polarity=true)
RTLIL::Cell *	addDffsr (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity=true, bool set_polarity=true, bool clr_polarity=true)
RTLIL::Cell *	addAdff (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_arst, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, RTLIL::Const arst_value, bool clk_polarity=true, bool arst_polarity=true)
RTLIL::Cell *	addDlatch (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity=true)
RTLIL::Cell *	addDlatchsr (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity=true, bool set_polarity=true, bool clr_polarity=true)
RTLIL::Cell *	addNotGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_y)
RTLIL::Cell *	addAndGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y)
RTLIL::Cell *	addNandGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y)
RTLIL::Cell *	addOrGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y)
RTLIL::Cell *	addNorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y)
RTLIL::Cell *	addXorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y)
RTLIL::Cell *	addXnorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_y)
RTLIL::Cell *	addMuxGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_s, RTLIL::SigBit sig_y)
RTLIL::Cell *	addAoi3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_y)
RTLIL::Cell *	addOai3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_y)
RTLIL::Cell *	addAoi4Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_d, RTLIL::SigBit sig_y)
RTLIL::Cell *	addOai4Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_d, RTLIL::SigBit sig_y)
RTLIL::Cell *	addDffGate (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity=true)
RTLIL::Cell *	addDffeGate (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity=true, bool en_polarity=true)
RTLIL::Cell *	addDffsrGate (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool clk_polarity=true, bool set_polarity=true, bool clr_polarity=true)
RTLIL::Cell *	addAdffGate (RTLIL::IdString name, RTLIL::SigSpec sig_clk, RTLIL::SigSpec sig_arst, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool arst_value=false, bool clk_polarity=true, bool arst_polarity=true)
RTLIL::Cell *	addDlatchGate (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity=true)
RTLIL::Cell *	addDlatchsrGate (RTLIL::IdString name, RTLIL::SigSpec sig_en, RTLIL::SigSpec sig_set, RTLIL::SigSpec sig_clr, RTLIL::SigSpec sig_d, RTLIL::SigSpec sig_q, bool en_polarity=true, bool set_polarity=true, bool clr_polarity=true)
RTLIL::SigSpec	Not (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	Pos (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	Bu0 (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	Neg (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	And (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Or (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Xor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Xnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	ReduceAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	ReduceOr (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	ReduceXor (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	ReduceXnor (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	ReduceBool (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	Shl (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Shr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Sshl (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Sshr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Shift (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Shiftx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Lt (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Le (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Eq (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Ne (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Eqx (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Nex (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Ge (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Gt (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Add (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Sub (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Mul (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Div (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Mod (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Pow (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool a_signed=false, bool b_signed=false)
RTLIL::SigSpec	LogicNot (RTLIL::IdString name, RTLIL::SigSpec sig_a, bool is_signed=false)
RTLIL::SigSpec	LogicAnd (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	LogicOr (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, bool is_signed=false)
RTLIL::SigSpec	Mux (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s)
RTLIL::SigSpec	Pmux (RTLIL::IdString name, RTLIL::SigSpec sig_a, RTLIL::SigSpec sig_b, RTLIL::SigSpec sig_s)
RTLIL::SigBit	NotGate (RTLIL::IdString name, RTLIL::SigBit sig_a)
RTLIL::SigBit	AndGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b)
RTLIL::SigBit	NandGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b)
RTLIL::SigBit	OrGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b)
RTLIL::SigBit	NorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b)
RTLIL::SigBit	XorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b)
RTLIL::SigBit	XnorGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b)
RTLIL::SigBit	MuxGate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_s)
RTLIL::SigBit	Aoi3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c)
RTLIL::SigBit	Oai3Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c)
RTLIL::SigBit	Aoi4Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_d)
RTLIL::SigBit	Oai4Gate (RTLIL::IdString name, RTLIL::SigBit sig_a, RTLIL::SigBit sig_b, RTLIL::SigBit sig_c, RTLIL::SigBit sig_d)

Data Fields
RTLIL::Design *	design
std::set< RTLIL::Monitor * >	monitors
int	refcount_wires_
int	refcount_cells_
std::map< RTLIL::IdString, RTLIL::Wire * >	wires_
std::map< RTLIL::IdString, RTLIL::Cell * >	cells_
std::vector< RTLIL::SigSig >	connections_
RTLIL::IdString	name
std::set< RTLIL::IdString >	avail_parameters
std::map< RTLIL::IdString, RTLIL::Memory * >	memories
std::map< RTLIL::IdString, RTLIL::Process * >	processes
std::vector< RTLIL::IdString >	ports

Protected Member Functions
void	add (RTLIL::Wire *wire)
void	add (RTLIL::Cell *cell)

Detailed Description

Definition at line 582 of file rtlil.h.

Constructor & Destructor Documentation

RTLIL::Module::Module

(

)

Definition at line 448 of file rtlil.cc.

{
    design = nullptr;
    refcount_wires_ = 0;
    refcount_cells_ = 0;
}

RTLIL::Module::~Module ( )

virtual

Definition at line 455 of file rtlil.cc.

{
    for (auto it = wires_.begin(); it != wires_.end(); it++)
        delete it->second;
    for (auto it = memories.begin(); it != memories.end(); it++)
        delete it->second;
    for (auto it = cells_.begin(); it != cells_.end(); it++)
        delete it->second;
    for (auto it = processes.begin(); it != processes.end(); it++)
        delete it->second;
}

Member Function Documentation

void RTLIL::Module::add ( RTLIL::Wire *  wire )

protected

Definition at line 1113 of file rtlil.cc.

{
    log_assert(!wire->name.empty());
    log_assert(count_id(wire->name) == 0);
    log_assert(refcount_wires_ == 0);
    wires_[wire->name] = wire;
    wire->module = this;
}

Here is the call graph for this function:

void RTLIL::Module::add ( RTLIL::Cell *  cell )

protected

Definition at line 1122 of file rtlil.cc.

{
    log_assert(!cell->name.empty());
    log_assert(count_id(cell->name) == 0);
    log_assert(refcount_cells_ == 0);
    cells_[cell->name] = cell;
    cell->module = this;
}

Here is the call graph for this function:

RTLIL::SigSpec RTLIL::Module::Add	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addAdd	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::Cell * RTLIL::Module::addAdff	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_arst,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		RTLIL::Const	arst_value,
		bool	clk_polarity = true,
		bool	arst_polarity = true
	)

Definition at line 1639 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$adff");
    cell->parameters["\\CLK_POLARITY"] = clk_polarity;
    cell->parameters["\\ARST_POLARITY"] = arst_polarity;
    cell->parameters["\\ARST_VALUE"] = arst_value;
    cell->parameters["\\WIDTH"] = sig_q.size();
    cell->setPort("\\CLK", sig_clk);
    cell->setPort("\\ARST", sig_arst);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addAdffGate	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_arst,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	arst_value = false,
		bool	clk_polarity = true,
		bool	arst_polarity = true
	)

Definition at line 1712 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, stringf("$_DFF_%c%c%c_", clk_polarity ? 'P' : 'N', arst_polarity ? 'P' : 'N', arst_value ? '1' : '0'));
    cell->setPort("\\C", sig_clk);
    cell->setPort("\\R", sig_arst);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell* RTLIL::Module::addAnd	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addAndGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addAoi3Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addAoi4Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c,
		RTLIL::SigBit	sig_d,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell * RTLIL::Module::addAssert	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_en
	)

Definition at line 1579 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$assert");
    cell->setPort("\\A", sig_a);
    cell->setPort("\\EN", sig_en);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addCell	(	RTLIL::IdString	name,
		RTLIL::IdString	type
	)

Definition at line 1353 of file rtlil.cc.

{
    RTLIL::Cell *cell = new RTLIL::Cell;
    cell->name = name;
    cell->type = type;
    add(cell);
    return cell;
}

RTLIL::Cell * RTLIL::Module::addCell	(	RTLIL::IdString	name,
		const RTLIL::Cell *	other
	)

Definition at line 1362 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, other->type);
    cell->connections_ = other->connections_;
    cell->parameters = other->parameters;
    cell->attributes = other->attributes;
    return cell;
}

RTLIL::Cell * RTLIL::Module::addConcat	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y
	)

Definition at line 1558 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$concat");
    cell->parameters["\\A_WIDTH"] = sig_a.size();
    cell->parameters["\\B_WIDTH"] = sig_b.size();
    cell->setPort("\\A", sig_a);
    cell->setPort("\\B", sig_b);
    cell->setPort("\\Y", sig_y);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDff	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	clk_polarity = true
	)

Definition at line 1599 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$dff");
    cell->parameters["\\CLK_POLARITY"] = clk_polarity;
    cell->parameters["\\WIDTH"] = sig_q.size();
    cell->setPort("\\CLK", sig_clk);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDffe	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_en,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	clk_polarity = true,
		bool	en_polarity = true
	)

Definition at line 1610 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$dffe");
    cell->parameters["\\CLK_POLARITY"] = clk_polarity;
    cell->parameters["\\EN_POLARITY"] = en_polarity;
    cell->parameters["\\WIDTH"] = sig_q.size();
    cell->setPort("\\CLK", sig_clk);
    cell->setPort("\\EN", sig_en);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Cell * RTLIL::Module::addDffeGate	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_en,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	clk_polarity = true,
		bool	en_polarity = true
	)

Definition at line 1690 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, stringf("$_DFFE_%c%c_", clk_polarity ? 'P' : 'N', en_polarity ? 'P' : 'N'));
    cell->setPort("\\C", sig_clk);
    cell->setPort("\\E", sig_en);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDffGate	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	clk_polarity = true
	)

Definition at line 1681 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, stringf("$_DFF_%c_", clk_polarity ? 'P' : 'N'));
    cell->setPort("\\C", sig_clk);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDffsr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_set,
		RTLIL::SigSpec	sig_clr,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	clk_polarity = true,
		bool	set_polarity = true,
		bool	clr_polarity = true
	)

Definition at line 1623 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$dffsr");
    cell->parameters["\\CLK_POLARITY"] = clk_polarity;
    cell->parameters["\\SET_POLARITY"] = set_polarity;
    cell->parameters["\\CLR_POLARITY"] = clr_polarity;
    cell->parameters["\\WIDTH"] = sig_q.size();
    cell->setPort("\\CLK", sig_clk);
    cell->setPort("\\SET", sig_set);
    cell->setPort("\\CLR", sig_clr);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDffsrGate	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_clk,
		RTLIL::SigSpec	sig_set,
		RTLIL::SigSpec	sig_clr,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	clk_polarity = true,
		bool	set_polarity = true,
		bool	clr_polarity = true
	)

Definition at line 1700 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, stringf("$_DFFSR_%c%c%c_", clk_polarity ? 'P' : 'N', set_polarity ? 'P' : 'N', clr_polarity ? 'P' : 'N'));
    cell->setPort("\\C", sig_clk);
    cell->setPort("\\S", sig_set);
    cell->setPort("\\R", sig_clr);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell* RTLIL::Module::addDiv	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell * RTLIL::Module::addDlatch	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_en,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	en_polarity = true
	)

Definition at line 1654 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$dlatch");
    cell->parameters["\\EN_POLARITY"] = en_polarity;
    cell->parameters["\\WIDTH"] = sig_q.size();
    cell->setPort("\\EN", sig_en);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDlatchGate	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_en,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	en_polarity = true
	)

Definition at line 1723 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, stringf("$_DLATCH_%c_", en_polarity ? 'P' : 'N'));
    cell->setPort("\\E", sig_en);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDlatchsr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_en,
		RTLIL::SigSpec	sig_set,
		RTLIL::SigSpec	sig_clr,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	en_polarity = true,
		bool	set_polarity = true,
		bool	clr_polarity = true
	)

Definition at line 1665 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$dlatchsr");
    cell->parameters["\\EN_POLARITY"] = en_polarity;
    cell->parameters["\\SET_POLARITY"] = set_polarity;
    cell->parameters["\\CLR_POLARITY"] = clr_polarity;
    cell->parameters["\\WIDTH"] = sig_q.size();
    cell->setPort("\\EN", sig_en);
    cell->setPort("\\SET", sig_set);
    cell->setPort("\\CLR", sig_clr);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addDlatchsrGate	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_en,
		RTLIL::SigSpec	sig_set,
		RTLIL::SigSpec	sig_clr,
		RTLIL::SigSpec	sig_d,
		RTLIL::SigSpec	sig_q,
		bool	en_polarity = true,
		bool	set_polarity = true,
		bool	clr_polarity = true
	)

Definition at line 1732 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, stringf("$_DLATCHSR_%c%c%c_", en_polarity ? 'P' : 'N', set_polarity ? 'P' : 'N', clr_polarity ? 'P' : 'N'));
    cell->setPort("\\E", sig_en);
    cell->setPort("\\S", sig_set);
    cell->setPort("\\R", sig_clr);
    cell->setPort("\\D", sig_d);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell* RTLIL::Module::addEq	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addEqx	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addGe	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addGt	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addLe	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addLogicAnd	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addLogicNot	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addLogicOr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addLt	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell * RTLIL::Module::addLut	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_i,
		RTLIL::SigSpec	sig_o,
		RTLIL::Const	lut
	)

Definition at line 1569 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$lut");
    cell->parameters["\\LUT"] = lut;
    cell->parameters["\\WIDTH"] = sig_i.size();
    cell->setPort("\\A", sig_i);
    cell->setPort("\\Y", sig_o);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell* RTLIL::Module::addMod	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addMul	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addMux	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_s,
		RTLIL::SigSpec	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addMuxGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_s,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addNandGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addNe	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addNeg	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addNex	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addNorGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addNot	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addNotGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addOai3Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addOai4Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c,
		RTLIL::SigBit	sig_d,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addOr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addOrGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addPmux	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_s,
		RTLIL::SigSpec	sig_y
	)

RTLIL::Cell* RTLIL::Module::addPos	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addPow	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	a_signed = false,
		bool	b_signed = false
	)

RTLIL::Cell* RTLIL::Module::addReduceAnd	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addReduceBool	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addReduceOr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addReduceXnor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addReduceXor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addShift	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addShiftx	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addShl	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addShr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell * RTLIL::Module::addSlice	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_y,
		RTLIL::Const	offset
	)

Definition at line 1547 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$slice");
    cell->parameters["\\A_WIDTH"] = sig_a.size();
    cell->parameters["\\Y_WIDTH"] = sig_y.size();
    cell->parameters["\\OFFSET"] = offset;
    cell->setPort("\\A", sig_a);
    cell->setPort("\\Y", sig_y);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell * RTLIL::Module::addSr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_set,
		RTLIL::SigSpec	sig_clr,
		RTLIL::SigSpec	sig_q,
		bool	set_polarity = true,
		bool	clr_polarity = true
	)

Definition at line 1587 of file rtlil.cc.

{
    RTLIL::Cell *cell = addCell(name, "$sr");
    cell->parameters["\\SET_POLARITY"] = set_polarity;
    cell->parameters["\\CLR_POLARITY"] = clr_polarity;
    cell->parameters["\\WIDTH"] = sig_q.size();
    cell->setPort("\\SET", sig_set);
    cell->setPort("\\CLR", sig_clr);
    cell->setPort("\\Q", sig_q);
    return cell;
}

Here is the call graph for this function:

RTLIL::Cell* RTLIL::Module::addSshl	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addSshr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addSub	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::Wire * RTLIL::Module::addWire	(	RTLIL::IdString	name,
		int	width = 1
	)

Definition at line 1331 of file rtlil.cc.

{
    RTLIL::Wire *wire = new RTLIL::Wire;
    wire->name = name;
    wire->width = width;
    add(wire);
    return wire;
}

RTLIL::Wire * RTLIL::Module::addWire	(	RTLIL::IdString	name,
		const RTLIL::Wire *	other
	)

Definition at line 1340 of file rtlil.cc.

{
    RTLIL::Wire *wire = addWire(name);
    wire->width = other->width;
    wire->start_offset = other->start_offset;
    wire->port_id = other->port_id;
    wire->port_input = other->port_input;
    wire->port_output = other->port_output;
    wire->upto = other->upto;
    wire->attributes = other->attributes;
    return wire;
}

RTLIL::Cell* RTLIL::Module::addXnor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addXnorGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::Cell* RTLIL::Module::addXor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_y,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::addXorGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_y
	)

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::And	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigBit RTLIL::Module::AndGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b
	)

RTLIL::SigBit RTLIL::Module::Aoi3Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c
	)

RTLIL::SigBit RTLIL::Module::Aoi4Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c,
		RTLIL::SigBit	sig_d
	)

RTLIL::SigSpec RTLIL::Module::Bu0	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

RTLIL::Cell* RTLIL::Module::cell ( RTLIL::IdString  id )

inline

Definition at line 638 of file rtlil.h.

{ return cells_.count(id) ? cells_.at(id) : nullptr; }

Here is the caller graph for this function:

RTLIL::ObjRange<RTLIL::Cell*> RTLIL::Module::cells ( )

inline

Definition at line 641 of file rtlil.h.

{ return RTLIL::ObjRange<RTLIL::Cell*>(&cells_, &refcount_cells_); }

Here is the caller graph for this function:

void RTLIL::Module::check ( )

virtual

Definition at line 948 of file rtlil.cc.

{
#ifndef NDEBUG
    std::vector<bool> ports_declared;
    for (auto &it : wires_) {
        log_assert(this == it.second->module);
        log_assert(it.first == it.second->name);
        log_assert(!it.first.empty());
        log_assert(it.second->width >= 0);
        log_assert(it.second->port_id >= 0);
        for (auto &it2 : it.second->attributes)
            log_assert(!it2.first.empty());
        if (it.second->port_id) {
            log_assert(GetSize(ports) >= it.second->port_id);
            log_assert(ports.at(it.second->port_id-1) == it.first);
            log_assert(it.second->port_input || it.second->port_output);
            if (GetSize(ports_declared) < it.second->port_id)
                ports_declared.resize(it.second->port_id);
            log_assert(ports_declared[it.second->port_id-1] == false);
            ports_declared[it.second->port_id-1] = true;
        } else
            log_assert(!it.second->port_input && !it.second->port_output);
    }
    for (auto port_declared : ports_declared)
        log_assert(port_declared == true);
    log_assert(GetSize(ports) == GetSize(ports_declared));

    for (auto &it : memories) {
        log_assert(it.first == it.second->name);
        log_assert(!it.first.empty());
        log_assert(it.second->width >= 0);
        log_assert(it.second->size >= 0);
        for (auto &it2 : it.second->attributes)
            log_assert(!it2.first.empty());
    }

    for (auto &it : cells_) {
        log_assert(this == it.second->module);
        log_assert(it.first == it.second->name);
        log_assert(!it.first.empty());
        log_assert(!it.second->type.empty());
        for (auto &it2 : it.second->connections()) {
            log_assert(!it2.first.empty());
            it2.second.check();
        }
        for (auto &it2 : it.second->attributes)
            log_assert(!it2.first.empty());
        for (auto &it2 : it.second->parameters)
            log_assert(!it2.first.empty());
        InternalCellChecker checker(this, it.second);
        checker.check();
    }

    for (auto &it : processes) {
        log_assert(it.first == it.second->name);
        log_assert(!it.first.empty());
        // FIXME: More checks here..
    }

    for (auto &it : connections_) {
        log_assert(it.first.size() == it.second.size());
        it.first.check();
        it.second.check();
    }

    for (auto &it : attributes)
        log_assert(!it.first.empty());
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::Module * RTLIL::Module::clone ( ) const

virtual

Reimplemented in AST::AstModule.

Definition at line 1061 of file rtlil.cc.

{
    RTLIL::Module *new_mod = new RTLIL::Module;
    new_mod->name = name;
    cloneInto(new_mod);
    return new_mod;
}

Here is the caller graph for this function:

void RTLIL::Module::cloneInto

(

RTLIL::Module *

new_mod

)

const

Definition at line 1022 of file rtlil.cc.

{
    log_assert(new_mod->refcount_wires_ == 0);
    log_assert(new_mod->refcount_cells_ == 0);

    new_mod->connections_ = connections_;
    new_mod->attributes = attributes;

    for (auto &it : wires_)
        new_mod->addWire(it.first, it.second);

    for (auto &it : memories)
        new_mod->memories[it.first] = new RTLIL::Memory(*it.second);

    for (auto &it : cells_)
        new_mod->addCell(it.first, it.second);

    for (auto &it : processes)
        new_mod->processes[it.first] = it.second->clone();

    struct RewriteSigSpecWorker
    {
        RTLIL::Module *mod;
        void operator()(RTLIL::SigSpec &sig)
        {
            std::vector<RTLIL::SigChunk> chunks = sig.chunks();
            for (auto &c : chunks)
                if (c.wire != NULL)
                    c.wire = mod->wires_.at(c.wire->name);
            sig = chunks;
        }
    };

    RewriteSigSpecWorker rewriteSigSpecWorker;
    rewriteSigSpecWorker.mod = new_mod;
    new_mod->rewrite_sigspecs(rewriteSigSpecWorker);
    new_mod->fixup_ports();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void RTLIL::Module::connect

(

const RTLIL::SigSig &

conn

)

Definition at line 1278 of file rtlil.cc.

{
    for (auto mon : monitors)
        mon->notify_connect(this, conn);

    if (design)
        for (auto mon : design->monitors)
            mon->notify_connect(this, conn);

    connections_.push_back(conn);
}

Here is the caller graph for this function:

void RTLIL::Module::connect	(	const RTLIL::SigSpec &	lhs,
		const RTLIL::SigSpec &	rhs
	)

Definition at line 1290 of file rtlil.cc.

{
    connect(RTLIL::SigSig(lhs, rhs));
}

const std::vector< RTLIL::SigSig > & RTLIL::Module::connections

(

)

const

Definition at line 1307 of file rtlil.cc.

{
    return connections_;
}

Here is the caller graph for this function:

size_t RTLIL::Module::count_id ( RTLIL::IdString  id )

virtual

Definition at line 472 of file rtlil.cc.

{
    return wires_.count(id) + memories.count(id) + cells_.count(id) + processes.count(id);
}

Here is the caller graph for this function:

RTLIL::IdString RTLIL::Module::derive ( RTLIL::Design *  design, std::map< RTLIL::IdString, RTLIL::Const >  parameters  )

virtual

Definition at line 467 of file rtlil.cc.

{
    log_error("Module `%s' is used with parameters but is not parametric!\n", id2cstr(name));
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::Div	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Eq	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::Eqx	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

void RTLIL::Module::fixup_ports

(

)

Definition at line 1312 of file rtlil.cc.

{
    std::vector<RTLIL::Wire*> all_ports;

    for (auto &w : wires_)
        if (w.second->port_input || w.second->port_output)
            all_ports.push_back(w.second);
        else
            w.second->port_id = 0;

    std::sort(all_ports.begin(), all_ports.end(), fixup_ports_compare);

    ports.clear();
    for (size_t i = 0; i < all_ports.size(); i++) {
        ports.push_back(all_ports[i]->name);
        all_ports[i]->port_id = i+1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::Ge	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Gt	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

bool RTLIL::Module::has_memories

(

)

const

Definition at line 1069 of file rtlil.cc.

{
    return !memories.empty();
}

bool RTLIL::Module::has_memories_warn

(

)

const

Definition at line 1079 of file rtlil.cc.

{
    if (!memories.empty())
        log_warning("Ignoring module %s because it contains memories (run 'memory' command first).\n", log_id(this));
    return !memories.empty();
}

Here is the call graph for this function:

bool RTLIL::Module::has_processes

(

)

const

Definition at line 1074 of file rtlil.cc.

{
    return !processes.empty();
}

bool RTLIL::Module::has_processes_warn

(

)

const

Definition at line 1086 of file rtlil.cc.

{
    if (!processes.empty())
        log_warning("Ignoring module %s because it contains processes (run 'proc' command first).\n", log_id(this));
    return !processes.empty();
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::Le	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::LogicAnd	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::LogicNot	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::LogicOr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Lt	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Mod	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Mul	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Mux	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_s
	)

Here is the caller graph for this function:

RTLIL::SigBit RTLIL::Module::MuxGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_s
	)

RTLIL::SigBit RTLIL::Module::NandGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b
	)

RTLIL::SigSpec RTLIL::Module::Ne	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::Neg	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

void RTLIL::Module::new_connections

(

const std::vector< RTLIL::SigSig > &

new_conn

)

Definition at line 1295 of file rtlil.cc.

{
    for (auto mon : monitors)
        mon->notify_connect(this, new_conn);

    if (design)
        for (auto mon : design->monitors)
            mon->notify_connect(this, new_conn);

    connections_ = new_conn;
}

RTLIL::SigSpec RTLIL::Module::Nex	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigBit RTLIL::Module::NorGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b
	)

RTLIL::SigSpec RTLIL::Module::Not	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigBit RTLIL::Module::NotGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a
	)

Here is the caller graph for this function:

RTLIL::SigBit RTLIL::Module::Oai3Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c
	)

RTLIL::SigBit RTLIL::Module::Oai4Gate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b,
		RTLIL::SigBit	sig_c,
		RTLIL::SigBit	sig_d
	)

void RTLIL::Module::optimize ( )

virtual

Definition at line 1018 of file rtlil.cc.

{
}

RTLIL::SigSpec RTLIL::Module::Or	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigBit RTLIL::Module::OrGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b
	)

RTLIL::SigSpec RTLIL::Module::Pmux	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		RTLIL::SigSpec	sig_s
	)

RTLIL::SigSpec RTLIL::Module::Pos	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Pow	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	a_signed = false,
		bool	b_signed = false
	)

RTLIL::SigSpec RTLIL::Module::ReduceAnd	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::ReduceBool	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::ReduceOr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::ReduceXnor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::ReduceXor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		bool	is_signed = false
	)

void RTLIL::Module::remove

(

const std::set< RTLIL::Wire * > &

wires

)

Definition at line 1158 of file rtlil.cc.

{
    log_assert(refcount_wires_ == 0);

    DeleteWireWorker delete_wire_worker;
    delete_wire_worker.module = this;
    delete_wire_worker.wires_p = &wires;
    rewrite_sigspecs(delete_wire_worker);

    for (auto &it : wires) {
        log_assert(wires_.count(it->name) != 0);
        wires_.erase(it->name);
        delete it;
    }
}

Here is the caller graph for this function:

void RTLIL::Module::remove

(

RTLIL::Cell *

cell

)

Definition at line 1174 of file rtlil.cc.

{
    while (!cell->connections_.empty())
        cell->unsetPort(cell->connections_.begin()->first);

    log_assert(cells_.count(cell->name) != 0);
    log_assert(refcount_cells_ == 0);
    cells_.erase(cell->name);
    delete cell;
}

Here is the call graph for this function:

void RTLIL::Module::rename	(	RTLIL::Wire *	wire,
		RTLIL::IdString	new_name
	)

Definition at line 1185 of file rtlil.cc.

{
    log_assert(wires_[wire->name] == wire);
    log_assert(refcount_wires_ == 0);
    wires_.erase(wire->name);
    wire->name = new_name;
    add(wire);
}

Here is the caller graph for this function:

void RTLIL::Module::rename	(	RTLIL::Cell *	cell,
		RTLIL::IdString	new_name
	)

Definition at line 1194 of file rtlil.cc.

{
    log_assert(cells_[cell->name] == cell);
    log_assert(refcount_wires_ == 0);
    cells_.erase(cell->name);
    cell->name = new_name;
    add(cell);
}

void RTLIL::Module::rename	(	RTLIL::IdString	old_name,
		RTLIL::IdString	new_name
	)

Definition at line 1203 of file rtlil.cc.

{
    log_assert(count_id(old_name) != 0);
    if (wires_.count(old_name))
        rename(wires_.at(old_name), new_name);
    else if (cells_.count(old_name))
        rename(cells_.at(old_name), new_name);
    else
        log_abort();
}

template<typename T >

void RTLIL::Module::rewrite_sigspecs

(

T

functor

)

Definition at line 1166 of file rtlil.h.

{
    for (auto &it : cells_)
        it.second->rewrite_sigspecs(functor);
    for (auto &it : processes)
        it.second->rewrite_sigspecs(functor);
    for (auto &it : connections_) {
        functor(it.first);
        functor(it.second);
    }
}

Here is the caller graph for this function:

template<typename T >

bool RTLIL::Module::selected ( T *  member ) const

inline

Definition at line 633 of file rtlil.h.

                                                        {
        return design->selected_member(name, member->name);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< RTLIL::Cell * > RTLIL::Module::selected_cells

(

)

const

Definition at line 1103 of file rtlil.cc.

{
    std::vector<RTLIL::Cell*> result;
    result.reserve(wires_.size());
    for (auto &it : cells_)
        if (design->selected(this, it.second))
            result.push_back(it.second);
    return result;
}

Here is the caller graph for this function:

std::vector< RTLIL::Wire * > RTLIL::Module::selected_wires

(

)

const

Definition at line 1093 of file rtlil.cc.

{
    std::vector<RTLIL::Wire*> result;
    result.reserve(wires_.size());
    for (auto &it : wires_)
        if (design->selected(this, it.second))
            result.push_back(it.second);
    return result;
}

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::Shift	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Shiftx	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Shl	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Shr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Sshl	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Sshr	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigSpec RTLIL::Module::Sub	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

Here is the caller graph for this function:

void RTLIL::Module::swap_names	(	RTLIL::Wire *	w1,
		RTLIL::Wire *	w2
	)

Definition at line 1214 of file rtlil.cc.

{
    log_assert(wires_[w1->name] == w1);
    log_assert(wires_[w2->name] == w2);
    log_assert(refcount_wires_ == 0);

    wires_.erase(w1->name);
    wires_.erase(w2->name);

    std::swap(w1->name, w2->name);

    wires_[w1->name] = w1;
    wires_[w2->name] = w2;
}

Here is the caller graph for this function:

void RTLIL::Module::swap_names	(	RTLIL::Cell *	c1,
		RTLIL::Cell *	c2
	)

Definition at line 1229 of file rtlil.cc.

{
    log_assert(cells_[c1->name] == c1);
    log_assert(cells_[c2->name] == c2);
    log_assert(refcount_cells_ == 0);

    cells_.erase(c1->name);
    cells_.erase(c2->name);

    std::swap(c1->name, c2->name);

    cells_[c1->name] = c1;
    cells_[c2->name] = c2;
}

RTLIL::IdString RTLIL::Module::uniquify

(

RTLIL::IdString

name

)

Definition at line 1244 of file rtlil.cc.

{
    int index = 0;
    return uniquify(name, index);
}

Here is the caller graph for this function:

RTLIL::IdString RTLIL::Module::uniquify	(	RTLIL::IdString	name,
		int &	index
	)

Definition at line 1250 of file rtlil.cc.

{
    if (index == 0) {
        if (count_id(name) == 0)
            return name;
        index++;
    }

    while (1) {
        RTLIL::IdString new_name = stringf("%s_%d", name.c_str(), index);
        if (count_id(new_name) == 0)
            return new_name;
        index++;
    }
}

Here is the call graph for this function:

RTLIL::Wire* RTLIL::Module::wire ( RTLIL::IdString  id )

inline

Definition at line 637 of file rtlil.h.

{ return wires_.count(id) ? wires_.at(id) : nullptr; }

Here is the caller graph for this function:

RTLIL::ObjRange<RTLIL::Wire*> RTLIL::Module::wires ( )

inline

Definition at line 640 of file rtlil.h.

{ return RTLIL::ObjRange<RTLIL::Wire*>(&wires_, &refcount_wires_); }

Here is the caller graph for this function:

RTLIL::SigSpec RTLIL::Module::Xnor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

RTLIL::SigBit RTLIL::Module::XnorGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b
	)

RTLIL::SigSpec RTLIL::Module::Xor	(	RTLIL::IdString	name,
		RTLIL::SigSpec	sig_a,
		RTLIL::SigSpec	sig_b,
		bool	is_signed = false
	)

Here is the caller graph for this function:

RTLIL::SigBit RTLIL::Module::XorGate	(	RTLIL::IdString	name,
		RTLIL::SigBit	sig_a,
		RTLIL::SigBit	sig_b
	)

Field Documentation

std::set<RTLIL::IdString> RTLIL::Module::avail_parameters

Definition at line 600 of file rtlil.h.

std::map<RTLIL::IdString, RTLIL::Cell*> RTLIL::Module::cells_

Definition at line 596 of file rtlil.h.

std::vector<RTLIL::SigSig> RTLIL::Module::connections_

Definition at line 597 of file rtlil.h.

RTLIL::Design* RTLIL::Module::design

Definition at line 589 of file rtlil.h.

std::map<RTLIL::IdString, RTLIL::Memory*> RTLIL::Module::memories

Definition at line 601 of file rtlil.h.

std::set<RTLIL::Monitor*> RTLIL::Module::monitors

Definition at line 590 of file rtlil.h.

RTLIL::IdString RTLIL::Module::name

Definition at line 599 of file rtlil.h.

std::vector<RTLIL::IdString> RTLIL::Module::ports

Definition at line 617 of file rtlil.h.

std::map<RTLIL::IdString, RTLIL::Process*> RTLIL::Module::processes

Definition at line 602 of file rtlil.h.

int RTLIL::Module::refcount_cells_

Definition at line 593 of file rtlil.h.

int RTLIL::Module::refcount_wires_

Definition at line 592 of file rtlil.h.

std::map<RTLIL::IdString, RTLIL::Wire*> RTLIL::Module::wires_

Definition at line 595 of file rtlil.h.

---

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

• rtlil.h
• rtlil.cc