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

hashlib: acc -> eat

This commit is contained in:
Emil J. Tywoniak 2024-11-11 15:45:11 +01:00
parent 79acc141d5
commit 4e29ec1854
25 changed files with 200 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
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_acc(Hasher(), obj)``. the default implementation of which is ``hash_ops<T>::hash_eat(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_acc(Hasher h)`` method. That's the method you have to through a ``Hasher T::hash_eat(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,13 +113,13 @@ 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_acc`` on the instances pointed to. call ``hash_eat`` 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_acc in sequence on its members. For flexible ``std::pair<U>`` by calling hash_eat 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.acc(m)`` on should be - unless there is strong reason to do otherwise, call ``h.eat(m)`` on
the ``Hasher h`` you have received for each member in sequence and ``return the ``Hasher h`` you have received for each member in sequence and ``return
h;``. If you do have a strong reason to do so, look at how h;``. If you do have a strong reason to do so, look at how
``hash_top_ops<RTLIL::SigBit>`` is implemented in ``kernel/rtlil.h``. ``hash_top_ops<RTLIL::SigBit>`` is implemented in ``kernel/rtlil.h``.
@ -134,7 +134,7 @@ operations thrown in to mix bits together somewhat. A plugin can stay compatible
with both versions prior and after the break by implementing the aforementioned with both versions prior and after the break by implementing the aforementioned
current interface and redirecting the legacy one: current interface and redirecting the legacy one:
``void Hasher::acc(const T& t)`` hashes ``t`` into its internal state by also ``void Hasher::eat(const T& t)`` hashes ``t`` into its internal state by also
redirecting to ``hash_ops<T>`` redirecting to ``hash_ops<T>``
.. code-block:: cpp .. code-block:: cpp
@ -143,7 +143,7 @@ redirecting to ``hash_ops<T>``
inline unsigned int T::hash() const { inline unsigned int T::hash() const {
Hasher h; Hasher h;
return (unsigned int)hash_acc(h).yield(); return (unsigned int)hash_eat(h).yield();
} }
To get hashes for Yosys types, you can temporarily use the templated deprecated To get hashes for Yosys types, you can temporarily use the templated deprecated

8
flake.nix
View File

@ -14,15 +14,15 @@
}; };
# TODO: don't override src when ./abc is empty # TODO: don't override src when ./abc is empty
# which happens when the command used is `nix build` and not `nix build ?submodules=1` # which happens when the command used is `nix build` and not `nix build ?submodules=1`
abc-verifier = pkgs.abc-verifier.overrideAttrs(x: y: {src = ./abc;}); abc-verifier = pkgs.abc-verifier;
yosys = pkgs.clangStdenv.mkDerivation { yosys = pkgs.clangStdenv.mkDerivation {
name = "yosys"; name = "yosys";
src = ./. ; src = ./. ;
buildInputs = with pkgs; [ clang bison flex libffi tcl readline python3 llvmPackages.libcxxClang zlib git pkg-configUpstream llvmPackages.bintools ]; buildInputs = with pkgs; [ clang bison flex libffi tcl readline python3 zlib git pkg-configUpstream llvmPackages.bintools ];
checkInputs = with pkgs; [ gtest ]; checkInputs = with pkgs; [ gtest ];
propagatedBuildInputs = [ abc-verifier ]; propagatedBuildInputs = [ abc-verifier ];
preConfigure = "make config-clang"; preConfigure = "make config-clang";
checkTarget = "test"; checkTarget = "unit-test";
installPhase = '' installPhase = ''
make install PREFIX=$out ABCEXTERNAL=yosys-abc make install PREFIX=$out ABCEXTERNAL=yosys-abc
ln -s ${abc-verifier}/bin/abc $out/bin/yosys-abc ln -s ${abc-verifier}/bin/abc $out/bin/yosys-abc
@ -41,7 +41,7 @@
packages.default = yosys; packages.default = yosys;
defaultPackage = yosys; defaultPackage = yosys;
devShell = pkgs.mkShell { devShell = pkgs.mkShell {
buildInputs = with pkgs; [ clang llvmPackages.bintools bison flex libffi tcl readline python3 llvmPackages.libcxxClang zlib git gtest abc-verifier ]; buildInputs = with pkgs; [ clang llvmPackages.bintools gcc bison flex libffi tcl readline python3 zlib git gtest abc-verifier verilog boost python3Packages.boost ];
}; };
} }
); );

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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(Hasher h) const { h.eat(hashidx_); return h; }
// this nodes type // this nodes type
AstNodeType type; AstNodeType type;

