RTLIL::Design Struct Reference

#include <rtlil.h>

Public Member Functions
	Design ()
	~Design ()
RTLIL::ObjRange< RTLIL::Module * >	modules ()
RTLIL::Module *	module (RTLIL::IdString name)
bool	has (RTLIL::IdString id) const
void	add (RTLIL::Module *module)
RTLIL::Module *	addModule (RTLIL::IdString name)
void	remove (RTLIL::Module *module)
void	scratchpad_unset (std::string varname)
void	scratchpad_set_int (std::string varname, int value)
void	scratchpad_set_bool (std::string varname, bool value)
void	scratchpad_set_string (std::string varname, std::string value)
int	scratchpad_get_int (std::string varname, int default_value=0) const
bool	scratchpad_get_bool (std::string varname, bool default_value=false) const
std::string	scratchpad_get_string (std::string varname, std::string default_value=std::string()) const
void	check ()
void	optimize ()
bool	selected_module (RTLIL::IdString mod_name) const
bool	selected_whole_module (RTLIL::IdString mod_name) const
bool	selected_member (RTLIL::IdString mod_name, RTLIL::IdString memb_name) const
bool	selected_module (RTLIL::Module *mod) const
bool	selected_whole_module (RTLIL::Module *mod) const
bool	full_selection () const
template<typename T1 >
bool	selected (T1 *module) const
template<typename T1 , typename T2 >
bool	selected (T1 *module, T2 *member) const
template<typename T1 , typename T2 >
void	select (T1 *module, T2 *member)
std::vector< RTLIL::Module * >	selected_modules () const
std::vector< RTLIL::Module * >	selected_whole_modules () const
std::vector< RTLIL::Module * >	selected_whole_modules_warn () const

Data Fields
std::set< RTLIL::Monitor * >	monitors
std::map< std::string, std::string >	scratchpad
int	refcount_modules_
std::map< RTLIL::IdString, RTLIL::Module * >	modules_
std::vector< RTLIL::Selection >	selection_stack
std::map< RTLIL::IdString, RTLIL::Selection >	selection_vars
std::string	selected_active_module

Detailed Description

Definition at line 501 of file rtlil.h.

Constructor & Destructor Documentation

RTLIL::Design::Design

(

)

Definition at line 237 of file rtlil.cc.

{
    refcount_modules_ = 0;
    selection_stack.push_back(RTLIL::Selection());
}

RTLIL::Design::~Design

(

)

Definition at line 243 of file rtlil.cc.

{
    for (auto it = modules_.begin(); it != modules_.end(); it++)
        delete it->second;
}

Member Function Documentation

void RTLIL::Design::add

(

RTLIL::Module *

module

)

Definition at line 259 of file rtlil.cc.

{
    log_assert(modules_.count(module->name) == 0);
    log_assert(refcount_modules_ == 0);
    modules_[module->name] = module;
    module->design = this;

    for (auto mon : monitors)
        mon->notify_module_add(module);
}

Here is the caller graph for this function:

RTLIL::Module * RTLIL::Design::addModule

(

RTLIL::IdString

name

)

Definition at line 270 of file rtlil.cc.

{
    log_assert(modules_.count(name) == 0);
    log_assert(refcount_modules_ == 0);

    RTLIL::Module *module = new RTLIL::Module;
    modules_[name] = module;
    module->design = this;
    module->name = name;

    for (auto mon : monitors)
        mon->notify_module_add(module);

    return module;
}

Here is the caller graph for this function:

void RTLIL::Design::check

(

)

Definition at line 357 of file rtlil.cc.

{
#ifndef NDEBUG
    for (auto &it : modules_) {
        log_assert(this == it.second->design);
        log_assert(it.first == it.second->name);
        log_assert(!it.first.empty());
        it.second->check();
    }
#endif
}

Here is the caller graph for this function:

bool RTLIL::Design::full_selection ( ) const

inline

Definition at line 547 of file rtlil.h.

                                {
        return selection_stack.back().full_selection;
    }

