riscv
/
yosys
mirror of https://github.com/YosysHQ/yosys.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

hashlib: hash_eat -> hash_into

This commit is contained in:
Emil J. Tywoniak 2024-11-19 20:04:19 +01:00
parent 0a525f38c2
commit b9b9515bb0
23 changed files with 95 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/source/yosys_internals/hashing.rst
View File

@ -98,13 +98,13 @@ Making a type hashable
Let's first take a look at the external interface on a simplified level. Let's first take a look at the external interface on a simplified level.
Generally, to get the hash for ``T obj``, you would call the utility function Generally, to get the hash for ``T obj``, you would call the utility function
``run_hash<T>(const T& obj)``, corresponding to ``hash_top_ops<T>::hash(obj)``, ``run_hash<T>(const T& obj)``, corresponding to ``hash_top_ops<T>::hash(obj)``,
the default implementation of which is ``hash_ops<T>::hash_eat(Hasher(), obj)``. the default implementation of which is ``hash_ops<T>::hash_into(Hasher(), obj)``.
``Hasher`` is the class actually implementing the hash function, hiding its ``Hasher`` is the class actually implementing the hash function, hiding its
initialized internal state, and passing it out on ``hash_t yield()`` with initialized internal state, and passing it out on ``hash_t yield()`` with
perhaps some finalization steps. perhaps some finalization steps.
``hash_ops<T>`` is the star of the show. By default it pulls the ``Hasher h`` ``hash_ops<T>`` is the star of the show. By default it pulls the ``Hasher h``
through a ``Hasher T::hash_eat(Hasher h)`` method. That's the method you have to through a ``Hasher T::hash_into(Hasher h)`` method. That's the method you have to
implement to make a record (class or struct) type easily hashable with Yosys implement to make a record (class or struct) type easily hashable with Yosys
hashlib associative data structures. hashlib associative data structures.
@ -113,10 +113,10 @@ treats pointers the same as integers, so it doesn't dereference pointers. Since
many RTLIL data structures like ``RTLIL::Wire`` carry their own unique index many RTLIL data structures like ``RTLIL::Wire`` carry their own unique index
``Hasher::hash_t hashidx_;``, there are specializations for ``hash_ops<Wire*>`` ``Hasher::hash_t hashidx_;``, there are specializations for ``hash_ops<Wire*>``
and others in ``kernel/hashlib.h`` that actually dereference the pointers and and others in ``kernel/hashlib.h`` that actually dereference the pointers and
call ``hash_eat`` on the instances pointed to. call ``hash_into`` on the instances pointed to.
``hash_ops<T>`` is also specialized for simple compound types like ``hash_ops<T>`` is also specialized for simple compound types like
``std::pair<U>`` by calling hash_eat in sequence on its members. For flexible ``std::pair<U>`` by calling hash_into in sequence on its members. For flexible
size containers like ``std::vector<U>`` the size of the container is hashed size containers like ``std::vector<U>`` the size of the container is hashed
first. That is also how implementing hashing for a custom record data type first. That is also how implementing hashing for a custom record data type
should be - unless there is strong reason to do otherwise, call ``h.eat(m)`` on should be - unless there is strong reason to do otherwise, call ``h.eat(m)`` on
@ -143,7 +143,7 @@ based on the existance and value of `YS_HASHING_VERSION`.
return mkhash(a, b); return mkhash(a, b);
} }
#elif YS_HASHING_VERSION == 1 #elif YS_HASHING_VERSION == 1
Hasher T::hash_eat(Hasher h) const { Hasher T::hash_into(Hasher h) const {
h.eat(a); h.eat(a);
h.eat(b); h.eat(b);
return h; return h;

2
frontends/ast/ast.h
View File

@ -177,7 +177,7 @@ namespace AST
{ {
// for dict<> and pool<> // for dict<> and pool<>
unsigned int hashidx_; unsigned int hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
// this nodes type // this nodes type
AstNodeType type; AstNodeType type;

2
kernel/bitpattern.h
View File

@ -43,7 +43,7 @@ struct BitPatternPool
return false; return false;
return bitdata == other.bitdata; return bitdata == other.bitdata;
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
if (!cached_hash) if (!cached_hash)
cached_hash = run_hash(bitdata); cached_hash = run_hash(bitdata);
h.eat(cached_hash); h.eat(cached_hash);

4
kernel/cellaigs.cc
View File

@ -39,7 +39,7 @@ bool AigNode::operator==(const AigNode &other) const
return true; return true;
} }
Hasher AigNode::hash_eat(Hasher h) const Hasher AigNode::hash_into(Hasher h) const
{ {
h.eat(portname); h.eat(portname);
h.eat(portbit); h.eat(portbit);
@ -54,7 +54,7 @@ bool Aig::operator==(const Aig &other) const
return name == other.name; return name == other.name;
} }
Hasher Aig::hash_eat(Hasher h) const Hasher Aig::hash_into(Hasher h) const
{ {
h.eat(name); h.eat(name);
return h; return h;

4
kernel/cellaigs.h
View File

@ -34,7 +34,7 @@ struct AigNode
AigNode(); AigNode();
bool operator==(const AigNode &other) const; bool operator==(const AigNode &other) const;
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
struct Aig struct Aig
@ -44,7 +44,7 @@ struct Aig
Aig(Cell *cell); Aig(Cell *cell);
bool operator==(const Aig &other) const; bool operator==(const Aig &other) const;
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
YOSYS_NAMESPACE_END YOSYS_NAMESPACE_END

48
kernel/drivertools.h
View File

@ -74,7 +74,7 @@ struct DriveBitWire
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
operator SigBit() const operator SigBit() const
@ -105,7 +105,7 @@ struct DriveBitPort
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
@ -129,7 +129,7 @@ struct DriveBitMarker
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
@ -164,7 +164,7 @@ public:
return multiple_ == other.multiple_; return multiple_ == other.multiple_;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
struct DriveBit struct DriveBit
@ -352,7 +352,7 @@ public:
return *this; return *this;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
bool operator==(const DriveBit &other) const bool operator==(const DriveBit &other) const
{ {
@ -473,7 +473,7 @@ struct DriveChunkWire
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
explicit operator SigChunk() const explicit operator SigChunk() const
{ {
@ -531,7 +531,7 @@ struct DriveChunkPort
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
@ -572,7 +572,7 @@ struct DriveChunkMarker
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
struct DriveChunkMultiple struct DriveChunkMultiple
@ -612,7 +612,7 @@ public:
return false; // TODO implement, canonicalize order return false; // TODO implement, canonicalize order
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
struct DriveChunk struct DriveChunk
@ -863,7 +863,7 @@ public:
bool try_append(DriveBit const &bit); bool try_append(DriveBit const &bit);
bool try_append(DriveChunk const &chunk); bool try_append(DriveChunk const &chunk);
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
bool operator==(const DriveChunk &other) const bool operator==(const DriveChunk &other) const
{ {
@ -1073,7 +1073,7 @@ public:
that->hash_ |= (that->hash_ == 0); that->hash_ |= (that->hash_ == 0);
} }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
bool operator==(DriveSpec const &other) const { bool operator==(DriveSpec const &other) const {
updhash(); updhash();
@ -1112,7 +1112,7 @@ private:
bool operator!=(const DriveBitId &other) const { return id != other.id; } bool operator!=(const DriveBitId &other) const { return id != other.id; }
bool operator<(const DriveBitId &other) const { return id < other.id; } bool operator<(const DriveBitId &other) const { return id < other.id; }
// unsigned int hash() const { return id; } // unsigned int hash() const { return id; }
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
}; };
// Essentially a dict<DriveBitId, pool<DriveBitId>> but using less memory // Essentially a dict<DriveBitId, pool<DriveBitId>> but using less memory
// and fewer allocations // and fewer allocations
@ -1258,14 +1258,14 @@ private:
} }
}; };
inline Hasher DriveBitWire::hash_eat(Hasher h) const inline Hasher DriveBitWire::hash_into(Hasher h) const
{ {
h.eat(wire->name); h.eat(wire->name);
h.eat(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveBitPort::hash_eat(Hasher h) const inline Hasher DriveBitPort::hash_into(Hasher h) const
{ {
h.eat(cell->name); h.eat(cell->name);
h.eat(port); h.eat(port);
@ -1273,20 +1273,20 @@ inline Hasher DriveBitPort::hash_eat(Hasher h) const
return h; return h;
} }
inline Hasher DriveBitMarker::hash_eat(Hasher h) const inline Hasher DriveBitMarker::hash_into(Hasher h) const
{ {
h.eat(marker); h.eat(marker);
h.eat(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveBitMultiple::hash_eat(Hasher h) const inline Hasher DriveBitMultiple::hash_into(Hasher h) const
{ {
h.eat(multiple_); h.eat(multiple_);
return h; return h;
} }
inline Hasher DriveBit::hash_eat(Hasher h) const inline Hasher DriveBit::hash_into(Hasher h) const
{ {
switch (type_) { switch (type_) {
case DriveType::NONE: case DriveType::NONE:
@ -1312,7 +1312,7 @@ inline Hasher DriveBit::hash_eat(Hasher h) const
return h; return h;
} }
inline Hasher DriveChunkWire::hash_eat(Hasher h) const inline Hasher DriveChunkWire::hash_into(Hasher h) const
{ {
h.eat(wire->name); h.eat(wire->name);
h.eat(width); h.eat(width);
@ -1320,7 +1320,7 @@ inline Hasher DriveChunkWire::hash_eat(Hasher h) const
return h; return h;
} }
inline Hasher DriveChunkPort::hash_eat(Hasher h) const inline Hasher DriveChunkPort::hash_into(Hasher h) const
{ {
h.eat(cell->name); h.eat(cell->name);
h.eat(port); h.eat(port);
@ -1329,7 +1329,7 @@ inline Hasher DriveChunkPort::hash_eat(Hasher h) const
return h; return h;
} }
inline Hasher DriveChunkMarker::hash_eat(Hasher h) const inline Hasher DriveChunkMarker::hash_into(Hasher h) const
{ {
h.eat(marker); h.eat(marker);
h.eat(width); h.eat(width);
@ -1337,14 +1337,14 @@ inline Hasher DriveChunkMarker::hash_eat(Hasher h) const
return h; return h;
} }
inline Hasher DriveChunkMultiple::hash_eat(Hasher h) const inline Hasher DriveChunkMultiple::hash_into(Hasher h) const
{ {
h.eat(width_); h.eat(width_);
h.eat(multiple_); h.eat(multiple_);
return h; return h;
} }
inline Hasher DriveChunk::hash_eat(Hasher h) const inline Hasher DriveChunk::hash_into(Hasher h) const
{ {
switch (type_) { switch (type_) {
case DriveType::NONE: case DriveType::NONE:
@ -1370,7 +1370,7 @@ inline Hasher DriveChunk::hash_eat(Hasher h) const
return h; return h;
} }
inline Hasher DriveSpec::hash_eat(Hasher h) const inline Hasher DriveSpec::hash_into(Hasher h) const
{ {
if (hash_ == 0) if (hash_ == 0)
updhash(); updhash();
@ -1379,7 +1379,7 @@ inline Hasher DriveSpec::hash_eat(Hasher h) const
return h; return h;
} }
inline Hasher DriverMap::DriveBitId::hash_eat(Hasher h) const inline Hasher DriverMap::DriveBitId::hash_into(Hasher h) const
{ {
h.eat(id); h.eat(id);
return h; return h;

4
kernel/functional.h
View File

@ -151,7 +151,7 @@ namespace Functional {
// returns the data width of a bitvector sort, errors out for other sorts // returns the data width of a bitvector sort, errors out for other sorts
int data_width() const { return std::get<1>(_v).second; } int data_width() const { return std::get<1>(_v).second; }
bool operator==(Sort const& other) const { return _v == other._v; } bool operator==(Sort const& other) const { return _v == other._v; }
Hasher hash_eat(Hasher h) const { h.eat(_v); return h; } Hasher hash_into(Hasher h) const { h.eat(_v); return h; }
}; };
class IR; class IR;
class Factory; class Factory;
@ -225,7 +225,7 @@ namespace Functional {
const RTLIL::Const &as_const() const { return std::get<RTLIL::Const>(_extra); } const RTLIL::Const &as_const() const { return std::get<RTLIL::Const>(_extra); }
std::pair<IdString, IdString> as_idstring_pair() const { return std::get<std::pair<IdString, IdString>>(_extra); } std::pair<IdString, IdString> as_idstring_pair() const { return std::get<std::pair<IdString, IdString>>(_extra); }
int as_int() const { return std::get<int>(_extra); } int as_int() const { return std::get<int>(_extra); }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat((unsigned int) _fn); h.eat((unsigned int) _fn);
h.eat(_extra); h.eat(_extra);
return h; return h;

54
kernel/hashlib.h
View File

@ -128,12 +128,12 @@ private:
template<typename T> template<typename T>
void eat(T&& t) { void eat(T&& t) {
*this = hash_ops<std::remove_cv_t<std::remove_reference_t<T>>>::hash_eat(std::forward<T>(t), *this); *this = hash_ops<std::remove_cv_t<std::remove_reference_t<T>>>::hash_into(std::forward<T>(t), *this);
} }
template<typename T> template<typename T>
void eat(const T& t) { void eat(const T& t) {
*this = hash_ops<T>::hash_eat(t, *this); *this = hash_ops<T>::hash_into(t, *this);
} }
void commutative_eat(hash_t t) { void commutative_eat(hash_t t) {
@ -153,7 +153,7 @@ struct hash_top_ops {
return hash_ops<T>::cmp(a, b); return hash_ops<T>::cmp(a, b);
} }
static inline Hasher hash(const T &a) { static inline Hasher hash(const T &a) {
return hash_ops<T>::hash_eat(a, Hasher()); return hash_ops<T>::hash_into(a, Hasher());
} }
}; };
@ -162,7 +162,7 @@ struct hash_ops {
static inline bool cmp(const T &a, const T &b) { static inline bool cmp(const T &a, const T &b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(const T &a, Hasher h) { static inline Hasher hash_into(const T &a, Hasher h) {
if constexpr (std::is_same_v<T, bool>) { if constexpr (std::is_same_v<T, bool>) {
h.hash32(a ? 1 : 0); h.hash32(a ? 1 : 0);
return h; return h;
@ -175,15 +175,15 @@ struct hash_ops {
return h; return h;
} else if constexpr (std::is_enum_v<T>) { } else if constexpr (std::is_enum_v<T>) {
using u_type = std::underlying_type_t<T>; using u_type = std::underlying_type_t<T>;
return hash_ops<u_type>::hash_eat((u_type) a, h); return hash_ops<u_type>::hash_into((u_type) a, h);
} else if constexpr (std::is_pointer_v<T>) { } else if constexpr (std::is_pointer_v<T>) {
return hash_ops<uintptr_t>::hash_eat((uintptr_t) a, h); return hash_ops<uintptr_t>::hash_into((uintptr_t) a, h);
} else if constexpr (std::is_same_v<T, std::string>) { } else if constexpr (std::is_same_v<T, std::string>) {
for (auto c : a) for (auto c : a)
h.hash32(c); h.hash32(c);
return h; return h;
} else { } else {
return a.hash_eat(h); return a.hash_into(h);
} }
} }
}; };
@ -192,9 +192,9 @@ template<typename P, typename Q> struct hash_ops<std::pair<P, Q>> {
static inline bool cmp(std::pair<P, Q> a, std::pair<P, Q> b) { static inline bool cmp(std::pair<P, Q> a, std::pair<P, Q> b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(std::pair<P, Q> a, Hasher h) { static inline Hasher hash_into(std::pair<P, Q> a, Hasher h) {
h = hash_ops<P>::hash_eat(a.first, h); h = hash_ops<P>::hash_into(a.first, h);
h = hash_ops<Q>::hash_eat(a.second, h); h = hash_ops<Q>::hash_into(a.second, h);
return h; return h;
} }
}; };
@ -204,14 +204,14 @@ template<typename... T> struct hash_ops<std::tuple<T...>> {
return a == b; return a == b;
} }
template<size_t I = 0> template<size_t I = 0>
static inline typename std::enable_if<I == sizeof...(T), Hasher>::type hash_eat(std::tuple<T...>, Hasher h) { static inline typename std::enable_if<I == sizeof...(T), Hasher>::type hash_into(std::tuple<T...>, Hasher h) {
return h; return h;
} }
template<size_t I = 0> template<size_t I = 0>
static inline typename std::enable_if<I != sizeof...(T), Hasher>::type hash_eat(std::tuple<T...> a, Hasher h) { static inline typename std::enable_if<I != sizeof...(T), Hasher>::type hash_into(std::tuple<T...> a, Hasher h) {
typedef hash_ops<typename std::tuple_element<I, std::tuple<T...>>::type> element_ops_t; typedef hash_ops<typename std::tuple_element<I, std::tuple<T...>>::type> element_ops_t;
h = hash_eat<I+1>(a, h); h = hash_into<I+1>(a, h);
h = element_ops_t::hash_eat(std::get<I>(a), h); h = element_ops_t::hash_into(std::get<I>(a), h);
return h; return h;
} }
}; };
@ -220,7 +220,7 @@ template<typename T> struct hash_ops<std::vector<T>> {
static inline bool cmp(std::vector<T> a, std::vector<T> b) { static inline bool cmp(std::vector<T> a, std::vector<T> b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(std::vector<T> a, Hasher h) { static inline Hasher hash_into(std::vector<T> a, Hasher h) {
h.eat(a.size()); h.eat(a.size());
for (auto k : a) for (auto k : a)
h.eat(k); h.eat(k);
@ -232,9 +232,9 @@ template<typename T, size_t N> struct hash_ops<std::array<T, N>> {
static inline bool cmp(std::array<T, N> a, std::array<T, N> b) { static inline bool cmp(std::array<T, N> a, std::array<T, N> b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(std::array<T, N> a, Hasher h) { static inline Hasher hash_into(std::array<T, N> a, Hasher h) {
for (const auto& k : a) for (const auto& k : a)
h = hash_ops<T>::hash_eat(k, h); h = hash_ops<T>::hash_into(k, h);
return h; return h;
} }
}; };
@ -246,7 +246,7 @@ struct hash_cstr_ops {
return false; return false;
return true; return true;
} }
static inline Hasher hash_eat(const char *a, Hasher h) { static inline Hasher hash_into(const char *a, Hasher h) {
while (*a) while (*a)
h.hash32(*(a++)); h.hash32(*(a++));
return h; return h;
@ -259,8 +259,8 @@ struct hash_ptr_ops {
static inline bool cmp(const void *a, const void *b) { static inline bool cmp(const void *a, const void *b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(const void *a, Hasher h) { static inline Hasher hash_into(const void *a, Hasher h) {
return hash_ops<uintptr_t>::hash_eat((uintptr_t)a, h); return hash_ops<uintptr_t>::hash_into((uintptr_t)a, h);
} }
}; };
@ -269,8 +269,8 @@ struct hash_obj_ops {
return a == b; return a == b;
} }
template<typename T> template<typename T>
static inline Hasher hash_eat(const T *a, Hasher h) { static inline Hasher hash_into(const T *a, Hasher h) {
return a ? a->hash_eat(h) : h; return a ? a->hash_into(h) : h;
} }
}; };
/** /**
@ -297,7 +297,7 @@ template<> struct hash_ops<std::monostate> {
static inline bool cmp(std::monostate a, std::monostate b) { static inline bool cmp(std::monostate a, std::monostate b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(std::monostate, Hasher h) { static inline Hasher hash_into(std::monostate, Hasher h) {
return h; return h;
} }
}; };
@ -306,7 +306,7 @@ template<typename... T> struct hash_ops<std::variant<T...>> {
static inline bool cmp(std::variant<T...> a, std::variant<T...> b) { static inline bool cmp(std::variant<T...> a, std::variant<T...> b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(std::variant<T...> a, Hasher h) { static inline Hasher hash_into(std::variant<T...> a, Hasher h) {
std::visit([& h](const auto &v) { h.eat(v); }, a); std::visit([& h](const auto &v) { h.eat(v); }, a);
h.eat(a.index()); h.eat(a.index());
return h; return h;
@ -317,7 +317,7 @@ template<typename T> struct hash_ops<std::optional<T>> {
static inline bool cmp(std::optional<T> a, std::optional<T> b) { static inline bool cmp(std::optional<T> a, std::optional<T> b) {
return a == b; return a == b;
} }
static inline Hasher hash_eat(std::optional<T> a, Hasher h) { static inline Hasher hash_into(std::optional<T> a, Hasher h) {
if(a.has_value()) if(a.has_value())
h.eat(*a); h.eat(*a);
else else
@ -790,7 +790,7 @@ public:
return !operator==(other); return !operator==(other);
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(entries.size()); h.eat(entries.size());
for (auto &it : entries) { for (auto &it : entries) {
Hasher entry_hash; Hasher entry_hash;
@ -1160,7 +1160,7 @@ public:
return !operator==(other); return !operator==(other);
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(entries.size()); h.eat(entries.size());
for (auto &it : entries) { for (auto &it : entries) {
h.commutative_eat(ops.hash(it.udata).yield()); h.commutative_eat(ops.hash(it.udata).yield());

4
kernel/modtools.h
View File

@ -48,7 +48,7 @@ struct ModIndex : public RTLIL::Monitor
return cell == other.cell && port == other.port && offset == other.offset; return cell == other.cell && port == other.port && offset == other.offset;
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(cell->name); h.eat(cell->name);
h.eat(port); h.eat(port);
h.eat(offset); h.eat(offset);
@ -324,7 +324,7 @@ struct ModWalker
return cell == other.cell && port == other.port && offset == other.offset; return cell == other.cell && port == other.port && offset == other.offset;
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(cell->name); h.eat(cell->name);
h.eat(port); h.eat(port);
h.eat(offset); h.eat(offset);

24
kernel/rtlil.h
View File

@ -362,7 +362,7 @@ struct RTLIL::IdString
*this = IdString(); *this = IdString();
} }
Hasher hash_eat(Hasher h) const { return hash_ops<int>::hash_eat(index_, h); } Hasher hash_into(Hasher h) const { return hash_ops<int>::hash_into(index_, h); }
Hasher hash_top() const { Hasher hash_top() const {
Hasher h; Hasher h;
@ -815,7 +815,7 @@ public:
bv.resize(width, bv.empty() ? RTLIL::State::Sx : bv.back()); bv.resize(width, bv.empty() ? RTLIL::State::Sx : bv.back());
} }
inline Hasher hash_eat(Hasher h) const { inline Hasher hash_into(Hasher h) const {
// TODO hash size // TODO hash size
for (auto b : *this) for (auto b : *this)
h.eat(b); h.eat(b);
@ -908,7 +908,7 @@ struct RTLIL::SigBit
bool operator <(const RTLIL::SigBit &other) const; bool operator <(const RTLIL::SigBit &other) const;
bool operator ==(const RTLIL::SigBit &other) const; bool operator ==(const RTLIL::SigBit &other) const;
bool operator !=(const RTLIL::SigBit &other) const; bool operator !=(const RTLIL::SigBit &other) const;
Hasher hash_eat(Hasher h) const; Hasher hash_into(Hasher h) const;
Hasher hash_top() const; Hasher hash_top() const;
}; };
@ -1115,7 +1115,7 @@ public:
operator std::vector<RTLIL::SigBit>() const { return bits(); } operator std::vector<RTLIL::SigBit>() const { return bits(); }
const RTLIL::SigBit &at(int offset, const RTLIL::SigBit &defval) { return offset < width_ ? (*this)[offset] : defval; } const RTLIL::SigBit &at(int offset, const RTLIL::SigBit &defval) { return offset < width_ ? (*this)[offset] : defval; }
Hasher hash_eat(Hasher h) const { if (!hash_) updhash(); h.eat(hash_); return h; } Hasher hash_into(Hasher h) const { if (!hash_) updhash(); h.eat(hash_); return h; }
#ifndef NDEBUG #ifndef NDEBUG
void check(Module *mod = nullptr) const; void check(Module *mod = nullptr) const;
@ -1157,7 +1157,7 @@ struct RTLIL::Selection
struct RTLIL::Monitor struct RTLIL::Monitor
{ {
Hasher::hash_t hashidx_; Hasher::hash_t hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
Monitor() { Monitor() {
static unsigned int hashidx_count = 123456789; static unsigned int hashidx_count = 123456789;
@ -1180,7 +1180,7 @@ struct define_map_t;
struct RTLIL::Design struct RTLIL::Design
{ {
Hasher::hash_t hashidx_; Hasher::hash_t hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
pool<RTLIL::Monitor*> monitors; pool<RTLIL::Monitor*> monitors;
dict<std::string, std::string> scratchpad; dict<std::string, std::string> scratchpad;
@ -1285,7 +1285,7 @@ struct RTLIL::Design
struct RTLIL::Module : public RTLIL::AttrObject struct RTLIL::Module : public RTLIL::AttrObject
{ {
Hasher::hash_t hashidx_; Hasher::hash_t hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
protected: protected:
void add(RTLIL::Wire *wire); void add(RTLIL::Wire *wire);
@ -1640,7 +1640,7 @@ void dump_wire(std::ostream &f, std::string indent, const RTLIL::Wire *wire);
struct RTLIL::Wire : public RTLIL::AttrObject struct RTLIL::Wire : public RTLIL::AttrObject
{ {
Hasher::hash_t hashidx_; Hasher::hash_t hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
protected: protected:
// use module->addWire() and module->remove() to create or destroy wires // use module->addWire() and module->remove() to create or destroy wires
@ -1679,7 +1679,7 @@ inline int GetSize(RTLIL::Wire *wire) {
struct RTLIL::Memory : public RTLIL::AttrObject struct RTLIL::Memory : public RTLIL::AttrObject
{ {
Hasher::hash_t hashidx_; Hasher::hash_t hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
Memory(); Memory();
@ -1694,7 +1694,7 @@ struct RTLIL::Memory : public RTLIL::AttrObject
struct RTLIL::Cell : public RTLIL::AttrObject struct RTLIL::Cell : public RTLIL::AttrObject
{ {
Hasher::hash_t hashidx_; Hasher::hash_t hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
protected: protected:
// use module->addCell() and module->remove() to create or destroy cells // use module->addCell() and module->remove() to create or destroy cells
@ -1804,7 +1804,7 @@ struct RTLIL::SyncRule
struct RTLIL::Process : public RTLIL::AttrObject struct RTLIL::Process : public RTLIL::AttrObject
{ {
Hasher::hash_t hashidx_; Hasher::hash_t hashidx_;
Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; } Hasher hash_into(Hasher h) const { h.eat(hashidx_); return h; }
protected: protected:
// use module->addProcess() and module->remove() to create or destroy processes // use module->addProcess() and module->remove() to create or destroy processes
@ -1848,7 +1848,7 @@ inline bool RTLIL::SigBit::operator!=(const RTLIL::SigBit &other) const {
return (wire != other.wire) || (wire ? (offset != other.offset) : (data != other.data)); return (wire != other.wire) || (wire ? (offset != other.offset) : (data != other.data));
} }
inline Hasher RTLIL::SigBit::hash_eat(Hasher h) const { inline Hasher RTLIL::SigBit::hash_into(Hasher h) const {
if (wire) { if (wire) {
h.eat(offset); h.eat(offset);
h.eat(wire->name); h.eat(wire->name);

4
kernel/scopeinfo.h
View File

@ -169,7 +169,7 @@ public:
return !(*this == other); return !(*this == other);
} }
Hasher hash_acc(Hasher h) const Hasher hash_into(Hasher h) const
{ {
h.eat(scope_name); h.eat(scope_name);
h.eat(target); h.eat(target);
@ -325,7 +325,7 @@ struct ModuleItem {
Cell *cell() const { return type == Type::Cell ? static_cast<Cell *>(ptr) : nullptr; } Cell *cell() const { return type == Type::Cell ? static_cast<Cell *>(ptr) : nullptr; }
bool operator==(const ModuleItem &other) const { return ptr == other.ptr && type == other.type; } bool operator==(const ModuleItem &other) const { return ptr == other.ptr && type == other.type; }
Hasher hash_eat(Hasher h) const { h.eat(ptr); return h; } Hasher hash_into(Hasher h) const { h.eat(ptr); return h; }
}; };
static inline void log_dump_val_worker(typename IdTree<ModuleItem>::Cursor cursor ) { log("%p %s", cursor.target, log_id(cursor.scope_name)); } static inline void log_dump_val_worker(typename IdTree<ModuleItem>::Cursor cursor ) { log("%p %s", cursor.target, log_id(cursor.scope_name)); }

4
kernel/sigtools.h
View File

@ -29,7 +29,7 @@ struct SigPool
struct bitDef_t : public std::pair<RTLIL::Wire*, int> { struct bitDef_t : public std::pair<RTLIL::Wire*, int> {
bitDef_t() : std::pair<RTLIL::Wire*, int>(NULL, 0) { } bitDef_t() : std::pair<RTLIL::Wire*, int>(NULL, 0) { }
bitDef_t(const RTLIL::SigBit &bit) : std::pair<RTLIL::Wire*, int>(bit.wire, bit.offset) { } bitDef_t(const RTLIL::SigBit &bit) : std::pair<RTLIL::Wire*, int>(bit.wire, bit.offset) { }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(first->name); h.eat(first->name);
h.eat(second); h.eat(second);
return h; return h;
@ -147,7 +147,7 @@ struct SigSet
struct bitDef_t : public std::pair<RTLIL::Wire*, int> { struct bitDef_t : public std::pair<RTLIL::Wire*, int> {
bitDef_t() : std::pair<RTLIL::Wire*, int>(NULL, 0) { } bitDef_t() : std::pair<RTLIL::Wire*, int>(NULL, 0) { }
bitDef_t(const RTLIL::SigBit &bit) : std::pair<RTLIL::Wire*, int>(bit.wire, bit.offset) { } bitDef_t(const RTLIL::SigBit &bit) : std::pair<RTLIL::Wire*, int>(bit.wire, bit.offset) { }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(first->name); h.eat(first->name);
h.eat(second); h.eat(second);
return h; return h;

4
kernel/timinginfo.h
View File

@ -44,7 +44,7 @@ struct TimingInfo
return {}; return {};
return port[offset]; return port[offset];
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(name); h.eat(name);
h.eat(offset); h.eat(offset);
return h; return h;
@ -56,7 +56,7 @@ struct TimingInfo
BitBit(const NameBit &first, const NameBit &second) : first(first), second(second) {} BitBit(const NameBit &first, const NameBit &second) : first(first), second(second) {}
BitBit(const SigBit &first, const SigBit &second) : first(first), second(second) {} BitBit(const SigBit &first, const SigBit &second) : first(first), second(second) {}
bool operator==(const BitBit& bb) const { return bb.first == first && bb.second == second; } bool operator==(const BitBit& bb) const { return bb.first == first && bb.second == second; }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(first); h.eat(first);
h.eat(second); h.eat(second);
return h; return h;

2
kernel/yosys_common.h
View File

@ -171,7 +171,7 @@ struct shared_str {
const char *c_str() const { return content->c_str(); } const char *c_str() const { return content->c_str(); }
const string &str() const { return *content; } const string &str() const { return *content; }
bool operator==(const shared_str &other) const { return *content == *other.content; } bool operator==(const shared_str &other) const { return *content == *other.content; }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(*content); h.eat(*content);
return h; return h;
} }

2
kernel/yw.h
View File

@ -35,7 +35,7 @@ struct IdPath : public std::vector<RTLIL::IdString>
bool has_address() const { int tmp; return get_address(tmp); }; bool has_address() const { int tmp; return get_address(tmp); };
bool get_address(int &addr) const; bool get_address(int &addr) const;
Hasher hash_eat(Hasher h) const { h.eat(*this); return h; } Hasher hash_into(Hasher h) const { h.eat(*this); return h; }
}; };
struct WitnessHierarchyItem { struct WitnessHierarchyItem {

2
passes/cmds/dft_tag.cc
View File

@ -47,7 +47,7 @@ struct DftTagWorker {
bool operator<(const tag_set &other) const { return index < other.index; } bool operator<(const tag_set &other) const { return index < other.index; }
bool operator==(const tag_set &other) const { return index == other.index; } bool operator==(const tag_set &other) const { return index == other.index; }
Hasher hash_eat(Hasher h) const { h.eat(index); return h; } Hasher hash_into(Hasher h) const { h.eat(index); return h; }
bool empty() const { return index == 0; } bool empty() const { return index == 0; }
}; };

2
passes/cmds/example_dt.cc
View File

@ -52,7 +52,7 @@ struct ExampleDtPass : public Pass
return name == other.name && parameters == other.parameters; return name == other.name && parameters == other.parameters;
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(name); h.eat(name);
h.eat(parameters); h.eat(parameters);
return h; return h;

2
passes/equiv/equiv_struct.cc
View File

@ -46,7 +46,7 @@ struct EquivStructWorker
parameters == other.parameters && port_sizes == other.port_sizes; parameters == other.parameters && port_sizes == other.port_sizes;
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(type); h.eat(type);
h.eat(parameters); h.eat(parameters);
h.eat(port_sizes); h.eat(port_sizes);

2
passes/proc/proc_dlatch.cc
View File

@ -127,7 +127,7 @@ struct proc_dlatch_db_t
return signal == other.signal && match == other.match && children == other.children; return signal == other.signal && match == other.match && children == other.children;
} }
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
h.eat(signal); h.eat(signal);
h.eat(match); h.eat(match);
h.eat(children); h.eat(children);

4
passes/sat/recover_names.cc
View File

@ -46,7 +46,7 @@ struct IdBit {
bool operator==(const IdBit &other) const { return name == other.name && bit == other.bit; }; bool operator==(const IdBit &other) const { return name == other.name && bit == other.bit; };
bool operator!=(const IdBit &other) const { return name != other.name || bit != other.bit; }; bool operator!=(const IdBit &other) const { return name != other.name || bit != other.bit; };
Hasher hash_eat(Hasher h) const Hasher hash_into(Hasher h) const
{ {
h.eat(name); h.eat(name);
h.eat(bit); h.eat(bit);
@ -64,7 +64,7 @@ struct InvBit {
bool operator==(const InvBit &other) const { return bit == other.bit && inverted == other.inverted; }; bool operator==(const InvBit &other) const { return bit == other.bit && inverted == other.inverted; };
bool operator!=(const InvBit &other) const { return bit != other.bit || inverted != other.inverted; }; bool operator!=(const InvBit &other) const { return bit != other.bit || inverted != other.inverted; };
Hasher hash_eat(Hasher h) const Hasher hash_into(Hasher h) const
{ {
h.eat(bit); h.eat(bit);
h.eat(inverted); h.eat(inverted);

2
passes/techmap/clockgate.cc
View File

@ -233,7 +233,7 @@ struct ClockgatePass : public Pass {
SigBit ce_bit; SigBit ce_bit;
bool pol_clk; bool pol_clk;
bool pol_ce; bool pol_ce;
Hasher hash_eat(Hasher h) const { Hasher hash_into(Hasher h) const {
auto t = std::make_tuple(clk_bit, ce_bit, pol_clk, pol_ce); auto t = std::make_tuple(clk_bit, ce_bit, pol_clk, pol_ce);
h.eat(t); h.eat(t);
return h; return h;

2
passes/techmap/flowmap.cc
View File

@ -250,7 +250,7 @@ struct FlowGraph
{ {
return !(*this == other); return !(*this == other);
} }
Hasher hash_eat(Hasher h) const Hasher hash_into(Hasher h) const
{ {
std::pair<RTLIL::SigBit, int> p = {node, is_bottom}; std::pair<RTLIL::SigBit, int> p = {node, is_bottom};
h.eat(p); h.eat(p);

2
techlibs/quicklogic/ql_dsp_simd.cc
View File

@ -53,7 +53,7 @@ struct QlDspSimdPass : public Pass {
DspConfig(const DspConfig &ref) = default; DspConfig(const DspConfig &ref) = default;
DspConfig(DspConfig &&ref) = default; DspConfig(DspConfig &&ref) = default;
Hasher hash_eat(Hasher h) const { h.eat(connections); return h; } Hasher hash_into(Hasher h) const { h.eat(connections); return h; }
bool operator==(const DspConfig &ref) const { return connections == ref.connections; } bool operator==(const DspConfig &ref) const { return connections == ref.connections; }
}; };