mirrors/yosys
3
0
Fork 0
mirror of https://github.com/YosysHQ/yosys synced 2025-04-06 17:44:09 +00:00
Code Activity

Added Yosys::{dict,nodict,vector} container types

Browse source
This commit is contained in:
Clifford Wolf 2014-12-26 10:53:21 +01:00
parent e8c12e5f0c
commit a6c96b986b
21 changed files with 495 additions and 331 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
backends/verilog/verilog_backend.cc
View file

@ -246,7 +246,7 @@ void dump_sigspec(std::ostream &f, const RTLIL::SigSpec &sig)
} }
} }
void dump_attributes(std::ostream &f, std::string indent, std::map<RTLIL::IdString, RTLIL::Const> &attributes, char term = '\n') void dump_attributes(std::ostream &f, std::string indent, dict<RTLIL::IdString, RTLIL::Const> &attributes, char term = '\n')
{ {
if (noattr) if (noattr)
return; return;

2
frontends/ast/ast.cc
View file

@ -1018,7 +1018,7 @@ AstModule::~AstModule()
} }
// create a new parametric module (when needed) and return the name of the generated module // create a new parametric module (when needed) and return the name of the generated module
RTLIL::IdString AstModule::derive(RTLIL::Design *design, std::map<RTLIL::IdString, RTLIL::Const> parameters) RTLIL::IdString AstModule::derive(RTLIL::Design *design, dict<RTLIL::IdString, RTLIL::Const> parameters)
{ {
std::string stripped_name = name.str(); std::string stripped_name = name.str();

2
frontends/ast/ast.h
View file

@ -268,7 +268,7 @@ namespace AST
AstNode *ast; AstNode *ast;
bool nolatches, nomem2reg, mem2reg, lib, noopt, icells, autowire; bool nolatches, nomem2reg, mem2reg, lib, noopt, icells, autowire;
virtual ~AstModule(); virtual ~AstModule();
virtual RTLIL::IdString derive(RTLIL::Design *design, std::map<RTLIL::IdString, RTLIL::Const> parameters); virtual RTLIL::IdString derive(RTLIL::Design *design, dict<RTLIL::IdString, RTLIL::Const> parameters);
virtual RTLIL::Module *clone() const; virtual RTLIL::Module *clone() const;
}; };

2
frontends/ilang/ilang_parser.y
View file

@ -36,7 +36,7 @@ namespace ILANG_FRONTEND {
RTLIL::Process *current_process; RTLIL::Process *current_process;
std::vector<std::vector<RTLIL::SwitchRule*>*> switch_stack; std::vector<std::vector<RTLIL::SwitchRule*>*> switch_stack;
std::vector<RTLIL::CaseRule*> case_stack; std::vector<RTLIL::CaseRule*> case_stack;
std::map<RTLIL::IdString, RTLIL::Const> attrbuf; dict<RTLIL::IdString, RTLIL::Const> attrbuf;
} }
using namespace ILANG_FRONTEND; using namespace ILANG_FRONTEND;
YOSYS_NAMESPACE_END YOSYS_NAMESPACE_END

12
kernel/cost.h
View file