Here is the caller graph for this function:

bool RTLIL::Design::has ( RTLIL::IdString  id ) const

inline

Definition at line 519 of file rtlil.h.

                                     {
        return modules_.count(id) != 0;
    }

Here is the caller graph for this function:

RTLIL::Module * RTLIL::Design::module

(

RTLIL::IdString

name

)

Definition at line 254 of file rtlil.cc.

{
    return modules_.count(name) ? modules_.at(name) : NULL;
}

Here is the caller graph for this function:

RTLIL::ObjRange< RTLIL::Module * > RTLIL::Design::modules

(

)

Definition at line 249 of file rtlil.cc.

{
    return RTLIL::ObjRange<RTLIL::Module*>(&modules_, &refcount_modules_);
}

Here is the caller graph for this function:

void RTLIL::Design::optimize

(

)

Definition at line 369 of file rtlil.cc.

{
    for (auto &it : modules_)
        it.second->optimize();
    for (auto &it : selection_stack)
        it.optimize(this);
    for (auto &it : selection_vars)
        it.second.optimize(this);
}

Here is the caller graph for this function:

void RTLIL::Design::remove

(

RTLIL::Module *

module

)

Definition at line 347 of file rtlil.cc.

{
    for (auto mon : monitors)
        mon->notify_module_del(module);

    log_assert(modules_.at(module->name) == module);
    modules_.erase(module->name);
    delete module;
}

Here is the caller graph for this function:

bool RTLIL::Design::scratchpad_get_bool	(	std::string	varname,
		bool	default_value = false
	)		const

Definition at line 324 of file rtlil.cc.

{
    if (scratchpad.count(varname) == 0)
        return default_value;

    std::string str = scratchpad.at(varname);

    if (str == "0" || str == "false")
        return false;

    if (str == "1" || str == "true")
        return true;

    return default_value;
}

Here is the caller graph for this function:

int RTLIL::Design::scratchpad_get_int	(	std::string	varname,
		int	default_value = 0
	)		const

Definition at line 306 of file rtlil.cc.

{
    if (scratchpad.count(varname) == 0)
        return default_value;

    std::string str = scratchpad.at(varname);

    if (str == "0" || str == "false")
        return 0;

    if (str == "1" || str == "true")
        return 1;

    char *endptr = nullptr;
    long int parsed_value = strtol(str.c_str(), &endptr, 10);
    return *endptr ? default_value : parsed_value;
}

std::string RTLIL::Design::scratchpad_get_string	(	std::string	varname,
		std::string	default_value = std::string()
	)		const

Definition at line 340 of file rtlil.cc.

{
    if (scratchpad.count(varname) == 0)
        return default_value;
    return scratchpad.at(varname);
}

void RTLIL::Design::scratchpad_set_bool	(	std::string	varname,
		bool	value
	)

Definition at line 296 of file rtlil.cc.

{
    scratchpad[varname] = value ? "true" : "false";
}

Here is the caller graph for this function:

void RTLIL::Design::scratchpad_set_int	(	std::string	varname,
		int	value
	)

Definition at line 291 of file rtlil.cc.

{
    scratchpad[varname] = stringf("%d", value);
}

Here is the call graph for this function:

void RTLIL::Design::scratchpad_set_string	(	std::string	varname,
		std::string	value
	)

Definition at line 301 of file rtlil.cc.

{
    scratchpad[varname] = value;
}

void RTLIL::Design::scratchpad_unset

(

std::string

varname

)

Definition at line 286 of file rtlil.cc.

{
    scratchpad.erase(varname);
}

Here is the caller graph for this function:

template<typename T1 , typename T2 >

void RTLIL::Design::select ( T1 *  module, T2 *  member  )

inline

