From 4e29ec18543d290e599f921be3120b7470aad020 Mon Sep 17 00:00:00 2001 From: "Emil J. Tywoniak" Date: Mon, 11 Nov 2024 15:45:11 +0100 Subject: [PATCH] hashlib: acc -> eat --- docs/source/yosys_internals/hashing.rst | 14 +-- flake.nix | 8 +- frontends/ast/ast.h | 2 +- kernel/bitpattern.h | 4 +- kernel/cellaigs.cc | 16 ++-- kernel/cellaigs.h | 4 +- kernel/drivertools.h | 120 ++++++++++++------------ kernel/functional.h | 8 +- kernel/hashlib.h | 84 ++++++++--------- kernel/modtools.h | 16 ++-- kernel/rtlil.cc | 8 +- kernel/rtlil.h | 32 +++---- kernel/scopeinfo.h | 6 +- kernel/sigtools.h | 12 +-- kernel/timinginfo.h | 12 +-- kernel/yosys_common.h | 4 +- kernel/yw.h | 2 +- passes/cmds/dft_tag.cc | 2 +- passes/cmds/example_dt.cc | 6 +- passes/equiv/equiv_struct.cc | 10 +- passes/proc/proc_dlatch.cc | 8 +- passes/sat/recover_names.cc | 12 +-- passes/techmap/clockgate.cc | 4 +- passes/techmap/flowmap.cc | 4 +- techlibs/quicklogic/ql_dsp_simd.cc | 2 +- 25 files changed, 200 insertions(+), 200 deletions(-) diff --git a/docs/source/yosys_internals/hashing.rst b/docs/source/yosys_internals/hashing.rst index 0d74f9014..b6d8df6ef 100644 --- a/docs/source/yosys_internals/hashing.rst +++ b/docs/source/yosys_internals/hashing.rst @@ -98,13 +98,13 @@ Making a type hashable 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 ``run_hash(const T& obj)``, corresponding to ``hash_top_ops::hash(obj)``, -the default implementation of which is ``hash_ops::hash_acc(Hasher(), obj)``. +the default implementation of which is ``hash_ops::hash_eat(Hasher(), obj)``. ``Hasher`` is the class actually implementing the hash function, hiding its initialized internal state, and passing it out on ``hash_t yield()`` with perhaps some finalization steps. ``hash_ops`` 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 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 ``Hasher::hash_t hashidx_;``, there are specializations for ``hash_ops`` 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`` is also specialized for simple compound types like -``std::pair`` by calling hash_acc in sequence on its members. For flexible +``std::pair`` by calling hash_eat in sequence on its members. For flexible size containers like ``std::vector`` the size of the container is hashed 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 h;``. If you do have a strong reason to do so, look at how ``hash_top_ops`` 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 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`` .. code-block:: cpp @@ -143,7 +143,7 @@ redirecting to ``hash_ops`` inline unsigned int T::hash() const { 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 diff --git a/flake.nix b/flake.nix index 90fa5328c..19ba59f17 100644 --- a/flake.nix +++ b/flake.nix @@ -14,15 +14,15 @@ }; # TODO: don't override src when ./abc is empty # 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 { name = "yosys"; 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 ]; propagatedBuildInputs = [ abc-verifier ]; preConfigure = "make config-clang"; - checkTarget = "test"; + checkTarget = "unit-test"; installPhase = '' make install PREFIX=$out ABCEXTERNAL=yosys-abc ln -s ${abc-verifier}/bin/abc $out/bin/yosys-abc @@ -41,7 +41,7 @@ packages.default = yosys; defaultPackage = yosys; 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 ]; }; } ); diff --git a/frontends/ast/ast.h b/frontends/ast/ast.h index 1a72e6285..472219034 100644 --- a/frontends/ast/ast.h +++ b/frontends/ast/ast.h @@ -177,7 +177,7 @@ namespace AST { // for dict<> and pool<> 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 AstNodeType type; diff --git a/kernel/bitpattern.h b/kernel/bitpattern.h index 3814f4672..7752acc42 100644 --- a/kernel/bitpattern.h +++ b/kernel/bitpattern.h @@ -43,10 +43,10 @@ struct BitPatternPool return false; return bitdata == other.bitdata; } - Hasher hash_acc(Hasher h) const { + Hasher hash_eat(Hasher h) const { if (!cached_hash) cached_hash = run_hash(bitdata); - h.acc(cached_hash); + h.eat(cached_hash); return h; } }; diff --git a/kernel/cellaigs.cc b/kernel/cellaigs.cc index 81b486c79..63bbbca37 100644 --- a/kernel/cellaigs.cc +++ b/kernel/cellaigs.cc @@ -39,13 +39,13 @@ bool AigNode::operator==(const AigNode &other) const return true; } -Hasher AigNode::hash_acc(Hasher h) const +Hasher AigNode::hash_eat(Hasher h) const { - h.acc(portname); - h.acc(portbit); - h.acc(inverter); - h.acc(left_parent); - h.acc(right_parent); + h.eat(portname); + h.eat(portbit); + h.eat(inverter); + h.eat(left_parent); + h.eat(right_parent); return h; } @@ -54,9 +54,9 @@ bool Aig::operator==(const Aig &other) const 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; } diff --git a/kernel/cellaigs.h b/kernel/cellaigs.h index bdb8b3c07..8d3f03120 100644 --- a/kernel/cellaigs.h +++ b/kernel/cellaigs.h @@ -34,7 +34,7 @@ struct AigNode AigNode(); bool operator==(const AigNode &other) const; - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; }; struct Aig @@ -44,7 +44,7 @@ struct Aig Aig(Cell *cell); bool operator==(const Aig &other) const; - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; }; YOSYS_NAMESPACE_END diff --git a/kernel/drivertools.h b/kernel/drivertools.h index 0e7b872e4..b46c1e2b6 100644 --- a/kernel/drivertools.h +++ b/kernel/drivertools.h @@ -74,7 +74,7 @@ struct DriveBitWire return offset < other.offset; } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; operator SigBit() const @@ -105,7 +105,7 @@ struct DriveBitPort 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; } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; }; @@ -164,7 +164,7 @@ public: return multiple_ == other.multiple_; } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; }; struct DriveBit @@ -352,7 +352,7 @@ public: return *this; } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; bool operator==(const DriveBit &other) const { @@ -473,7 +473,7 @@ struct DriveChunkWire return offset < other.offset; } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; explicit operator SigChunk() const { @@ -531,7 +531,7 @@ struct DriveChunkPort 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; } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; }; struct DriveChunkMultiple @@ -612,7 +612,7 @@ public: return false; // TODO implement, canonicalize order } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; }; struct DriveChunk @@ -863,7 +863,7 @@ public: bool try_append(DriveBit const &bit); bool try_append(DriveChunk const &chunk); - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; bool operator==(const DriveChunk &other) const { @@ -1073,7 +1073,7 @@ public: that->hash_ |= (that->hash_ == 0); } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; bool operator==(DriveSpec const &other) const { 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; } // unsigned int hash() const { return id; } - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; }; // Essentially a dict> but using less memory // 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.acc(offset); + h.eat(wire->name); + h.eat(offset); return h; } -inline Hasher DriveBitPort::hash_acc(Hasher h) const +inline Hasher DriveBitPort::hash_eat(Hasher h) const { - h.acc(cell->name); - h.acc(port); - h.acc(offset); + h.eat(cell->name); + h.eat(port); + h.eat(offset); return h; } -inline Hasher DriveBitMarker::hash_acc(Hasher h) const +inline Hasher DriveBitMarker::hash_eat(Hasher h) const { - h.acc(marker); - h.acc(offset); + h.eat(marker); + h.eat(offset); 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; } -inline Hasher DriveBit::hash_acc(Hasher h) const +inline Hasher DriveBit::hash_eat(Hasher h) const { switch (type_) { case DriveType::NONE: - h.acc(0); + h.eat(0); break; case DriveType::CONSTANT: - h.acc(constant_); + h.eat(constant_); break; case DriveType::WIRE: - h.acc(wire_); + h.eat(wire_); break; case DriveType::PORT: - h.acc(port_); + h.eat(port_); break; case DriveType::MARKER: - h.acc(marker_); + h.eat(marker_); break; case DriveType::MULTIPLE: - h.acc(multiple_); + h.eat(multiple_); break; } - h.acc(type_); + h.eat(type_); return h; } -inline Hasher DriveChunkWire::hash_acc(Hasher h) const +inline Hasher DriveChunkWire::hash_eat(Hasher h) const { - h.acc(wire->name); - h.acc(width); - h.acc(offset); + h.eat(wire->name); + h.eat(width); + h.eat(offset); return h; } -inline Hasher DriveChunkPort::hash_acc(Hasher h) const +inline Hasher DriveChunkPort::hash_eat(Hasher h) const { - h.acc(cell->name); - h.acc(port); - h.acc(width); - h.acc(offset); + h.eat(cell->name); + h.eat(port); + h.eat(width); + h.eat(offset); return h; } -inline Hasher DriveChunkMarker::hash_acc(Hasher h) const +inline Hasher DriveChunkMarker::hash_eat(Hasher h) const { - h.acc(marker); - h.acc(width); - h.acc(offset); + h.eat(marker); + h.eat(width); + h.eat(offset); return h; } -inline Hasher DriveChunkMultiple::hash_acc(Hasher h) const +inline Hasher DriveChunkMultiple::hash_eat(Hasher h) const { - h.acc(width_); - h.acc(multiple_); + h.eat(width_); + h.eat(multiple_); return h; } -inline Hasher DriveChunk::hash_acc(Hasher h) const +inline Hasher DriveChunk::hash_eat(Hasher h) const { switch (type_) { case DriveType::NONE: - h.acc(0); + h.eat(0); break; case DriveType::CONSTANT: - h.acc(constant_); + h.eat(constant_); break; case DriveType::WIRE: - h.acc(wire_); + h.eat(wire_); break; case DriveType::PORT: - h.acc(port_); + h.eat(port_); break; case DriveType::MARKER: - h.acc(marker_); + h.eat(marker_); break; case DriveType::MULTIPLE: - h.acc(multiple_); + h.eat(multiple_); break; } - h.acc(type_); + h.eat(type_); return h; } -inline Hasher DriveSpec::hash_acc(Hasher h) const +inline Hasher DriveSpec::hash_eat(Hasher h) const { if (hash_ == 0) updhash(); - h.acc(hash_); + h.eat(hash_); 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; } diff --git a/kernel/functional.h b/kernel/functional.h index b80c77be4..790190e08 100644 --- a/kernel/functional.h +++ b/kernel/functional.h @@ -151,7 +151,7 @@ namespace Functional { // returns the data width of a bitvector sort, errors out for other sorts int data_width() const { return std::get<1>(_v).second; } 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 Factory; @@ -225,9 +225,9 @@ namespace Functional { const RTLIL::Const &as_const() const { return std::get(_extra); } std::pair as_idstring_pair() const { return std::get>(_extra); } int as_int() const { return std::get(_extra); } - Hasher hash_acc(Hasher h) const { - h.acc((unsigned int) _fn); - h.acc(_extra); + Hasher hash_eat(Hasher h) const { + h.eat((unsigned int) _fn); + h.eat(_extra); return h; } bool operator==(NodeData const &other) const { diff --git a/kernel/hashlib.h b/kernel/hashlib.h index df6a4853c..f66baa429 100644 --- a/kernel/hashlib.h +++ b/kernel/hashlib.h @@ -125,16 +125,16 @@ private: } template - void acc(T&& t) { - *this = hash_ops>>::hash_acc(std::forward(t), *this); + void eat(T&& t) { + *this = hash_ops>>::hash_eat(std::forward(t), *this); } template - void acc(const T& t) { - *this = hash_ops::hash_acc(t, *this); + void eat(const T& t) { + *this = hash_ops::hash_eat(t, *this); } - void commutative_acc(hash_t t) { + void commutative_eat(hash_t t) { state ^= t; } @@ -151,7 +151,7 @@ struct hash_top_ops { return hash_ops::cmp(a, b); } static inline Hasher hash(const T &a) { - return hash_ops::hash_acc(a, Hasher()); + return hash_ops::hash_eat(a, Hasher()); } }; @@ -160,7 +160,7 @@ struct hash_ops { static inline bool cmp(const T &a, const T &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) { h.hash32(a ? 1 : 0); return h; @@ -173,15 +173,15 @@ struct hash_ops { return h; } else if constexpr (std::is_enum_v) { using u_type = std::underlying_type_t; - return hash_ops::hash_acc((u_type) a, h); + return hash_ops::hash_eat((u_type) a, h); } else if constexpr (std::is_pointer_v) { - return hash_ops::hash_acc((uintptr_t) a, h); + return hash_ops::hash_eat((uintptr_t) a, h); } else if constexpr (std::is_same_v) { for (auto c : a) h.hash32(c); return h; } else { - return a.hash_acc(h); + return a.hash_eat(h); } } }; @@ -190,9 +190,9 @@ template struct hash_ops> { static inline bool cmp(std::pair a, std::pair b) { return a == b; } - static inline Hasher hash_acc(std::pair a, Hasher h) { - h = hash_ops