4
kernel/bitpattern.h
View File

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

16
kernel/cellaigs.cc
View File

@ -39,13 +39,13 @@ bool AigNode::operator==(const AigNode &other) const
return true; return true;
} }
Hasher AigNode::hash_acc(Hasher h) const Hasher AigNode::hash_eat(Hasher h) const
{ {
h.acc(portname); h.eat(portname);
h.acc(portbit); h.eat(portbit);
h.acc(inverter); h.eat(inverter);
h.acc(left_parent); h.eat(left_parent);
h.acc(right_parent); h.eat(right_parent);
return h; return h;
} }
@ -54,9 +54,9 @@ bool Aig::operator==(const Aig &other) const
return name == other.name; return name == other.name;
} }
Hasher Aig::hash_acc(Hasher h) const Hasher Aig::hash_eat(Hasher h) const
{ {
h.acc(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_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(Hasher h) const;
}; };
YOSYS_NAMESPACE_END YOSYS_NAMESPACE_END

120
kernel/drivertools.h
View File

@ -74,7 +74,7 @@ struct DriveBitWire
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(Hasher h) const;
}; };
@ -129,7 +129,7 @@ struct DriveBitMarker
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_acc(Hasher h) const; Hasher hash_eat(Hasher h) const;
}; };
@ -164,7 +164,7 @@ public:
return multiple_ == other.multiple_; return multiple_ == other.multiple_;
} }
Hasher hash_acc(Hasher h) const; Hasher hash_eat(Hasher h) const;
}; };
struct DriveBit struct DriveBit
@ -352,7 +352,7 @@ public:
return *this; return *this;
} }
Hasher hash_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(Hasher h) const;
}; };
@ -572,7 +572,7 @@ struct DriveChunkMarker
return offset < other.offset; return offset < other.offset;
} }
Hasher hash_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const; Hasher hash_eat(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,130 +1258,130 @@ private:
} }
}; };
inline Hasher DriveBitWire::hash_acc(Hasher h) const inline Hasher DriveBitWire::hash_eat(Hasher h) const
{ {
h.acc(wire->name); h.eat(wire->name);
h.acc(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveBitPort::hash_acc(Hasher h) const inline Hasher DriveBitPort::hash_eat(Hasher h) const
{ {
h.acc(cell->name); h.eat(cell->name);
h.acc(port); h.eat(port);
h.acc(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveBitMarker::hash_acc(Hasher h) const inline Hasher DriveBitMarker::hash_eat(Hasher h) const
{ {
h.acc(marker); h.eat(marker);
h.acc(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveBitMultiple::hash_acc(Hasher h) const inline Hasher DriveBitMultiple::hash_eat(Hasher h) const
{ {
h.acc(multiple_); h.eat(multiple_);
return h; return h;
} }
inline Hasher DriveBit::hash_acc(Hasher h) const inline Hasher DriveBit::hash_eat(Hasher h) const
{ {
switch (type_) { switch (type_) {
case DriveType::NONE: case DriveType::NONE:
h.acc(0); h.eat(0);
break; break;
case DriveType::CONSTANT: case DriveType::CONSTANT:
h.acc(constant_); h.eat(constant_);
break; break;
case DriveType::WIRE: case DriveType::WIRE:
h.acc(wire_); h.eat(wire_);
break; break;
case DriveType::PORT: case DriveType::PORT:
h.acc(port_); h.eat(port_);
break; break;
case DriveType::MARKER: case DriveType::MARKER:
h.acc(marker_); h.eat(marker_);
break; break;
case DriveType::MULTIPLE: case DriveType::MULTIPLE:
h.acc(multiple_); h.eat(multiple_);
break; break;
} }
h.acc(type_); h.eat(type_);
return h; return h;
} }
inline Hasher DriveChunkWire::hash_acc(Hasher h) const inline Hasher DriveChunkWire::hash_eat(Hasher h) const
{ {
h.acc(wire->name); h.eat(wire->name);
h.acc(width); h.eat(width);
h.acc(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveChunkPort::hash_acc(Hasher h) const inline Hasher DriveChunkPort::hash_eat(Hasher h) const
{ {
h.acc(cell->name); h.eat(cell->name);
h.acc(port); h.eat(port);
h.acc(width); h.eat(width);
h.acc(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveChunkMarker::hash_acc(Hasher h) const inline Hasher DriveChunkMarker::hash_eat(Hasher h) const
{ {
h.acc(marker); h.eat(marker);
h.acc(width); h.eat(width);
h.acc(offset); h.eat(offset);
return h; return h;
} }
inline Hasher DriveChunkMultiple::hash_acc(Hasher h) const inline Hasher DriveChunkMultiple::hash_eat(Hasher h) const
{ {
h.acc(width_); h.eat(width_);
h.acc(multiple_); h.eat(multiple_);
return h; return h;
} }
inline Hasher DriveChunk::hash_acc(Hasher h) const inline Hasher DriveChunk::hash_eat(Hasher h) const
{ {
switch (type_) { switch (type_) {
case DriveType::NONE: case DriveType::NONE:
h.acc(0); h.eat(0);
break; break;
case DriveType::CONSTANT: case DriveType::CONSTANT:
h.acc(constant_); h.eat(constant_);
break; break;
case DriveType::WIRE: case DriveType::WIRE:
h.acc(wire_); h.eat(wire_);
break; break;
case DriveType::PORT: case DriveType::PORT:
h.acc(port_); h.eat(port_);
break; break;
case DriveType::MARKER: case DriveType::MARKER:
h.acc(marker_); h.eat(marker_);
break; break;
case DriveType::MULTIPLE: case DriveType::MULTIPLE:
h.acc(multiple_); h.eat(multiple_);
break; break;
} }
h.acc(type_); h.eat(type_);
return h; return h;
} }
inline Hasher DriveSpec::hash_acc(Hasher h) const inline Hasher DriveSpec::hash_eat(Hasher h) const
{ {
if (hash_ == 0) if (hash_ == 0)
updhash(); updhash();
h.acc(hash_); h.eat(hash_);
return h; return h;
} }
inline Hasher DriverMap::DriveBitId::hash_acc(Hasher h) const inline Hasher DriverMap::DriveBitId::hash_eat(Hasher h) const
{ {
h.acc(id); h.eat(id);
return h; return h;
} }

8
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_acc(Hasher h) const { h.acc(_v); return h; } Hasher hash_eat(Hasher h) const { h.eat(_v); return h; }
}; };
class IR; class IR;
class Factory; class Factory;
@ -225,9 +225,9 @@ 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_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc((unsigned int) _fn); h.eat((unsigned int) _fn);
h.acc(_extra); h.eat(_extra);
return h; return h;
} }
bool operator==(NodeData const &other) const { bool operator==(NodeData const &other) const {

84
kernel/hashlib.h
View File

@ -125,16 +125,16 @@ private:
} }
template<typename T> template<typename T>
void acc(T&& t) { void eat(T&& t) {
*this = hash_ops<std::remove_cv_t<std::remove_reference_t<T>>>::hash_acc(std::forward<T>(t), *this); *this = hash_ops<std::remove_cv_t<std::remove_reference_t<T>>>::hash_eat(std::forward<T>(t), *this);
} }
template<typename T> template<typename T>
void acc(const T& t) { void eat(const T& t) {
*this = hash_ops<T>::hash_acc(t, *this); *this = hash_ops<T>::hash_eat(t, *this);
} }
void commutative_acc(hash_t t) { void commutative_eat(hash_t t) {
state ^= t; state ^= t;
} }
@ -151,7 +151,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_acc(a, Hasher()); return hash_ops<T>::hash_eat(a, Hasher());
} }
}; };
@ -160,7 +160,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_acc(const T &a, Hasher h) { static inline Hasher hash_eat(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;
@ -173,15 +173,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_acc((u_type) a, h); return hash_ops<u_type>::hash_eat((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_acc((uintptr_t) a, h); return hash_ops<uintptr_t>::hash_eat((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_acc(h); return a.hash_eat(h);
} }
} }
}; };
@ -190,9 +190,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_acc(std::pair<P, Q> a, Hasher h) { static inline Hasher hash_eat(std::pair<P, Q> a, Hasher h) {
h = hash_ops<P>::hash_acc(a.first, h); h = hash_ops<P>::hash_eat(a.first, h);
h = hash_ops<Q>::hash_acc(a.second, h); h = hash_ops<Q>::hash_eat(a.second, h);
return h; return h;
} }
}; };
@ -202,14 +202,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_acc(std::tuple<T...>, Hasher h) { static inline typename std::enable_if<I == sizeof...(T), Hasher>::type hash_eat(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_acc(std::tuple<T...> a, Hasher h) { static inline typename std::enable_if<I != sizeof...(T), Hasher>::type hash_eat(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_acc<I+1>(a, h); h = hash_eat<I+1>(a, h);
h = element_ops_t::hash_acc(std::get<I>(a), h); h = element_ops_t::hash_eat(std::get<I>(a), h);
return h; return h;
} }
}; };
@ -218,10 +218,10 @@ 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_acc(std::vector<T> a, Hasher h) { static inline Hasher hash_eat(std::vector<T> a, Hasher h) {
h.acc(a.size()); h.eat(a.size());
for (auto k : a) for (auto k : a)
h.acc(k); h.eat(k);
return h; return h;
} }
}; };
@ -230,9 +230,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_acc(std::array<T, N> a, Hasher h) { static inline Hasher hash_eat(std::array<T, N> a, Hasher h) {
for (const auto& k : a) for (const auto& k : a)
h = hash_ops<T>::hash_acc(k, h); h = hash_ops<T>::hash_eat(k, h);
return h; return h;
} }
}; };
@ -244,7 +244,7 @@ struct hash_cstr_ops {
return false; return false;
return true; return true;
} }
static inline Hasher hash_acc(const char *a, Hasher h) { static inline Hasher hash_eat(const char *a, Hasher h) {
while (*a) while (*a)
h.hash32(*(a++)); h.hash32(*(a++));
return h; return h;
@ -257,8 +257,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_acc(const void *a, Hasher h) { static inline Hasher hash_eat(const void *a, Hasher h) {
return hash_ops<uintptr_t>::hash_acc((uintptr_t)a, h); return hash_ops<uintptr_t>::hash_eat((uintptr_t)a, h);
} }
}; };
@ -267,8 +267,8 @@ struct hash_obj_ops {
return a == b; return a == b;
} }
template<typename T> template<typename T>
static inline Hasher hash_acc(const T *a, Hasher h) { static inline Hasher hash_eat(const T *a, Hasher h) {
return a ? a->hash_acc(h) : h; return a ? a->hash_eat(h) : h;
} }
}; };
/** /**
@ -295,7 +295,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_acc(std::monostate, Hasher h) { static inline Hasher hash_eat(std::monostate, Hasher h) {
return h; return h;
} }
}; };
@ -304,9 +304,9 @@ 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_acc(std::variant<T...> a, Hasher h) { static inline Hasher hash_eat(std::variant<T...> a, Hasher h) {
std::visit([& h](const auto &v) { h.acc(v); }, a); std::visit([& h](const auto &v) { h.eat(v); }, a);
h.acc(a.index()); h.eat(a.index());
return h; return h;
} }
}; };
@ -315,11 +315,11 @@ 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_acc(std::optional<T> a, Hasher h) { static inline Hasher hash_eat(std::optional<T> a, Hasher h) {
if(a.has_value()) if(a.has_value())
h.acc(*a); h.eat(*a);
else else
h.acc(0); h.eat(0);
return h; return h;
} }
}; };
@ -788,13 +788,13 @@ public:
return !operator==(other); return !operator==(other);
} }
Hasher hash_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(entries.size()); h.eat(entries.size());
for (auto &it : entries) { for (auto &it : entries) {
Hasher entry_hash; Hasher entry_hash;
entry_hash.acc(it.udata.first); entry_hash.eat(it.udata.first);
entry_hash.acc(it.udata.second); entry_hash.eat(it.udata.second);
h.commutative_acc(entry_hash.yield()); h.commutative_eat(entry_hash.yield());
} }
return h; return h;
} }
@ -1158,10 +1158,10 @@ public:
return !operator==(other); return !operator==(other);
} }
Hasher hash_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(entries.size()); h.eat(entries.size());
for (auto &it : entries) { for (auto &it : entries) {
h.commutative_acc(ops.hash(it.udata).yield()); h.commutative_eat(ops.hash(it.udata).yield());
} }
return h; return h;
} }

16
kernel/modtools.h
View File

@ -48,10 +48,10 @@ 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_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(cell->name); h.eat(cell->name);
h.acc(port); h.eat(port);
h.acc(offset); h.eat(offset);
return h; return h;
} }
}; };
@ -324,10 +324,10 @@ struct ModWalker
return cell == other.cell && port == other.port && offset == other.offset; return cell == other.cell && port == other.port && offset == other.offset;
} }
Hasher hash_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(cell->name); h.eat(cell->name);
h.acc(port); h.eat(port);
h.acc(offset); h.eat(offset);
return h; return h;
} }
}; };

8
kernel/rtlil.cc
View File

@ -4480,11 +4480,11 @@ void RTLIL::SigSpec::updhash() const
for (auto &c : that->chunks_) for (auto &c : that->chunks_)
if (c.wire == NULL) { if (c.wire == NULL) {
for (auto &v : c.data) for (auto &v : c.data)
h.acc(v); h.eat(v);
} else { } else {
h.acc(c.wire->name.index_); h.eat(c.wire->name.index_);
h.acc(c.offset); h.eat(c.offset);
h.acc(c.width); h.eat(c.width);
} }
that->hash_ = h.yield(); that->hash_ = h.yield();
if (that->hash_ == 0) if (that->hash_ == 0)

32
kernel/rtlil.h
View File

@ -362,7 +362,7 @@ struct RTLIL::IdString
*this = IdString(); *this = IdString();
} }
Hasher hash_acc(Hasher h) const { return hash_ops<int>::hash_acc(index_, h); } Hasher hash_eat(Hasher h) const { return hash_ops<int>::hash_eat(index_, h); }
Hasher hash_top() const { Hasher hash_top() const {
Hasher h; Hasher h;
@ -815,10 +815,10 @@ public:
bv.resize(width, bv.empty() ? RTLIL::State::Sx : bv.back()); bv.resize(width, bv.empty() ? RTLIL::State::Sx : bv.back());
} }
inline Hasher hash_acc(Hasher h) const { inline Hasher hash_eat(Hasher h) const {
// TODO hash size // TODO hash size
for (auto b : *this) for (auto b : *this)
h.acc(b); h.eat(b);
return h; return h;
} }
}; };
@ -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_acc(Hasher h) const; Hasher hash_eat(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_acc(Hasher h) const { if (!hash_) updhash(); h.acc(hash_); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(hashidx_); return h; } Hasher hash_eat(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,13 +1848,13 @@ 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_acc(Hasher h) const { inline Hasher RTLIL::SigBit::hash_eat(Hasher h) const {
if (wire) { if (wire) {
h.acc(offset); h.eat(offset);
h.acc(wire->name); h.eat(wire->name);
return h; return h;
} }
h.acc(data); h.eat(data);
return h; return h;
} }

6
kernel/scopeinfo.h
View File

@ -171,8 +171,8 @@ public:
Hasher hash_acc(Hasher h) const Hasher hash_acc(Hasher h) const
{ {
h.acc(scope_name); h.eat(scope_name);
h.acc(target); h.eat(target);
return h; return h;
} }
@ -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_acc(Hasher h) const { h.acc(ptr); return h; } Hasher hash_eat(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)); }

12
kernel/sigtools.h
View File

@ -29,9 +29,9 @@ 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_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(first->name); h.eat(first->name);
h.acc(second); h.eat(second);
return h; return h;
} }
}; };
@ -147,9 +147,9 @@ 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_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(first->name); h.eat(first->name);
h.acc(second); h.eat(second);
return h; return h;
} }
}; };

12
kernel/timinginfo.h
View File

@ -44,9 +44,9 @@ struct TimingInfo
return {}; return {};
return port[offset]; return port[offset];
} }
Hasher hash_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(name); h.eat(name);
h.acc(offset); h.eat(offset);
return h; return h;
} }
}; };
@ -56,9 +56,9 @@ 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_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(first); h.eat(first);
h.acc(second); h.eat(second);
return h; return h;
} }
}; };

4
kernel/yosys_common.h
View File

@ -171,8 +171,8 @@ 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_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(*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_acc(Hasher h) const { h.acc(*this); return h; } Hasher hash_eat(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_acc(Hasher h) const { h.acc(index); return h; } Hasher hash_eat(Hasher h) const { h.eat(index); return h; }
bool empty() const { return index == 0; } bool empty() const { return index == 0; }
}; };

6
passes/cmds/example_dt.cc
View File

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

10
passes/equiv/equiv_struct.cc
View File

@ -46,11 +46,11 @@ struct EquivStructWorker
parameters == other.parameters && port_sizes == other.port_sizes; parameters == other.parameters && port_sizes == other.port_sizes;
} }
Hasher hash_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(type); h.eat(type);
h.acc(parameters); h.eat(parameters);
h.acc(port_sizes); h.eat(port_sizes);
h.acc(connections); h.eat(connections);
return h; return h;
} }
}; };

8
passes/proc/proc_dlatch.cc
View File

@ -127,10 +127,10 @@ 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_acc(Hasher h) const { Hasher hash_eat(Hasher h) const {
h.acc(signal); h.eat(signal);
h.acc(match); h.eat(match);
h.acc(children); h.eat(children);
return h; return h;
} }
}; };

12
passes/sat/recover_names.cc
View File

@ -46,10 +46,10 @@ 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_acc(Hasher h) const Hasher hash_eat(Hasher h) const
{ {
h.acc(name); h.eat(name);
h.acc(bit); h.eat(bit);
return h; return h;
} }
@ -64,10 +64,10 @@ 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_acc(Hasher h) const Hasher hash_eat(Hasher h) const
{ {
h.acc(bit); h.eat(bit);
h.acc(inverted); h.eat(inverted);
return h; return h;
} }

4
passes/techmap/clockgate.cc
View File

@ -233,9 +233,9 @@ struct ClockgatePass : public Pass {
SigBit ce_bit; SigBit ce_bit;
bool pol_clk; bool pol_clk;
bool pol_ce; bool pol_ce;
Hasher hash_acc(Hasher h) const { Hasher hash_eat(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.acc(t); h.eat(t);
return h; return h;
} }
bool operator==(const ClkNetInfo& other) const { bool operator==(const ClkNetInfo& other) const {

4
passes/techmap/flowmap.cc
View File

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

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_acc(Hasher h) const { h.acc(connections); return h; } Hasher hash_eat(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; }
}; };