Definition at line 559 of file rtlil.h.

                                                                           {
        if (selection_stack.size() > 0) {
            RTLIL::Selection &sel = selection_stack.back();
            sel.select(module, member);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T1 >

bool RTLIL::Design::selected ( T1 *  module ) const

inline

Definition at line 551 of file rtlil.h.

                                                          {
        return selected_module(module->name);
    }

Here is the call graph for this function:

template<typename T1 , typename T2 >

bool RTLIL::Design::selected ( T1 *  module, T2 *  member  ) const

inline

Definition at line 555 of file rtlil.h.

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

Here is the call graph for this function:

bool RTLIL::Design::selected_member	(	RTLIL::IdString	mod_name,
		RTLIL::IdString	memb_name
	)		const

Definition at line 397 of file rtlil.cc.

{
    if (!selected_active_module.empty() && mod_name != selected_active_module)
        return false;
    if (selection_stack.size() == 0)
        return true;
    return selection_stack.back().selected_member(mod_name, memb_name);
}

Here is the caller graph for this function:

bool RTLIL::Design::selected_module

(

RTLIL::IdString

mod_name

)

const

Definition at line 379 of file rtlil.cc.

{
    if (!selected_active_module.empty() && mod_name != selected_active_module)
        return false;
    if (selection_stack.size() == 0)
        return true;
    return selection_stack.back().selected_module(mod_name);
}

Here is the caller graph for this function:

bool RTLIL::Design::selected_module

(

RTLIL::Module *

mod

)

const

Definition at line 406 of file rtlil.cc.

{
    return selected_module(mod->name);
}

std::vector< RTLIL::Module * > RTLIL::Design::selected_modules

(

)

const

Definition at line 416 of file rtlil.cc.

{
    std::vector<RTLIL::Module*> result;
    result.reserve(modules_.size());
    for (auto &it : modules_)
        if (selected_module(it.first))
            result.push_back(it.second);
    return result;
}

Here is the caller graph for this function:

bool RTLIL::Design::selected_whole_module

(

RTLIL::IdString

mod_name

)

const

Definition at line 388 of file rtlil.cc.

{
    if (!selected_active_module.empty() && mod_name != selected_active_module)
        return false;
    if (selection_stack.size() == 0)
        return true;
    return selection_stack.back().selected_whole_module(mod_name);
}

Here is the caller graph for this function:

bool RTLIL::Design::selected_whole_module

(

RTLIL::Module *

mod

)

const

Definition at line 411 of file rtlil.cc.

{
    return selected_whole_module(mod->name);
}

std::vector< RTLIL::Module * > RTLIL::Design::selected_whole_modules

(

)

const

Definition at line 426 of file rtlil.cc.

{
    std::vector<RTLIL::Module*> result;
    result.reserve(modules_.size());
    for (auto &it : modules_)
        if (selected_whole_module(it.first))
            result.push_back(it.second);
    return result;
}

std::vector< RTLIL::Module * > RTLIL::Design::selected_whole_modules_warn

(

)

const

Definition at line 436 of file rtlil.cc.

{
    std::vector<RTLIL::Module*> result;
    result.reserve(modules_.size());
    for (auto &it : modules_)
        if (selected_whole_module(it.first))
            result.push_back(it.second);
        else if (selected_module(it.first))
            log_warning("Ignoring partially selected module %s.\n", log_id(it.first));
    return result;
}

Here is the call graph for this function:

Field Documentation

std::map<RTLIL::IdString, RTLIL::Module*> RTLIL::Design::modules_

Definition at line 507 of file rtlil.h.

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

Definition at line 503 of file rtlil.h.

int RTLIL::Design::refcount_modules_

Definition at line 506 of file rtlil.h.

std::map<std::string, std::string> RTLIL::Design::scratchpad

Definition at line 504 of file rtlil.h.

std::string RTLIL::Design::selected_active_module

Definition at line 511 of file rtlil.h.

std::vector<RTLIL::Selection> RTLIL::Design::selection_stack

Definition at line 509 of file rtlil.h.

std::map<RTLIL::IdString, RTLIL::Selection> RTLIL::Design::selection_vars

Definition at line 510 of file rtlil.h.

---

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

• rtlil.h
• rtlil.cc