::hash_acc(a.first, h); - h = hash_ops::hash_acc(a.second, h); + static inline Hasher hash_eat(std::pair a, Hasher h) { + h = hash_ops

::hash_eat(a.first, h); + h = hash_ops::hash_eat(a.second, h); return h; } }; @@ -202,14 +202,14 @@ template struct hash_ops> { return a == b; } template - static inline typename std::enable_if::type hash_acc(std::tuple, Hasher h) { + static inline typename std::enable_if::type hash_eat(std::tuple, Hasher h) { return h; } template - static inline typename std::enable_if::type hash_acc(std::tuple a, Hasher h) { + static inline typename std::enable_if::type hash_eat(std::tuple a, Hasher h) { typedef hash_ops>::type> element_ops_t; - h = hash_acc(a, h); - h = element_ops_t::hash_acc(std::get(a), h); + h = hash_eat(a, h); + h = element_ops_t::hash_eat(std::get(a), h); return h; } }; @@ -218,10 +218,10 @@ template struct hash_ops> { static inline bool cmp(std::vector a, std::vector b) { return a == b; } - static inline Hasher hash_acc(std::vector a, Hasher h) { - h.acc(a.size()); + static inline Hasher hash_eat(std::vector a, Hasher h) { + h.eat(a.size()); for (auto k : a) - h.acc(k); + h.eat(k); return h; } }; @@ -230,9 +230,9 @@ template struct hash_ops> { static inline bool cmp(std::array a, std::array b) { return a == b; } - static inline Hasher hash_acc(std::array a, Hasher h) { + static inline Hasher hash_eat(std::array a, Hasher h) { for (const auto& k : a) - h = hash_ops::hash_acc(k, h); + h = hash_ops::hash_eat(k, h); return h; } }; @@ -244,7 +244,7 @@ struct hash_cstr_ops { return false; return true; } - static inline Hasher hash_acc(const char *a, Hasher h) { + static inline Hasher hash_eat(const char *a, Hasher h) { while (*a) h.hash32(*(a++)); return h; @@ -257,8 +257,8 @@ struct hash_ptr_ops { static inline bool cmp(const void *a, const void *b) { return a == b; } - static inline Hasher hash_acc(const void *a, Hasher h) { - return hash_ops::hash_acc((uintptr_t)a, h); + static inline Hasher hash_eat(const void *a, Hasher h) { + return hash_ops::hash_eat((uintptr_t)a, h); } }; @@ -267,8 +267,8 @@ struct hash_obj_ops { return a == b; } template - static inline Hasher hash_acc(const T *a, Hasher h) { - return a ? a->hash_acc(h) : h; + static inline Hasher hash_eat(const T *a, Hasher h) { + return a ? a->hash_eat(h) : h; } }; /** @@ -295,7 +295,7 @@ template<> struct hash_ops { static inline bool cmp(std::monostate a, std::monostate b) { return a == b; } - static inline Hasher hash_acc(std::monostate, Hasher h) { + static inline Hasher hash_eat(std::monostate, Hasher h) { return h; } }; @@ -304,9 +304,9 @@ template struct hash_ops> { static inline bool cmp(std::variant a, std::variant b) { return a == b; } - static inline Hasher hash_acc(std::variant a, Hasher h) { - std::visit([& h](const auto &v) { h.acc(v); }, a); - h.acc(a.index()); + static inline Hasher hash_eat(std::variant a, Hasher h) { + std::visit([& h](const auto &v) { h.eat(v); }, a); + h.eat(a.index()); return h; } }; @@ -315,11 +315,11 @@ template struct hash_ops> { static inline bool cmp(std::optional a, std::optional b) { return a == b; } - static inline Hasher hash_acc(std::optional a, Hasher h) { + static inline Hasher hash_eat(std::optional a, Hasher h) { if(a.has_value()) - h.acc(*a); + h.eat(*a); else - h.acc(0); + h.eat(0); return h; } }; @@ -788,13 +788,13 @@ public: return !operator==(other); } - Hasher hash_acc(Hasher h) const { - h.acc(entries.size()); + Hasher hash_eat(Hasher h) const { + h.eat(entries.size()); for (auto &it : entries) { Hasher entry_hash; - entry_hash.acc(it.udata.first); - entry_hash.acc(it.udata.second); - h.commutative_acc(entry_hash.yield()); + entry_hash.eat(it.udata.first); + entry_hash.eat(it.udata.second); + h.commutative_eat(entry_hash.yield()); } return h; } @@ -1158,10 +1158,10 @@ public: return !operator==(other); } - Hasher hash_acc(Hasher h) const { - h.acc(entries.size()); + Hasher hash_eat(Hasher h) const { + h.eat(entries.size()); for (auto &it : entries) { - h.commutative_acc(ops.hash(it.udata).yield()); + h.commutative_eat(ops.hash(it.udata).yield()); } return h; } diff --git a/kernel/modtools.h b/kernel/modtools.h index 1afa0ad50..fce22d857 100644 --- a/kernel/modtools.h +++ b/kernel/modtools.h @@ -48,10 +48,10 @@ struct ModIndex : public RTLIL::Monitor return cell == other.cell && port == other.port && offset == other.offset; } - Hasher hash_acc(Hasher h) const { - h.acc(cell->name); - h.acc(port); - h.acc(offset); + Hasher hash_eat(Hasher h) const { + h.eat(cell->name); + h.eat(port); + h.eat(offset); return h; } }; @@ -324,10 +324,10 @@ struct ModWalker return cell == other.cell && port == other.port && offset == other.offset; } - Hasher hash_acc(Hasher h) const { - h.acc(cell->name); - h.acc(port); - h.acc(offset); + Hasher hash_eat(Hasher h) const { + h.eat(cell->name); + h.eat(port); + h.eat(offset); return h; } }; diff --git a/kernel/rtlil.cc b/kernel/rtlil.cc index 65510362e..cb0f7da78 100644 --- a/kernel/rtlil.cc +++ b/kernel/rtlil.cc @@ -4480,11 +4480,11 @@ void RTLIL::SigSpec::updhash() const for (auto &c : that->chunks_) if (c.wire == NULL) { for (auto &v : c.data) - h.acc(v); + h.eat(v); } else { - h.acc(c.wire->name.index_); - h.acc(c.offset); - h.acc(c.width); + h.eat(c.wire->name.index_); + h.eat(c.offset); + h.eat(c.width); } that->hash_ = h.yield(); if (that->hash_ == 0) diff --git a/kernel/rtlil.h b/kernel/rtlil.h index b17b82c47..eaf2eaf8e 100644 --- a/kernel/rtlil.h +++ b/kernel/rtlil.h @@ -362,7 +362,7 @@ struct RTLIL::IdString *this = IdString(); } - Hasher hash_acc(Hasher h) const { return hash_ops::hash_acc(index_, h); } + Hasher hash_eat(Hasher h) const { return hash_ops::hash_eat(index_, h); } Hasher hash_top() const { Hasher h; @@ -815,10 +815,10 @@ public: 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 for (auto b : *this) - h.acc(b); + h.eat(b); 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; - Hasher hash_acc(Hasher h) const; + Hasher hash_eat(Hasher h) const; Hasher hash_top() const; }; @@ -1115,7 +1115,7 @@ public: operator std::vector() const { return bits(); } 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 void check(Module *mod = nullptr) const; @@ -1157,7 +1157,7 @@ struct RTLIL::Selection struct RTLIL::Monitor { 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() { static unsigned int hashidx_count = 123456789; @@ -1180,7 +1180,7 @@ struct define_map_t; struct RTLIL::Design { 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 monitors; dict scratchpad; @@ -1285,7 +1285,7 @@ struct RTLIL::Design struct RTLIL::Module : public RTLIL::AttrObject { 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: 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 { 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: // 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 { 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(); @@ -1694,7 +1694,7 @@ struct RTLIL::Memory : public RTLIL::AttrObject struct RTLIL::Cell : public RTLIL::AttrObject { 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: // use module->addCell() and module->remove() to create or destroy cells @@ -1804,7 +1804,7 @@ struct RTLIL::SyncRule struct RTLIL::Process : public RTLIL::AttrObject { 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: // 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)); } -inline Hasher RTLIL::SigBit::hash_acc(Hasher h) const { +inline Hasher RTLIL::SigBit::hash_eat(Hasher h) const { if (wire) { - h.acc(offset); - h.acc(wire->name); + h.eat(offset); + h.eat(wire->name); return h; } - h.acc(data); + h.eat(data); return h; } diff --git a/kernel/scopeinfo.h b/kernel/scopeinfo.h index fa550dab6..3c9ca69b6 100644 --- a/kernel/scopeinfo.h +++ b/kernel/scopeinfo.h @@ -171,8 +171,8 @@ public: Hasher hash_acc(Hasher h) const { - h.acc(scope_name); - h.acc(target); + h.eat(scope_name); + h.eat(target); return h; } @@ -325,7 +325,7 @@ struct ModuleItem { Cell *cell() const { return type == Type::Cell ? static_cast(ptr) : nullptr; } 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::Cursor cursor ) { log("%p %s", cursor.target, log_id(cursor.scope_name)); } diff --git a/kernel/sigtools.h b/kernel/sigtools.h index f3779c37c..c827807aa 100644 --- a/kernel/sigtools.h +++ b/kernel/sigtools.h @@ -29,9 +29,9 @@ struct SigPool struct bitDef_t : public std::pair { bitDef_t() : std::pair(NULL, 0) { } bitDef_t(const RTLIL::SigBit &bit) : std::pair(bit.wire, bit.offset) { } - Hasher hash_acc(Hasher h) const { - h.acc(first->name); - h.acc(second); + Hasher hash_eat(Hasher h) const { + h.eat(first->name); + h.eat(second); return h; } }; @@ -147,9 +147,9 @@ struct SigSet struct bitDef_t : public std::pair { bitDef_t() : std::pair(NULL, 0) { } bitDef_t(const RTLIL::SigBit &bit) : std::pair(bit.wire, bit.offset) { } - Hasher hash_acc(Hasher h) const { - h.acc(first->name); - h.acc(second); + Hasher hash_eat(Hasher h) const { + h.eat(first->name); + h.eat(second); return h; } }; diff --git a/kernel/timinginfo.h b/kernel/timinginfo.h index 373615f59..e294d29a7 100644 --- a/kernel/timinginfo.h +++ b/kernel/timinginfo.h @@ -44,9 +44,9 @@ struct TimingInfo return {}; return port[offset]; } - Hasher hash_acc(Hasher h) const { - h.acc(name); - h.acc(offset); + Hasher hash_eat(Hasher h) const { + h.eat(name); + h.eat(offset); return h; } }; @@ -56,9 +56,9 @@ struct TimingInfo BitBit(const NameBit &first, const NameBit &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; } - Hasher hash_acc(Hasher h) const { - h.acc(first); - h.acc(second); + Hasher hash_eat(Hasher h) const { + h.eat(first); + h.eat(second); return h; } }; diff --git a/kernel/yosys_common.h b/kernel/yosys_common.h index 954a2a53f..b194718f1 100644 --- a/kernel/yosys_common.h +++ b/kernel/yosys_common.h @@ -171,8 +171,8 @@ struct shared_str { const char *c_str() const { return content->c_str(); } const string &str() const { return *content; } bool operator==(const shared_str &other) const { return *content == *other.content; } - Hasher hash_acc(Hasher h) const { - h.acc(*content); + Hasher hash_eat(Hasher h) const { + h.eat(*content); return h; } }; diff --git a/kernel/yw.h b/kernel/yw.h index a4bae5515..e16d49866 100644 --- a/kernel/yw.h +++ b/kernel/yw.h @@ -35,7 +35,7 @@ struct IdPath : public std::vector bool has_address() const { int tmp; return get_address(tmp); }; 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 { diff --git a/passes/cmds/dft_tag.cc b/passes/cmds/dft_tag.cc index 0b1127a11..2a5fb690e 100644 --- a/passes/cmds/dft_tag.cc +++ b/passes/cmds/dft_tag.cc @@ -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; } - 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; } }; diff --git a/passes/cmds/example_dt.cc b/passes/cmds/example_dt.cc index 97ce26327..7cd1d2f24 100644 --- a/passes/cmds/example_dt.cc +++ b/passes/cmds/example_dt.cc @@ -52,9 +52,9 @@ struct ExampleDtPass : public Pass return name == other.name && parameters == other.parameters; } - Hasher hash_acc(Hasher h) const { - h.acc(name); - h.acc(parameters); + Hasher hash_eat(Hasher h) const { + h.eat(name); + h.eat(parameters); return h; } }; diff --git a/passes/equiv/equiv_struct.cc b/passes/equiv/equiv_struct.cc index 55b364971..774c5a1a6 100644 --- a/passes/equiv/equiv_struct.cc +++ b/passes/equiv/equiv_struct.cc @@ -46,11 +46,11 @@ struct EquivStructWorker parameters == other.parameters && port_sizes == other.port_sizes; } - Hasher hash_acc(Hasher h) const { - h.acc(type); - h.acc(parameters); - h.acc(port_sizes); - h.acc(connections); + Hasher hash_eat(Hasher h) const { + h.eat(type); + h.eat(parameters); + h.eat(port_sizes); + h.eat(connections); return h; } }; diff --git a/passes/proc/proc_dlatch.cc b/passes/proc/proc_dlatch.cc index 5936502c0..6b579b4e4 100644 --- a/passes/proc/proc_dlatch.cc +++ b/passes/proc/proc_dlatch.cc @@ -127,10 +127,10 @@ struct proc_dlatch_db_t return signal == other.signal && match == other.match && children == other.children; } - Hasher hash_acc(Hasher h) const { - h.acc(signal); - h.acc(match); - h.acc(children); + Hasher hash_eat(Hasher h) const { + h.eat(signal); + h.eat(match); + h.eat(children); return h; } }; diff --git a/passes/sat/recover_names.cc b/passes/sat/recover_names.cc index 05ddf8e55..a84380cbf 100644 --- a/passes/sat/recover_names.cc +++ b/passes/sat/recover_names.cc @@ -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; }; - Hasher hash_acc(Hasher h) const + Hasher hash_eat(Hasher h) const { - h.acc(name); - h.acc(bit); + h.eat(name); + h.eat(bit); 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; }; - Hasher hash_acc(Hasher h) const + Hasher hash_eat(Hasher h) const { - h.acc(bit); - h.acc(inverted); + h.eat(bit); + h.eat(inverted); return h; } diff --git a/passes/techmap/clockgate.cc b/passes/techmap/clockgate.cc index 79c1be7c1..bfd4c8a97 100644 --- a/passes/techmap/clockgate.cc +++ b/passes/techmap/clockgate.cc @@ -233,9 +233,9 @@ struct ClockgatePass : public Pass { SigBit ce_bit; bool pol_clk; 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); - h.acc(t); + h.eat(t); return h; } bool operator==(const ClkNetInfo& other) const { diff --git a/passes/techmap/flowmap.cc b/passes/techmap/flowmap.cc index b07097b99..bfee38999 100644 --- a/passes/techmap/flowmap.cc +++ b/passes/techmap/flowmap.cc @@ -250,10 +250,10 @@ struct FlowGraph { return !(*this == other); } - Hasher hash_acc(Hasher h) const + Hasher hash_eat(Hasher h) const { std::pair p = {node, is_bottom}; - h.acc(p); + h.eat(p); return h; } diff --git a/techlibs/quicklogic/ql_dsp_simd.cc b/techlibs/quicklogic/ql_dsp_simd.cc index bcbb290df..162f0c2d6 100644 --- a/techlibs/quicklogic/ql_dsp_simd.cc +++ b/techlibs/quicklogic/ql_dsp_simd.cc @@ -53,7 +53,7 @@ struct QlDspSimdPass : public Pass { DspConfig(const 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; } };