@ -24,12 +24,12 @@
YOSYS_NAMESPACE_BEGIN YOSYS_NAMESPACE_BEGIN
int get_cell_cost(RTLIL::Cell *cell, std::map<RTLIL::Module*, int> *mod_cost_cache = nullptr); int get_cell_cost(RTLIL::Cell *cell, dict<RTLIL::Module*, int> *mod_cost_cache = nullptr);
int get_cell_cost(RTLIL::IdString type, const std::map<RTLIL::IdString, RTLIL::Const> &parameters = std::map<RTLIL::IdString, RTLIL::Const>(), int get_cell_cost(RTLIL::IdString type, const dict<RTLIL::IdString, RTLIL::Const> &parameters = dict<RTLIL::IdString, RTLIL::Const>(),
RTLIL::Design *design = nullptr, std::map<RTLIL::Module*, int> *mod_cost_cache = nullptr) RTLIL::Design *design = nullptr, dict<RTLIL::Module*, int> *mod_cost_cache = nullptr)
{ {
static std::map<RTLIL::IdString, int> gate_cost = { static dict<RTLIL::IdString, int> gate_cost = {
{ "$_BUF_", 1 }, { "$_BUF_", 1 },
{ "$_NOT_", 2 }, { "$_NOT_", 2 },
{ "$_AND_", 4 }, { "$_AND_", 4 },
@ -55,7 +55,7 @@ int get_cell_cost(RTLIL::IdString type, const std::map<RTLIL::IdString, RTLIL::C
if (mod->attributes.count("\\cost")) if (mod->attributes.count("\\cost"))
return mod->attributes.at("\\cost").as_int(); return mod->attributes.at("\\cost").as_int();
std::map<RTLIL::Module*, int> local_mod_cost_cache; dict<RTLIL::Module*, int> local_mod_cost_cache;
if (mod_cost_cache == nullptr) if (mod_cost_cache == nullptr)
mod_cost_cache = &local_mod_cost_cache; mod_cost_cache = &local_mod_cost_cache;
@ -74,7 +74,7 @@ int get_cell_cost(RTLIL::IdString type, const std::map<RTLIL::IdString, RTLIL::C
return 1; return 1;
} }
int get_cell_cost(RTLIL::Cell *cell, std::map<RTLIL::Module*, int> *mod_cost_cache) int get_cell_cost(RTLIL::Cell *cell, dict<RTLIL::Module*, int> *mod_cost_cache)
{ {
return get_cell_cost(cell->type, cell->parameters, cell->module->design, mod_cost_cache); return get_cell_cost(cell->type, cell->parameters, cell->module->design, mod_cost_cache);
} }

100
kernel/rtlil.cc
View file

@ -30,7 +30,7 @@ YOSYS_NAMESPACE_BEGIN
RTLIL::IdString::destruct_guard_t RTLIL::IdString::destruct_guard; RTLIL::IdString::destruct_guard_t RTLIL::IdString::destruct_guard;
std::vector<int> RTLIL::IdString::global_refcount_storage_; std::vector<int> RTLIL::IdString::global_refcount_storage_;
std::vector<char*> RTLIL::IdString::global_id_storage_; std::vector<char*> RTLIL::IdString::global_id_storage_;
std::map<char*, int, RTLIL::IdString::char_ptr_cmp> RTLIL::IdString::global_id_index_; dict<char*, int, RTLIL::IdString::char_ptr_hash, RTLIL::IdString::char_ptr_eq> RTLIL::IdString::global_id_index_;
std::vector<int> RTLIL::IdString::global_free_idx_list_; std::vector<int> RTLIL::IdString::global_free_idx_list_;
RTLIL::Const::Const() RTLIL::Const::Const()
@ -464,7 +464,7 @@ RTLIL::Module::~Module()
delete it->second; delete it->second;
} }
RTLIL::IdString RTLIL::Module::derive(RTLIL::Design*, std::map<RTLIL::IdString, RTLIL::Const>) RTLIL::IdString RTLIL::Module::derive(RTLIL::Design*, dict<RTLIL::IdString, RTLIL::Const>)
{ {
log_error("Module `%s' is used with parameters but is not parametric!\n", id2cstr(name)); log_error("Module `%s' is used with parameters but is not parametric!\n", id2cstr(name));
} }
@ -480,7 +480,7 @@ namespace {
{ {
RTLIL::Module *module; RTLIL::Module *module;
RTLIL::Cell *cell; RTLIL::Cell *cell;
std::set<RTLIL::IdString> expected_params, expected_ports; nodict<RTLIL::IdString> expected_params, expected_ports;
InternalCellChecker(RTLIL::Module *module, RTLIL::Cell *cell) : module(module), cell(cell) { } InternalCellChecker(RTLIL::Module *module, RTLIL::Cell *cell) : module(module), cell(cell) { }
@ -1132,7 +1132,7 @@ namespace {
struct DeleteWireWorker struct DeleteWireWorker
{ {
RTLIL::Module *module; RTLIL::Module *module;
const std::set<RTLIL::Wire*> *wires_p; const nodict<RTLIL::Wire*> *wires_p;
void operator()(RTLIL::SigSpec &sig) { void operator()(RTLIL::SigSpec &sig) {
std::vector<RTLIL::SigChunk> chunks = sig; std::vector<RTLIL::SigChunk> chunks = sig;
@ -1146,16 +1146,7 @@ namespace {
}; };
} }
#if 0 void RTLIL::Module::remove(const nodict<RTLIL::Wire*> &wires)
void RTLIL::Module::remove(RTLIL::Wire *wire)
{
std::setPort<RTLIL::Wire*> wires_;
wires_.insert(wire);
remove(wires_);
}
#endif
void RTLIL::Module::remove(const std::set<RTLIL::Wire*> &wires)
{ {
log_assert(refcount_wires_ == 0); log_assert(refcount_wires_ == 0);
@ -1811,7 +1802,7 @@ const RTLIL::SigSpec &RTLIL::Cell::getPort(RTLIL::IdString portname) const
return connections_.at(portname); return connections_.at(portname);
} }
const std::map<RTLIL::IdString, RTLIL::SigSpec> &RTLIL::Cell::connections() const const dict<RTLIL::IdString, RTLIL::SigSpec> &RTLIL::Cell::connections() const
{ {
return connections_; return connections_;
} }
@ -2178,6 +2169,17 @@ RTLIL::SigSpec::SigSpec(std::vector<RTLIL::SigBit> bits)
check(); check();
} }
RTLIL::SigSpec::SigSpec(nodict<RTLIL::SigBit> bits)
{
cover("kernel.rtlil.sigspec.init.stdset_bits");
width_ = 0;
hash_ = 0;
for (auto &bit : bits)
append_bit(bit);
check();
}
RTLIL::SigSpec::SigSpec(std::set<RTLIL::SigBit> bits) RTLIL::SigSpec::SigSpec(std::set<RTLIL::SigBit> bits)
{ {
cover("kernel.rtlil.sigspec.init.stdset_bits"); cover("kernel.rtlil.sigspec.init.stdset_bits");
@ -2306,7 +2308,7 @@ void RTLIL::SigSpec::replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec
pattern.unpack(); pattern.unpack();
with.unpack(); with.unpack();
std::map<RTLIL::SigBit, RTLIL::SigBit> rules; dict<RTLIL::SigBit, RTLIL::SigBit> rules;
for (int i = 0; i < GetSize(pattern.bits_); i++) for (int i = 0; i < GetSize(pattern.bits_); i++)
if (pattern.bits_[i].wire != NULL) if (pattern.bits_[i].wire != NULL)
@ -2315,6 +2317,30 @@ void RTLIL::SigSpec::replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec
replace(rules, other); replace(rules, other);
} }
void RTLIL::SigSpec::replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules)
{
replace(rules, this);
}
void RTLIL::SigSpec::replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const
{
cover("kernel.rtlil.sigspec.replace_dict");
log_assert(other != NULL);
log_assert(width_ == other->width_);
unpack();
other->unpack();
for (int i = 0; i < GetSize(bits_); i++) {
auto it = rules.find(bits_[i]);
if (it != rules.end())
other->bits_[i] = it->second;
}
other->check();
}
void RTLIL::SigSpec::replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules) void RTLIL::SigSpec::replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules)
{ {
replace(rules, this); replace(rules, this);
@ -2322,7 +2348,7 @@ void RTLIL::SigSpec::replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules
void RTLIL::SigSpec::replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const void RTLIL::SigSpec::replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const
{ {
cover("kernel.rtlil.sigspec.replace"); cover("kernel.rtlil.sigspec.replace_map");
log_assert(other != NULL); log_assert(other != NULL);
log_assert(width_ == other->width_); log_assert(width_ == other->width_);
@ -2352,22 +2378,22 @@ void RTLIL::SigSpec::remove(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other
void RTLIL::SigSpec::remove2(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other) void RTLIL::SigSpec::remove2(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other)
{ {
std::set<RTLIL::SigBit> pattern_bits = pattern.to_sigbit_set(); nodict<RTLIL::SigBit> pattern_bits = pattern.to_sigbit_nodict();
remove2(pattern_bits, other); remove2(pattern_bits, other);
} }
void RTLIL::SigSpec::remove(const std::set<RTLIL::SigBit> &pattern) void RTLIL::SigSpec::remove(const nodict<RTLIL::SigBit> &pattern)
{ {
remove2(pattern, NULL); remove2(pattern, NULL);
} }
void RTLIL::SigSpec::remove(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) const void RTLIL::SigSpec::remove(const nodict<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) const
{ {
RTLIL::SigSpec tmp = *this; RTLIL::SigSpec tmp = *this;
tmp.remove2(pattern, other); tmp.remove2(pattern, other);
} }
void RTLIL::SigSpec::remove2(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) void RTLIL::SigSpec::remove2(const nodict<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other)
{ {
if (other) if (other)
cover("kernel.rtlil.sigspec.remove_other"); cover("kernel.rtlil.sigspec.remove_other");
@ -2413,11 +2439,11 @@ void RTLIL::SigSpec::remove2(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigS
RTLIL::SigSpec RTLIL::SigSpec::extract(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec *other) const RTLIL::SigSpec RTLIL::SigSpec::extract(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec *other) const
{ {
std::set<RTLIL::SigBit> pattern_bits = pattern.to_sigbit_set(); nodict<RTLIL::SigBit> pattern_bits = pattern.to_sigbit_nodict();
return extract(pattern_bits, other); return extract(pattern_bits, other);
} }
RTLIL::SigSpec RTLIL::SigSpec::extract(const std::set<RTLIL::SigBit> &pattern, const RTLIL::SigSpec *other) const RTLIL::SigSpec RTLIL::SigSpec::extract(const nodict<RTLIL::SigBit> &pattern, const RTLIL::SigSpec *other) const
{ {
if (other) if (other)
cover("kernel.rtlil.sigspec.extract_other"); cover("kernel.rtlil.sigspec.extract_other");
@ -2917,6 +2943,18 @@ std::set<RTLIL::SigBit> RTLIL::SigSpec::to_sigbit_set() const
return sigbits; return sigbits;
} }
nodict<RTLIL::SigBit> RTLIL::SigSpec::to_sigbit_nodict() const
{
cover("kernel.rtlil.sigspec.to_sigbit_nodict");
pack();
nodict<RTLIL::SigBit> sigbits;
for (auto &c : chunks_)
for (int i = 0; i < c.width; i++)
sigbits.insert(RTLIL::SigBit(c, i));
return sigbits;
}
std::vector<RTLIL::SigBit> RTLIL::SigSpec::to_sigbit_vector() const std::vector<RTLIL::SigBit> RTLIL::SigSpec::to_sigbit_vector() const
{ {
cover("kernel.rtlil.sigspec.to_sigbit_vector"); cover("kernel.rtlil.sigspec.to_sigbit_vector");
@ -2941,6 +2979,22 @@ std::map<RTLIL::SigBit, RTLIL::SigBit> RTLIL::SigSpec::to_sigbit_map(const RTLIL
return new_map; return new_map;
} }
dict<RTLIL::SigBit, RTLIL::SigBit> RTLIL::SigSpec::to_sigbit_dict(const RTLIL::SigSpec &other) const
{
cover("kernel.rtlil.sigspec.to_sigbit_dict");
unpack();
other.unpack();
log_assert(width_ == other.width_);
dict<RTLIL::SigBit, RTLIL::SigBit> new_map;
for (int i = 0; i < width_; i++)
new_map[bits_[i]] = other.bits_[i];
return new_map;
}
RTLIL::SigBit RTLIL::SigSpec::to_single_sigbit() const RTLIL::SigBit RTLIL::SigSpec::to_single_sigbit() const
{ {
cover("kernel.rtlil.sigspec.to_single_sigbit"); cover("kernel.rtlil.sigspec.to_single_sigbit");

620
kernel/rtlil.h
View file

@ -22,6 +22,27 @@
#ifndef RTLIL_H #ifndef RTLIL_H
#define RTLIL_H #define RTLIL_H
namespace std {
template<> struct hash<Yosys::RTLIL::IdString> {
size_t operator()(const Yosys::RTLIL::IdString &arg) const;
};
template<> struct equal_to<Yosys::RTLIL::IdString> {
bool operator()(const Yosys::RTLIL::IdString &lhs, const Yosys::RTLIL::IdString &rhs) const;
};
template<> struct hash<Yosys::RTLIL::SigBit> {
size_t operator()(const Yosys::RTLIL::SigBit &arg) const;
};
template<> struct equal_to<Yosys::RTLIL::SigBit> {
bool operator()(const Yosys::RTLIL::SigBit &lhs, const Yosys::RTLIL::SigBit &rhs) const;
};
template<> struct hash<Yosys::RTLIL::SigSpec> {
size_t operator()(const Yosys::RTLIL::SigSpec &arg) const;
};
template<> struct equal_to<Yosys::RTLIL::SigSpec> {
bool operator()(const Yosys::RTLIL::SigSpec &lhs, const Yosys::RTLIL::SigSpec &rhs) const;
};
}
YOSYS_NAMESPACE_BEGIN YOSYS_NAMESPACE_BEGIN
namespace RTLIL namespace RTLIL
@ -85,6 +106,24 @@ namespace RTLIL
} }
}; };
struct char_ptr_hash {
size_t operator()(const char *a) const {
size_t hash = 5381;
for (int c; (c = *a); a++)
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
return hash;
}
};
struct char_ptr_eq {
bool operator()(const char *a, const char *b) const {
for (int i = 0; a[i] || b[i]; i++)
if (a[i] != b[i])
return false;
return true;
}
};
static struct destruct_guard_t { static struct destruct_guard_t {
bool ok; // POD, will be initialized to zero bool ok; // POD, will be initialized to zero
destruct_guard_t() { ok = true; } destruct_guard_t() { ok = true; }
@ -93,7 +132,7 @@ namespace RTLIL
static std::vector<int> global_refcount_storage_; static std::vector<int> global_refcount_storage_;
static std::vector<char*> global_id_storage_; static std::vector<char*> global_id_storage_;
static std::map<char*, int, char_ptr_cmp> global_id_index_; static dict<char*, int, char_ptr_hash, char_ptr_eq> global_id_index_;
static std::vector<int> global_free_idx_list_; static std::vector<int> global_free_idx_list_;
static inline int get_reference(int idx) static inline int get_reference(int idx)
@ -224,8 +263,8 @@ namespace RTLIL
*this = IdString(); *this = IdString();
} }
// The following is a helper key_compare class. Instead of for example std::set<Cell*> // The following is a helper key_compare class. Instead of for example nodict<Cell*>
// use std::set<Cell*, IdString::compare_ptr_by_name<Cell>> if the order of cells in the // use nodict<Cell*, IdString::compare_ptr_by_name<Cell>> if the order of cells in the
// set has an influence on the algorithm. // set has an influence on the algorithm.
template<typename T> struct compare_ptr_by_name { template<typename T> struct compare_ptr_by_name {
@ -245,7 +284,7 @@ namespace RTLIL
bool in(IdString rhs) { return *this == rhs; } bool in(IdString rhs) { return *this == rhs; }
bool in(const char *rhs) { return *this == rhs; } bool in(const char *rhs) { return *this == rhs; }
bool in(const std::string &rhs) { return *this == rhs; } bool in(const std::string &rhs) { return *this == rhs; }
bool in(const std::set<IdString> &rhs) { return rhs.count(*this) != 0; } bool in(const nodict<IdString> &rhs) { return rhs.count(*this) != 0; }
}; };
static inline std::string escape_id(std::string str) { static inline std::string escape_id(std::string str) {
@ -336,8 +375,8 @@ namespace RTLIL
template<typename T> template<typename T>
struct ObjIterator struct ObjIterator
{ {
typename std::map<RTLIL::IdString, T>::iterator it; typename dict<RTLIL::IdString, T>::iterator it;
std::map<RTLIL::IdString, T> *list_p; dict<RTLIL::IdString, T> *list_p;
int *refcount_p; int *refcount_p;
ObjIterator() : list_p(nullptr), refcount_p(nullptr) { ObjIterator() : list_p(nullptr), refcount_p(nullptr) {
@ -401,7 +440,7 @@ namespace RTLIL
template<typename T> template<typename T>
struct ObjRange struct ObjRange
{ {
std::map<RTLIL::IdString, T> *list_p; dict<RTLIL::IdString, T> *list_p;
int *refcount_p; int *refcount_p;
ObjRange(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) { } ObjRange(decltype(list_p) list_p, int *refcount_p) : list_p(list_p), refcount_p(refcount_p) { }
@ -412,8 +451,8 @@ namespace RTLIL
return list_p->size(); return list_p->size();
} }
operator std::set<T>() const { operator nodict<T>() const {
std::set<T> result; nodict<T> result;
for (auto &it : *list_p) for (auto &it : *list_p)
result.insert(it.second); result.insert(it.second);
return result; return result;
@ -427,7 +466,7 @@ namespace RTLIL
return result; return result;
} }
std::set<T> to_set() const { return *this; } nodict<T> to_set() const { return *this; }
std::vector<T> to_vector() const { return *this; } std::vector<T> to_vector() const { return *this; }
}; };
}; };
@ -457,11 +496,232 @@ struct RTLIL::Const
inline int size() const { return bits.size(); } inline int size() const { return bits.size(); }
}; };
struct RTLIL::SigChunk
{
RTLIL::Wire *wire;
std::vector<RTLIL::State> data; // only used if wire == NULL, LSB at index 0
int width, offset;
SigChunk();
SigChunk(const RTLIL::Const &value);
SigChunk(RTLIL::Wire *wire);
SigChunk(RTLIL::Wire *wire, int offset, int width = 1);
SigChunk(const std::string &str);
SigChunk(int val, int width = 32);
SigChunk(RTLIL::State bit, int width = 1);
SigChunk(RTLIL::SigBit bit);
RTLIL::SigChunk extract(int offset, int length) const;
bool operator <(const RTLIL::SigChunk &other) const;
bool operator ==(const RTLIL::SigChunk &other) const;
bool operator !=(const RTLIL::SigChunk &other) const;
};
struct RTLIL::SigBit
{
RTLIL::Wire *wire;
union {
RTLIL::State data; // used if wire == NULL
int offset; // used if wire != NULL
};
SigBit();
SigBit(RTLIL::State bit);
SigBit(bool bit);
SigBit(RTLIL::Wire *wire);
SigBit(RTLIL::Wire *wire, int offset);
SigBit(const RTLIL::SigChunk &chunk);
SigBit(const RTLIL::SigChunk &chunk, int index);
SigBit(const RTLIL::SigSpec &sig);
bool operator <(const RTLIL::SigBit &other) const;
bool operator ==(const RTLIL::SigBit &other) const;
bool operator !=(const RTLIL::SigBit &other) const;
};
struct RTLIL::SigSpecIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
{
RTLIL::SigSpec *sig_p;
int index;
inline RTLIL::SigBit &operator*() const;
inline bool operator!=(const RTLIL::SigSpecIterator &other) const { return index != other.index; }
inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
inline void operator++() { index++; }
};
struct RTLIL::SigSpecConstIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
{
const RTLIL::SigSpec *sig_p;
int index;
inline const RTLIL::SigBit &operator*() const;
inline bool operator!=(const RTLIL::SigSpecConstIterator &other) const { return index != other.index; }
inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
inline void operator++() { index++; }
};
struct RTLIL::SigSpec
{
private:
int width_;
unsigned long hash_;
std::vector<RTLIL::SigChunk> chunks_; // LSB at index 0
std::vector<RTLIL::SigBit> bits_; // LSB at index 0
void pack() const;
void unpack() const;
void hash() const;
inline bool packed() const {
return bits_.empty();
}
inline void inline_unpack() const {
if (!chunks_.empty())
unpack();
}
public:
SigSpec();
SigSpec(const RTLIL::SigSpec &other);
SigSpec(std::initializer_list<RTLIL::SigSpec> parts);
const RTLIL::SigSpec &operator=(const RTLIL::SigSpec &other);
SigSpec(const RTLIL::Const &value);
SigSpec(const RTLIL::SigChunk &chunk);
SigSpec(RTLIL::Wire *wire);
SigSpec(RTLIL::Wire *wire, int offset, int width = 1);
SigSpec(const std::string &str);
SigSpec(int val, int width = 32);
SigSpec(RTLIL::State bit, int width = 1);
SigSpec(RTLIL::SigBit bit, int width = 1);
SigSpec(std::vector<RTLIL::SigChunk> chunks);
SigSpec(std::vector<RTLIL::SigBit> bits);
SigSpec(nodict<RTLIL::SigBit> bits);
SigSpec(std::set<RTLIL::SigBit> bits);
SigSpec(bool bit);
SigSpec(RTLIL::SigSpec &&other) {
width_ = other.width_;
hash_ = other.hash_;
chunks_ = std::move(other.chunks_);
bits_ = std::move(other.bits_);
}
const RTLIL::SigSpec &operator=(RTLIL::SigSpec &&other) {
width_ = other.width_;
hash_ = other.hash_;
chunks_ = std::move(other.chunks_);
bits_ = std::move(other.bits_);
return *this;
}
size_t get_hash() const {
if (!hash_) hash();
return hash_;
}
inline const std::vector<RTLIL::SigChunk> &chunks() const { pack(); return chunks_; }
inline const std::vector<RTLIL::SigBit> &bits() const { inline_unpack(); return bits_; }
inline int size() const { return width_; }
inline bool empty() const { return width_ == 0; }
inline RTLIL::SigBit &operator[](int index) { inline_unpack(); return bits_.at(index); }
inline const RTLIL::SigBit &operator[](int index) const { inline_unpack(); return bits_.at(index); }
inline RTLIL::SigSpecIterator begin() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = 0; return it; }
inline RTLIL::SigSpecIterator end() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = width_; return it; }
inline RTLIL::SigSpecConstIterator begin() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = 0; return it; }
inline RTLIL::SigSpecConstIterator end() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = width_; return it; }
void sort();
void sort_and_unify();
void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with);
void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with, RTLIL::SigSpec *other) const;
void replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules);
void replace(const dict<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules);
void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
void replace(int offset, const RTLIL::SigSpec &with);
void remove(const RTLIL::SigSpec &pattern);
void remove(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other) const;
void remove2(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other);
void remove(const nodict<RTLIL::SigBit> &pattern);
void remove(const nodict<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) const;
void remove2(const nodict<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other);
void remove(int offset, int length = 1);
void remove_const();
RTLIL::SigSpec extract(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec *other = NULL) const;
RTLIL::SigSpec extract(const nodict<RTLIL::SigBit> &pattern, const RTLIL::SigSpec *other = NULL) const;
RTLIL::SigSpec extract(int offset, int length = 1) const;
void append(const RTLIL::SigSpec &signal);
void append_bit(const RTLIL::SigBit &bit);
void extend_xx(int width, bool is_signed = false);
void extend_u0(int width, bool is_signed = false);
RTLIL::SigSpec repeat(int num) const;
bool operator <(const RTLIL::SigSpec &other) const;
bool operator ==(const RTLIL::SigSpec &other) const;
inline bool operator !=(const RTLIL::SigSpec &other) const { return !(*this == other); }
bool is_wire() const;
bool is_chunk() const;
bool is_fully_const() const;
bool is_fully_def() const;
bool is_fully_undef() const;
bool has_marked_bits() const;
bool as_bool() const;
int as_int(bool is_signed = false) const;
std::string as_string() const;
RTLIL::Const as_const() const;
RTLIL::Wire *as_wire() const;
RTLIL::SigChunk as_chunk() const;
bool match(std::string pattern) const;
std::set<RTLIL::SigBit> to_sigbit_set() const;
nodict<RTLIL::SigBit> to_sigbit_nodict() const;
std::vector<RTLIL::SigBit> to_sigbit_vector() const;
std::map<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_map(const RTLIL::SigSpec &other) const;
dict<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_dict(const RTLIL::SigSpec &other) const;
RTLIL::SigBit to_single_sigbit() const;
static bool parse(RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
static bool parse_sel(RTLIL::SigSpec &sig, RTLIL::Design *design, RTLIL::Module *module, std::string str);
static bool parse_rhs(const RTLIL::SigSpec &lhs, RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
operator std::vector<RTLIL::SigChunk>() const { return chunks(); }
operator std::vector<RTLIL::SigBit>() const { return bits(); }
#ifndef NDEBUG
void check() const;
#else
void check() const { }
#endif
};
struct RTLIL::Selection struct RTLIL::Selection
{ {
bool full_selection; bool full_selection;
std::set<RTLIL::IdString> selected_modules; nodict<RTLIL::IdString> selected_modules;
std::map<RTLIL::IdString, std::set<RTLIL::IdString>> selected_members; dict<RTLIL::IdString, nodict<RTLIL::IdString>> selected_members;
Selection(bool full = true) : full_selection(full) { } Selection(bool full = true) : full_selection(full) { }
@ -500,14 +760,14 @@ struct RTLIL::Monitor
struct RTLIL::Design struct RTLIL::Design
{ {
std::set<RTLIL::Monitor*> monitors; nodict<RTLIL::Monitor*> monitors;
std::map<std::string, std::string> scratchpad; dict<std::string, std::string> scratchpad;
int refcount_modules_; int refcount_modules_;
std::map<RTLIL::IdString, RTLIL::Module*> modules_; dict<RTLIL::IdString, RTLIL::Module*> modules_;
std::vector<RTLIL::Selection> selection_stack; std::vector<RTLIL::Selection> selection_stack;
std::map<RTLIL::IdString, RTLIL::Selection> selection_vars; dict<RTLIL::IdString, RTLIL::Selection> selection_vars;
std::string selected_active_module; std::string selected_active_module;
Design(); Design();
@ -569,7 +829,7 @@ struct RTLIL::Design
}; };
#define RTLIL_ATTRIBUTE_MEMBERS \ #define RTLIL_ATTRIBUTE_MEMBERS \
std::map<RTLIL::IdString, RTLIL::Const> attributes; \ dict<RTLIL::IdString, RTLIL::Const> attributes; \
void set_bool_attribute(RTLIL::IdString id) { \ void set_bool_attribute(RTLIL::IdString id) { \
attributes[id] = RTLIL::Const(1); \ attributes[id] = RTLIL::Const(1); \
} \ } \
@ -587,24 +847,24 @@ protected:
public: public:
RTLIL::Design *design; RTLIL::Design *design;
std::set<RTLIL::Monitor*> monitors; nodict<RTLIL::Monitor*> monitors;
int refcount_wires_; int refcount_wires_;
int refcount_cells_; int refcount_cells_;
std::map<RTLIL::IdString, RTLIL::Wire*> wires_; dict<RTLIL::IdString, RTLIL::Wire*> wires_;
std::map<RTLIL::IdString, RTLIL::Cell*> cells_; dict<RTLIL::IdString, RTLIL::Cell*> cells_;
std::vector<RTLIL::SigSig> connections_; std::vector<RTLIL::SigSig> connections_;
RTLIL::IdString name; RTLIL::IdString name;
std::set<RTLIL::IdString> avail_parameters; nodict<RTLIL::IdString> avail_parameters;
std::map<RTLIL::IdString, RTLIL::Memory*> memories; dict<RTLIL::IdString, RTLIL::Memory*> memories;
std::map<RTLIL::IdString, RTLIL::Process*> processes; dict<RTLIL::IdString, RTLIL::Process*> processes;
RTLIL_ATTRIBUTE_MEMBERS RTLIL_ATTRIBUTE_MEMBERS
Module(); Module();
virtual ~Module(); virtual ~Module();
virtual RTLIL::IdString derive(RTLIL::Design *design, std::map<RTLIL::IdString, RTLIL::Const> parameters); virtual RTLIL::IdString derive(RTLIL::Design *design, dict<RTLIL::IdString, RTLIL::Const> parameters);
virtual size_t count_id(RTLIL::IdString id); virtual size_t count_id(RTLIL::IdString id);
virtual void check(); virtual void check();
virtual void optimize(); virtual void optimize();
@ -641,7 +901,7 @@ public:
RTLIL::ObjRange<RTLIL::Cell*> cells() { return RTLIL::ObjRange<RTLIL::Cell*>(&cells_, &refcount_cells_); } RTLIL::ObjRange<RTLIL::Cell*> cells() { return RTLIL::ObjRange<RTLIL::Cell*>(&cells_, &refcount_cells_); }
// Removing wires is expensive. If you have to remove wires, remove them all at once. // Removing wires is expensive. If you have to remove wires, remove them all at once.
void remove(const std::set<RTLIL::Wire*> &wires); void remove(const nodict<RTLIL::Wire*> &wires);
void remove(RTLIL::Cell *cell); void remove(RTLIL::Cell *cell);
void rename(RTLIL::Wire *wire, RTLIL::IdString new_name); void rename(RTLIL::Wire *wire, RTLIL::IdString new_name);
@ -852,8 +1112,8 @@ public:
RTLIL::Module *module; RTLIL::Module *module;
RTLIL::IdString name; RTLIL::IdString name;
RTLIL::IdString type; RTLIL::IdString type;
std::map<RTLIL::IdString, RTLIL::SigSpec> connections_; dict<RTLIL::IdString, RTLIL::SigSpec> connections_;
std::map<RTLIL::IdString, RTLIL::Const> parameters; dict<RTLIL::IdString, RTLIL::Const> parameters;
RTLIL_ATTRIBUTE_MEMBERS RTLIL_ATTRIBUTE_MEMBERS
// access cell ports // access cell ports
@ -861,7 +1121,7 @@ public:
void unsetPort(RTLIL::IdString portname); void unsetPort(RTLIL::IdString portname);
void setPort(RTLIL::IdString portname, RTLIL::SigSpec signal); void setPort(RTLIL::IdString portname, RTLIL::SigSpec signal);
const RTLIL::SigSpec &getPort(RTLIL::IdString portname) const; const RTLIL::SigSpec &getPort(RTLIL::IdString portname) const;
const std::map<RTLIL::IdString, RTLIL::SigSpec> &connections() const; const dict<RTLIL::IdString, RTLIL::SigSpec> &connections() const;
// access cell parameters // access cell parameters
bool hasParam(RTLIL::IdString paramname) const; bool hasParam(RTLIL::IdString paramname) const;
@ -880,241 +1140,6 @@ public:
template<typename T> void rewrite_sigspecs(T functor); template<typename T> void rewrite_sigspecs(T functor);
}; };
struct RTLIL::SigChunk
{
RTLIL::Wire *wire;
std::vector<RTLIL::State> data; // only used if wire == NULL, LSB at index 0
int width, offset;
SigChunk();
SigChunk(const RTLIL::Const &value);
SigChunk(RTLIL::Wire *wire);
SigChunk(RTLIL::Wire *wire, int offset, int width = 1);
SigChunk(const std::string &str);
SigChunk(int val, int width = 32);
SigChunk(RTLIL::State bit, int width = 1);
SigChunk(RTLIL::SigBit bit);
RTLIL::SigChunk extract(int offset, int length) const;
bool operator <(const RTLIL::SigChunk &other) const;
bool operator ==(const RTLIL::SigChunk &other) const;
bool operator !=(const RTLIL::SigChunk &other) const;
};
struct RTLIL::SigBit
{
RTLIL::Wire *wire;
union {
RTLIL::State data; // used if wire == NULL
int offset; // used if wire != NULL
};
SigBit() : wire(NULL), data(RTLIL::State::S0) { }
SigBit(RTLIL::State bit) : wire(NULL), data(bit) { }
SigBit(bool bit) : wire(NULL), data(bit ? RTLIL::S1 : RTLIL::S0) { }
SigBit(RTLIL::Wire *wire) : wire(wire), offset(0) { log_assert(wire && wire->width == 1); }
SigBit(RTLIL::Wire *wire, int offset) : wire(wire), offset(offset) { log_assert(wire != nullptr); }
SigBit(const RTLIL::SigChunk &chunk) : wire(chunk.wire) { log_assert(chunk.width == 1); if (wire) offset = chunk.offset; else data = chunk.data[0]; }
SigBit(const RTLIL::SigChunk &chunk, int index) : wire(chunk.wire) { if (wire) offset = chunk.offset + index; else data = chunk.data[index]; }
SigBit(const RTLIL::SigSpec &sig);
bool operator <(const RTLIL::SigBit &other) const {
if (wire == other.wire)
return wire ? (offset < other.offset) : (data < other.data);
if (wire != nullptr && other.wire != nullptr)
return wire->name < other.wire->name;
return wire < other.wire;
}
bool operator ==(const RTLIL::SigBit &other) const {
return (wire == other.wire) && (wire ? (offset == other.offset) : (data == other.data));
}
bool operator !=(const RTLIL::SigBit &other) const {
return (wire != other.wire) || (wire ? (offset != other.offset) : (data != other.data));
}
};
struct RTLIL::SigSpecIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
{
RTLIL::SigSpec *sig_p;
int index;
inline RTLIL::SigBit &operator*() const;
inline bool operator!=(const RTLIL::SigSpecIterator &other) const { return index != other.index; }
inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
inline void operator++() { index++; }
};
struct RTLIL::SigSpecConstIterator : public std::iterator<std::input_iterator_tag, RTLIL::SigSpec>
{
const RTLIL::SigSpec *sig_p;
int index;
inline const RTLIL::SigBit &operator*() const;
inline bool operator!=(const RTLIL::SigSpecConstIterator &other) const { return index != other.index; }
inline bool operator==(const RTLIL::SigSpecIterator &other) const { return index == other.index; }
inline void operator++() { index++; }
};
struct RTLIL::SigSpec
{
private:
int width_;
unsigned long hash_;
std::vector<RTLIL::SigChunk> chunks_; // LSB at index 0
std::vector<RTLIL::SigBit> bits_; // LSB at index 0
void pack() const;
void unpack() const;
void hash() const;
inline bool packed() const {
return bits_.empty();
}
inline void inline_unpack() const {
if (!chunks_.empty())
unpack();
}
public:
SigSpec();
SigSpec(const RTLIL::SigSpec &other);
SigSpec(std::initializer_list<RTLIL::SigSpec> parts);
const RTLIL::SigSpec &operator=(const RTLIL::SigSpec &other);
SigSpec(const RTLIL::Const &value);
SigSpec(const RTLIL::SigChunk &chunk);
SigSpec(RTLIL::Wire *wire);
SigSpec(RTLIL::Wire *wire, int offset, int width = 1);
SigSpec(const std::string &str);
SigSpec(int val, int width = 32);
SigSpec(RTLIL::State bit, int width = 1);
SigSpec(RTLIL::SigBit bit, int width = 1);
SigSpec(std::vector<RTLIL::SigChunk> chunks);
SigSpec(std::vector<RTLIL::SigBit> bits);
SigSpec(std::set<RTLIL::SigBit> bits);
SigSpec(bool bit);
SigSpec(RTLIL::SigSpec &&other) {
width_ = other.width_;
hash_ = other.hash_;
chunks_ = std::move(other.chunks_);
bits_ = std::move(other.bits_);
}
const RTLIL::SigSpec &operator=(RTLIL::SigSpec &&other) {
width_ = other.width_;
hash_ = other.hash_;
chunks_ = std::move(other.chunks_);
bits_ = std::move(other.bits_);
return *this;
}
inline const std::vector<RTLIL::SigChunk> &chunks() const { pack(); return chunks_; }
inline const std::vector<RTLIL::SigBit> &bits() const { inline_unpack(); return bits_; }
inline int size() const { return width_; }
inline bool empty() const { return width_ == 0; }
inline RTLIL::SigBit &operator[](int index) { inline_unpack(); return bits_.at(index); }
inline const RTLIL::SigBit &operator[](int index) const { inline_unpack(); return bits_.at(index); }
inline RTLIL::SigSpecIterator begin() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = 0; return it; }
inline RTLIL::SigSpecIterator end() { RTLIL::SigSpecIterator it; it.sig_p = this; it.index = width_; return it; }
inline RTLIL::SigSpecConstIterator begin() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = 0; return it; }
inline RTLIL::SigSpecConstIterator end() const { RTLIL::SigSpecConstIterator it; it.sig_p = this; it.index = width_; return it; }
void sort();
void sort_and_unify();
void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with);
void replace(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec &with, RTLIL::SigSpec *other) const;
void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules);
void replace(const std::map<RTLIL::SigBit, RTLIL::SigBit> &rules, RTLIL::SigSpec *other) const;
void replace(int offset, const RTLIL::SigSpec &with);
void remove(const RTLIL::SigSpec &pattern);
void remove(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other) const;
void remove2(const RTLIL::SigSpec &pattern, RTLIL::SigSpec *other);
void remove(const std::set<RTLIL::SigBit> &pattern);
void remove(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other) const;
void remove2(const std::set<RTLIL::SigBit> &pattern, RTLIL::SigSpec *other);
void remove(int offset, int length = 1);
void remove_const();
RTLIL::SigSpec extract(const RTLIL::SigSpec &pattern, const RTLIL::SigSpec *other = NULL) const;
RTLIL::SigSpec extract(const std::set<RTLIL::SigBit> &pattern, const RTLIL::SigSpec *other = NULL) const;
RTLIL::SigSpec extract(int offset, int length = 1) const;
void append(const RTLIL::SigSpec &signal);
void append_bit(const RTLIL::SigBit &bit);
void extend_xx(int width, bool is_signed = false);
void extend_u0(int width, bool is_signed = false);
RTLIL::SigSpec repeat(int num) const;
bool operator <(const RTLIL::SigSpec &other) const;
bool operator ==(const RTLIL::SigSpec &other) const;
inline bool operator !=(const RTLIL::SigSpec &other) const { return !(*this == other); }
bool is_wire() const;
bool is_chunk() const;
bool is_fully_const() const;
bool is_fully_def() const;
bool is_fully_undef() const;
bool has_marked_bits() const;
bool as_bool() const;
int as_int(bool is_signed = false) const;
std::string as_string() const;
RTLIL::Const as_const() const;
RTLIL::Wire *as_wire() const;
RTLIL::SigChunk as_chunk() const;
bool match(std::string pattern) const;
std::set<RTLIL::SigBit> to_sigbit_set() const;
std::vector<RTLIL::SigBit> to_sigbit_vector() const;
std::map<RTLIL::SigBit, RTLIL::SigBit> to_sigbit_map(const RTLIL::SigSpec &other) const;
RTLIL::SigBit to_single_sigbit() const;
static bool parse(RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
static bool parse_sel(RTLIL::SigSpec &sig, RTLIL::Design *design, RTLIL::Module *module, std::string str);
static bool parse_rhs(const RTLIL::SigSpec &lhs, RTLIL::SigSpec &sig, RTLIL::Module *module, std::string str);
operator std::vector<RTLIL::SigChunk>() const { return chunks(); }
operator std::vector<RTLIL::SigBit>() const { return bits(); }
#ifndef NDEBUG
void check() const;
#else
inline void check() const { }
#endif
};
inline RTLIL::SigBit &RTLIL::SigSpecIterator::operator*() const {
return (*sig_p)[index];
}
inline const RTLIL::SigBit &RTLIL::SigSpecConstIterator::operator*() const {
return (*sig_p)[index];
}
inline RTLIL::SigBit::SigBit(const RTLIL::SigSpec &sig) {
log_assert(sig.size() == 1 && sig.chunks().size() == 1);
*this = SigBit(sig.chunks().front());
}
struct RTLIL::CaseRule struct RTLIL::CaseRule
{ {
std::vector<RTLIL::SigSpec> compare; std::vector<RTLIL::SigSpec> compare;
@ -1163,6 +1188,44 @@ struct RTLIL::Process
RTLIL::Process *clone() const; RTLIL::Process *clone() const;
}; };
inline RTLIL::SigBit::SigBit() : wire(NULL), data(RTLIL::State::S0) { }
inline RTLIL::SigBit::SigBit(RTLIL::State bit) : wire(NULL), data(bit) { }
inline RTLIL::SigBit::SigBit(bool bit) : wire(NULL), data(bit ? RTLIL::S1 : RTLIL::S0) { }
inline RTLIL::SigBit::SigBit(RTLIL::Wire *wire) : wire(wire), offset(0) { log_assert(wire && wire->width == 1); }
inline RTLIL::SigBit::SigBit(RTLIL::Wire *wire, int offset) : wire(wire), offset(offset) { log_assert(wire != nullptr); }
inline RTLIL::SigBit::SigBit(const RTLIL::SigChunk &chunk) : wire(chunk.wire) { log_assert(chunk.width == 1); if (wire) offset = chunk.offset; else data = chunk.data[0]; }
inline RTLIL::SigBit::SigBit(const RTLIL::SigChunk &chunk, int index) : wire(chunk.wire) { if (wire) offset = chunk.offset + index; else data = chunk.data[index]; }
inline bool RTLIL::SigBit::operator<(const RTLIL::SigBit &other) const {
if (wire == other.wire)
return wire ? (offset < other.offset) : (data < other.data);
if (wire != nullptr && other.wire != nullptr)
return wire->name < other.wire->name;
return wire < other.wire;
}
inline bool RTLIL::SigBit::operator==(const RTLIL::SigBit &other) const {
return (wire == other.wire) && (wire ? (offset == other.offset) : (data == other.data));
}
inline bool RTLIL::SigBit::operator!=(const RTLIL::SigBit &other) const {
return (wire != other.wire) || (wire ? (offset != other.offset) : (data != other.data));
}
inline RTLIL::SigBit &RTLIL::SigSpecIterator::operator*() const {
return (*sig_p)[index];
}
inline const RTLIL::SigBit &RTLIL::SigSpecConstIterator::operator*() const {
return (*sig_p)[index];
}
inline RTLIL::SigBit::SigBit(const RTLIL::SigSpec &sig) {
log_assert(sig.size() == 1 && sig.chunks().size() == 1);
*this = SigBit(sig.chunks().front());
}
template<typename T> template<typename T>
void RTLIL::Module::rewrite_sigspecs(T functor) void RTLIL::Module::rewrite_sigspecs(T functor)
{ {
@ -1222,4 +1285,35 @@ void RTLIL::Process::rewrite_sigspecs(T functor)
YOSYS_NAMESPACE_END YOSYS_NAMESPACE_END
inline size_t std::hash<Yosys::RTLIL::IdString>::operator()(const Yosys::RTLIL::IdString &arg) const {
return arg.index_;
}
inline bool std::equal_to<Yosys::RTLIL::IdString>::operator()(const Yosys::RTLIL::IdString &lhs, const Yosys::RTLIL::IdString &rhs) const {
return lhs.index_ == rhs.index_;
}
inline size_t std::hash<Yosys::RTLIL::SigBit>::operator()(const Yosys::RTLIL::SigBit &arg) const {
if (arg.wire) {
size_t hash = arg.wire->name.index_;
hash = ((hash << 5) + hash) + arg.offset;
return hash;
}
return arg.data;
}
inline bool std::equal_to<Yosys::RTLIL::SigBit>::operator()(const Yosys::RTLIL::SigBit &lhs, const Yosys::RTLIL::SigBit &rhs) const {
if (lhs.wire || rhs.wire)
return lhs.wire == rhs.wire && lhs.offset == rhs.offset;
return lhs.data == rhs.data;
}
inline size_t std::hash<Yosys::RTLIL::SigSpec>::operator()(const Yosys::RTLIL::SigSpec &arg) const {
return arg.get_hash();
}
inline bool std::equal_to<Yosys::RTLIL::SigSpec>::operator()(const Yosys::RTLIL::SigSpec &lhs, const Yosys::RTLIL::SigSpec &rhs) const {
return lhs == rhs;
}
#endif #endif

12
kernel/yosys.h
View file

@ -45,6 +45,8 @@
#include <string> #include <string>
#include <algorithm> #include <algorithm>
#include <functional> #include <functional>
#include <unordered_map>
#include <unordered_set>
#include <initializer_list> #include <initializer_list>
#include <sstream> #include <sstream>
@ -122,8 +124,18 @@
YOSYS_NAMESPACE_BEGIN YOSYS_NAMESPACE_BEGIN
template <class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
using dict = std::unordered_map<Key, T, Hash, KeyEqual>;
template <class Key, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>>
using nodict = std::unordered_set<Key, Hash, KeyEqual>;
template <class T>
using vector = std::vector<T>;
namespace RTLIL { namespace RTLIL {
struct IdString; struct IdString;
struct SigBit;
struct SigSpec; struct SigSpec;
struct Wire; struct Wire;
struct Cell; struct Cell;

8
passes/cmds/delete.cc
View file

@ -91,10 +91,10 @@ struct DeletePass : public Pass {
continue; continue;
} }
std::set<RTLIL::Wire*> delete_wires; nodict<RTLIL::Wire*> delete_wires;
std::set<RTLIL::Cell*> delete_cells; nodict<RTLIL::Cell*> delete_cells;
std::set<RTLIL::IdString> delete_procs; nodict<RTLIL::IdString> delete_procs;
std::set<RTLIL::IdString> delete_mems; nodict<RTLIL::IdString> delete_mems;
for (auto &it : module->wires_) for (auto &it : module->wires_)
if (design->selected(module, it.second)) if (design->selected(module, it.second))

8
passes/cmds/rename.cc
View file

@ -118,7 +118,7 @@ struct RenamePass : public Pass {
if (!design->selected(module)) if (!design->selected(module))
continue; continue;
std::map<RTLIL::IdString, RTLIL::Wire*> new_wires; dict<RTLIL::IdString, RTLIL::Wire*> new_wires;
for (auto &it : module->wires_) { for (auto &it : module->wires_) {
if (it.first[0] == '$' && design->selected(module, it.second)) if (it.first[0] == '$' && design->selected(module, it.second))
do it.second->name = stringf("\\%s%d%s", pattern_prefix.c_str(), counter++, pattern_suffix.c_str()); do it.second->name = stringf("\\%s%d%s", pattern_prefix.c_str(), counter++, pattern_suffix.c_str());
@ -128,7 +128,7 @@ struct RenamePass : public Pass {
module->wires_.swap(new_wires); module->wires_.swap(new_wires);
module->fixup_ports(); module->fixup_ports();
std::map<RTLIL::IdString, RTLIL::Cell*> new_cells; dict<RTLIL::IdString, RTLIL::Cell*> new_cells;
for (auto &it : module->cells_) { for (auto &it : module->cells_) {
if (it.first[0] == '$' && design->selected(module, it.second)) if (it.first[0] == '$' && design->selected(module, it.second))
do it.second->name = stringf("\\%s%d%s", pattern_prefix.c_str(), counter++, pattern_suffix.c_str()); do it.second->name = stringf("\\%s%d%s", pattern_prefix.c_str(), counter++, pattern_suffix.c_str());
@ -149,7 +149,7 @@ struct RenamePass : public Pass {
if (!design->selected(module)) if (!design->selected(module))
continue; continue;
std::map<RTLIL::IdString, RTLIL::Wire*> new_wires; dict<RTLIL::IdString, RTLIL::Wire*> new_wires;
for (auto &it : module->wires_) { for (auto &it : module->wires_) {
if (design->selected(module, it.second)) if (design->selected(module, it.second))
if (it.first[0] == '\\' && it.second->port_id == 0) if (it.first[0] == '\\' && it.second->port_id == 0)
@ -159,7 +159,7 @@ struct RenamePass : public Pass {
module->wires_.swap(new_wires); module->wires_.swap(new_wires);
module->fixup_ports(); module->fixup_ports();
std::map<RTLIL::IdString, RTLIL::Cell*> new_cells; dict<RTLIL::IdString, RTLIL::Cell*> new_cells;
for (auto &it : module->cells_) { for (auto &it : module->cells_) {
if (design->selected(module, it.second)) if (design->selected(module, it.second))
if (it.first[0] == '\\') if (it.first[0] == '\\')

4
passes/cmds/select.cc
View file

@ -101,7 +101,7 @@ static bool match_attr_val(const RTLIL::Const &value, std::string pattern, char
log_abort(); log_abort();
} }
static bool match_attr(const std::map<RTLIL::IdString, RTLIL::Const> &attributes, std::string name_pat, std::string value_pat, char match_op) static bool match_attr(const dict<RTLIL::IdString, RTLIL::Const> &attributes, std::string name_pat, std::string value_pat, char match_op)
{ {
if (name_pat.find('*') != std::string::npos || name_pat.find('?') != std::string::npos || name_pat.find('[') != std::string::npos) { if (name_pat.find('*') != std::string::npos || name_pat.find('?') != std::string::npos || name_pat.find('[') != std::string::npos) {
for (auto &it : attributes) { for (auto &it : attributes) {
@ -119,7 +119,7 @@ static bool match_attr(const std::map<RTLIL::IdString, RTLIL::Const> &attributes
return false; return false;
} }
static bool match_attr(const std::map<RTLIL::IdString, RTLIL::Const> &attributes, std::string match_expr) static bool match_attr(const dict<RTLIL::IdString, RTLIL::Const> &attributes, std::string match_expr)
{ {
size_t pos = match_expr.find_first_of("<!=>"); size_t pos = match_expr.find_first_of("<!=>");

2
passes/cmds/setattr.cc
View file

@ -50,7 +50,7 @@ struct setunset_t
} }
}; };
static void do_setunset(std::map<RTLIL::IdString, RTLIL::Const> &attrs, std::vector<setunset_t> &list) static void do_setunset(dict<RTLIL::IdString, RTLIL::Const> &attrs, std::vector<setunset_t> &list)
{ {
for (auto &item : list) for (auto &item : list)
if (item.unset) if (item.unset)

2
passes/cmds/splitnets.cc
View file

@ -176,7 +176,7 @@ struct SplitnetsPass : public Pass {
module->rewrite_sigspecs(worker); module->rewrite_sigspecs(worker);
std::set<RTLIL::Wire*> delete_wires; nodict<RTLIL::Wire*> delete_wires;
for (auto &it : worker.splitmap) for (auto &it : worker.splitmap)
delete_wires.insert(it.first); delete_wires.insert(it.first);
module->remove(delete_wires); module->remove(delete_wires);

4
passes/fsm/fsm_export.cc
View file

@ -50,7 +50,7 @@ std::string kiss_convert_signal(const RTLIL::SigSpec &sig) {
* @param cell pointer to the FSM cell which should be exported. * @param cell pointer to the FSM cell which should be exported.
*/ */
void write_kiss2(struct RTLIL::Module *module, struct RTLIL::Cell *cell, std::string filename, bool origenc) { void write_kiss2(struct RTLIL::Module *module, struct RTLIL::Cell *cell, std::string filename, bool origenc) {
std::map<RTLIL::IdString, RTLIL::Const>::iterator attr_it; dict<RTLIL::IdString, RTLIL::Const>::iterator attr_it;
FsmData fsm_data; FsmData fsm_data;
FsmData::transition_t tr; FsmData::transition_t tr;
std::ofstream kiss_file; std::ofstream kiss_file;
@ -145,7 +145,7 @@ struct FsmExportPass : public Pass {
} }
virtual void execute(std::vector<std::string> args, RTLIL::Design *design) virtual void execute(std::vector<std::string> args, RTLIL::Design *design)
{ {
std::map<RTLIL::IdString, RTLIL::Const>::iterator attr_it; dict<RTLIL::IdString, RTLIL::Const>::iterator attr_it;
std::string arg; std::string arg;
bool flag_noauto = false; bool flag_noauto = false;
std::string filename; std::string filename;

4
passes/hierarchy/hierarchy.cc
View file

@ -462,7 +462,7 @@ struct HierarchyPass : public Pass {
log_cmd_error("Option -top requires an additional argument!\n"); log_cmd_error("Option -top requires an additional argument!\n");
top_mod = design->modules_.count(RTLIL::escape_id(args[argidx])) ? design->modules_.at(RTLIL::escape_id(args[argidx])) : NULL; top_mod = design->modules_.count(RTLIL::escape_id(args[argidx])) ? design->modules_.at(RTLIL::escape_id(args[argidx])) : NULL;
if (top_mod == NULL && design->modules_.count("$abstract" + RTLIL::escape_id(args[argidx]))) { if (top_mod == NULL && design->modules_.count("$abstract" + RTLIL::escape_id(args[argidx]))) {
std::map<RTLIL::IdString, RTLIL::Const> empty_parameters; dict<RTLIL::IdString, RTLIL::Const> empty_parameters;
design->modules_.at("$abstract" + RTLIL::escape_id(args[argidx]))->derive(design, empty_parameters); design->modules_.at("$abstract" + RTLIL::escape_id(args[argidx]))->derive(design, empty_parameters);
top_mod = design->modules_.count(RTLIL::escape_id(args[argidx])) ? design->modules_.at(RTLIL::escape_id(args[argidx])) : NULL; top_mod = design->modules_.count(RTLIL::escape_id(args[argidx])) ? design->modules_.at(RTLIL::escape_id(args[argidx])) : NULL;
} }
@ -560,7 +560,7 @@ struct HierarchyPass : public Pass {
RTLIL::Cell *cell = work.second; RTLIL::Cell *cell = work.second;
log("Mapping positional arguments of cell %s.%s (%s).\n", log("Mapping positional arguments of cell %s.%s (%s).\n",
RTLIL::id2cstr(module->name), RTLIL::id2cstr(cell->name), RTLIL::id2cstr(cell->type)); RTLIL::id2cstr(module->name), RTLIL::id2cstr(cell->name), RTLIL::id2cstr(cell->type));
std::map<RTLIL::IdString, RTLIL::SigSpec> new_connections; dict<RTLIL::IdString, RTLIL::SigSpec> new_connections;
for (auto &conn : cell->connections()) for (auto &conn : cell->connections())
if (conn.first[0] == '$' && '0' <= conn.first[1] && conn.first[1] <= '9') { if (conn.first[0] == '$' && '0' <= conn.first[1] && conn.first[1] <= '9') {
int id = atoi(conn.first.c_str()+1); int id = atoi(conn.first.c_str()+1);

2
passes/opt/opt_clean.cc
View file

@ -262,7 +262,7 @@ void rmunused_module_signals(RTLIL::Module *module, bool purge_mode, bool verbos
} }
std::set<RTLIL::Wire*> del_wires; nodict<RTLIL::Wire*> del_wires;
int del_wires_count = 0; int del_wires_count = 0;
for (auto wire : maybe_del_wires) for (auto wire : maybe_del_wires)

6
passes/opt/opt_const.cc
View file

@ -196,11 +196,11 @@ void replace_const_cells(RTLIL::Design *design, RTLIL::Module *module, bool cons
ct_combinational.setup_stdcells(); ct_combinational.setup_stdcells();
SigMap assign_map(module); SigMap assign_map(module);
std::map<RTLIL::SigSpec, RTLIL::SigSpec> invert_map; dict<RTLIL::SigSpec, RTLIL::SigSpec> invert_map;
TopoSort<RTLIL::Cell*, RTLIL::IdString::compare_ptr_by_name<RTLIL::Cell>> cells; TopoSort<RTLIL::Cell*, RTLIL::IdString::compare_ptr_by_name<RTLIL::Cell>> cells;
std::map<RTLIL::Cell*, std::set<RTLIL::SigBit>> cell_to_inbit; dict<RTLIL::Cell*, std::set<RTLIL::SigBit>> cell_to_inbit;
std::map<RTLIL::SigBit, std::set<RTLIL::Cell*>> outbit_to_cell; dict<RTLIL::SigBit, std::set<RTLIL::Cell*>> outbit_to_cell;
for (auto cell : module->cells()) for (auto cell : module->cells())
if (design->selected(module, cell) && cell->type[0] == '$') { if (design->selected(module, cell) && cell->type[0] == '$') {

18
passes/opt/opt_share.cc
View file

@ -41,7 +41,7 @@ struct OptShareWorker
CellTypes ct; CellTypes ct;
int total_count; int total_count;
#ifdef USE_CELL_HASH_CACHE #ifdef USE_CELL_HASH_CACHE
std::map<const RTLIL::Cell*, std::string> cell_hash_cache; dict<const RTLIL::Cell*, std::string> cell_hash_cache;
#endif #endif
#ifdef USE_CELL_HASH_CACHE #ifdef USE_CELL_HASH_CACHE
@ -67,8 +67,8 @@ struct OptShareWorker
for (auto &it : cell->parameters) for (auto &it : cell->parameters)
hash_string += "P " + it.first.str() + "=" + it.second.as_string() + "\n"; hash_string += "P " + it.first.str() + "=" + it.second.as_string() + "\n";
const std::map<RTLIL::IdString, RTLIL::SigSpec> *conn = &cell->connections(); const dict<RTLIL::IdString, RTLIL::SigSpec> *conn = &cell->connections();
std::map<RTLIL::IdString, RTLIL::SigSpec> alt_conn; dict<RTLIL::IdString, RTLIL::SigSpec> alt_conn;
if (cell->type == "$and" || cell->type == "$or" || cell->type == "$xor" || cell->type == "$xnor" || cell->type == "$add" || cell->type == "$mul" || if (cell->type == "$and" || cell->type == "$or" || cell->type == "$xor" || cell->type == "$xnor" || cell->type == "$add" || cell->type == "$mul" ||
cell->type == "$logic_and" || cell->type == "$logic_or" || cell->type == "$_AND_" || cell->type == "$_OR_" || cell->type == "$_XOR_") { cell->type == "$logic_and" || cell->type == "$logic_or" || cell->type == "$_AND_" || cell->type == "$_OR_" || cell->type == "$_XOR_") {
@ -127,12 +127,14 @@ struct OptShareWorker
#endif #endif
if (cell1->parameters != cell2->parameters) { if (cell1->parameters != cell2->parameters) {
lt = cell1->parameters < cell2->parameters; std::map<RTLIL::IdString, RTLIL::Const> p1(cell1->parameters.begin(), cell1->parameters.end());
std::map<RTLIL::IdString, RTLIL::Const> p2(cell2->parameters.begin(), cell2->parameters.end());
lt = p1 < p2;
return true; return true;
} }
std::map<RTLIL::IdString, RTLIL::SigSpec> conn1 = cell1->connections(); dict<RTLIL::IdString, RTLIL::SigSpec> conn1 = cell1->connections();
std::map<RTLIL::IdString, RTLIL::SigSpec> conn2 = cell2->connections(); dict<RTLIL::IdString, RTLIL::SigSpec> conn2 = cell2->connections();
for (auto &it : conn1) { for (auto &it : conn1) {
if (ct.cell_output(cell1->type, it.first)) if (ct.cell_output(cell1->type, it.first))
@ -171,7 +173,9 @@ struct OptShareWorker
} }
if (conn1 != conn2) { if (conn1 != conn2) {
lt = conn1 < conn2; std::map<RTLIL::IdString, RTLIL::SigSpec> c1(conn1.begin(), conn1.end());
std::map<RTLIL::IdString, RTLIL::SigSpec> c2(conn2.begin(), conn2.end());
lt = c1 < c2;
return true; return true;
} }

4
passes/opt/wreduce.cc
View file

@ -28,11 +28,11 @@ PRIVATE_NAMESPACE_BEGIN
struct WreduceConfig struct WreduceConfig
{ {
std::set<IdString> supported_cell_types; nodict<IdString> supported_cell_types;
WreduceConfig() WreduceConfig()
{ {
supported_cell_types = std::set<IdString>({ supported_cell_types = nodict<IdString>({
"$not", "$pos", "$neg", "$not", "$pos", "$neg",
"$and", "$or", "$xor", "$xnor", "$and", "$or", "$xor", "$xnor",
"$shl", "$shr", "$sshl", "$sshr", "$shift", "$shiftx", "$shl", "$shr", "$sshl", "$sshr", "$shift", "$shiftx",

4
passes/techmap/extract.cc
View file

@ -42,7 +42,7 @@ public:
{ {
} }
bool compareAttributes(const std::set<RTLIL::IdString> &attr, const std::map<RTLIL::IdString, RTLIL::Const> &needleAttr, const std::map<RTLIL::IdString, RTLIL::Const> &haystackAttr) bool compareAttributes(const std::set<RTLIL::IdString> &attr, const dict<RTLIL::IdString, RTLIL::Const> &needleAttr, const dict<RTLIL::IdString, RTLIL::Const> &haystackAttr)
{ {
for (auto &it : attr) { for (auto &it : attr) {
size_t nc = needleAttr.count(it), hc = haystackAttr.count(it); size_t nc = needleAttr.count(it), hc = haystackAttr.count(it);
@ -123,7 +123,7 @@ public:
{ {
RTLIL::Wire *lastNeedleWire = NULL; RTLIL::Wire *lastNeedleWire = NULL;
RTLIL::Wire *lastHaystackWire = NULL; RTLIL::Wire *lastHaystackWire = NULL;
std::map<RTLIL::IdString, RTLIL::Const> emptyAttr; dict<RTLIL::IdString, RTLIL::Const> emptyAttr;
for (auto &conn : needleCell->connections()) for (auto &conn : needleCell->connections())
{ {

8
passes/techmap/techmap.cc
View file

@ -341,7 +341,7 @@ struct TechmapWorker
{ {
RTLIL::IdString derived_name = tpl_name; RTLIL::IdString derived_name = tpl_name;
RTLIL::Module *tpl = map->modules_[tpl_name]; RTLIL::Module *tpl = map->modules_[tpl_name];
std::map<RTLIL::IdString, RTLIL::Const> parameters = cell->parameters; std::map<RTLIL::IdString, RTLIL::Const> parameters(cell->parameters.begin(), cell->parameters.end());
if (tpl->get_bool_attribute("\\blackbox")) if (tpl->get_bool_attribute("\\blackbox"))
continue; continue;
@ -529,7 +529,7 @@ struct TechmapWorker
tpl = techmap_cache[key]; tpl = techmap_cache[key];
} else { } else {
if (cell->parameters.size() != 0) { if (cell->parameters.size() != 0) {
derived_name = tpl->derive(map, parameters); derived_name = tpl->derive(map, dict<RTLIL::IdString, RTLIL::Const>(parameters.begin(), parameters.end()));
tpl = map->module(derived_name); tpl = map->module(derived_name);
log_continue = true; log_continue = true;
} }
@ -975,7 +975,7 @@ struct TechmapPass : public Pass {
Frontend::frontend_call(map, &f, fn, (fn.size() > 3 && fn.substr(fn.size()-3) == ".il") ? "ilang" : verilog_frontend); Frontend::frontend_call(map, &f, fn, (fn.size() > 3 && fn.substr(fn.size()-3) == ".il") ? "ilang" : verilog_frontend);
} }
std::map<RTLIL::IdString, RTLIL::Module*> modules_new; dict<RTLIL::IdString, RTLIL::Module*> modules_new;
for (auto &it : map->modules_) { for (auto &it : map->modules_) {
if (it.first.substr(0, 2) == "\\$") if (it.first.substr(0, 2) == "\\$")
it.second->name = it.first.substr(1); it.second->name = it.first.substr(1);
@ -1072,7 +1072,7 @@ struct FlattenPass : public Pass {
log("No more expansions possible.\n"); log("No more expansions possible.\n");
if (top_mod != NULL) { if (top_mod != NULL) {
std::map<RTLIL::IdString, RTLIL::Module*> new_modules; dict<RTLIL::IdString, RTLIL::Module*> new_modules;
for (auto mod : design->modules()) for (auto mod : design->modules())
if (mod == top_mod || mod->get_bool_attribute("\\blackbox")) { if (mod == top_mod || mod->get_bool_attribute("\\blackbox")) {
new_modules[mod->name] = mod; new_modules[mod->name] = mod;