Revert "operand: Implement operand hashing and use hashed set for declarations"

This reverts commit 1e665afa36.

include/sirit/sirit.h

@@ -945,8 +945,7 @@ private:
     std::vector<std::unique_ptr<Op>> execution_modes;
     std::vector<std::unique_ptr<Op>> debug;
     std::vector<std::unique_ptr<Op>> annotations;
-    std::unordered_set<std::unique_ptr<Op>> declarations;
+    std::vector<std::unique_ptr<Op>> declarations;
-    std::vector<Id> sorted_declarations;
 
     std::vector<Id> global_variables;
 

src/literal_number.cpp

@@ -35,8 +35,4 @@ bool LiteralNumber::operator==(const Operand& other) const {
     return false;
 }
 
-std::size_t LiteralNumber::Hash() const {
-    return static_cast<std::size_t>(raw) ^ Operand::Hash();
-}
-
 } // namespace Sirit

src/literal_number.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstring>
 #include <typeindex>
 #include "operand.h"
@@ -24,8 +23,6 @@ public:
 
     bool operator==(const Operand& other) const override;
 
-    std::size_t Hash() const override;
-
     template <typename T>
     static LiteralNumber* Create(T value) {
         static_assert(sizeof(T) == 4 || sizeof(T) == 8);

src/literal_string.cpp

@@ -4,7 +4,6 @@
  * 3-Clause BSD License
  */
 
-#include <functional>
 #include <string>
 #include "common_types.h"
 #include "literal_string.h"
@@ -37,8 +36,4 @@ bool LiteralString::operator==(const Operand& other) const {
     return false;
 }
 
-std::size_t LiteralString::Hash() const {
-    return Operand::Hash() ^ std::hash<std::string>{}(string);
-}
-
 } // namespace Sirit

src/literal_string.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <cstddef>
 #include <string>
 #include "operand.h"
 #include "stream.h"
@@ -23,10 +22,8 @@ public:
 
     bool operator==(const Operand& other) const override;
 
-    std::size_t Hash() const override;
-
 private:
-    std::string string;
+    const std::string string;
 };
 
 } // namespace Sirit

src/op.cpp

@@ -5,7 +5,6 @@
  */
 
 #include <cassert>
-#include <climits>
 
 #include "common_types.h"
 #include "literal_number.h"
@@ -48,21 +47,6 @@ bool Op::operator==(const Operand& other) const {
     return false;
 }
 
-std::size_t Op::Hash() const {
-    std::size_t hash = Operand::Hash();
-    hash ^= static_cast<std::size_t>(opcode) << 20;
-    if (result_type) {
-        hash ^= result_type->Hash() << 16;
-    }
-    hash ^= static_cast<std::size_t>(id.value_or(0)) << 8;
-    std::size_t wrap = 32;
-    for (const auto operand : operands) {
-        wrap = (wrap + 7) % (sizeof(std::size_t) * CHAR_BIT);
-        hash ^= operand->Hash() << wrap;
-    }
-    return hash;
-}
-
 void Op::Write(Stream& stream) const {
     stream.Write(static_cast<u16>(opcode));
     stream.Write(WordCount());

src/op.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <cstddef>
 #include <optional>
 #include "common_types.h"
 #include "operand.h"
@@ -25,8 +24,6 @@ public:
 
     bool operator==(const Operand& other) const override;
 
-    std::size_t Hash() const override;
-
     void Write(Stream& stream) const;
 
     void Sink(Operand* operand);

src/operand.cpp

@@ -30,10 +30,6 @@ bool Operand::operator!=(const Operand& other) const {
     return !(*this == other);
 }
 
-std::size_t Operand::Hash() const {
-    return static_cast<std::size_t>(operand_type) << 30;
-}
-
 OperandType Operand::GetType() const {
     return operand_type;
 }

src/operand.h

@@ -6,8 +6,6 @@
 
 #pragma once
 
-#include <cstddef>
-#include "common_types.h"
 #include "stream.h"
 
 namespace Sirit {
@@ -25,8 +23,6 @@ public:
     virtual bool operator==(const Operand& other) const;
     bool operator!=(const Operand& other) const;
 
-    virtual std::size_t Hash() const;
-
     OperandType GetType() const;
 
 protected:
@@ -34,14 +30,3 @@ protected:
 };
 
 } // namespace Sirit
-
-namespace std {
-
-template <>
-struct hash<Sirit::Operand> {
-    std::size_t operator()(const Sirit::Operand& operand) const noexcept {
-        return operand.Hash();
-    }
-};
-
-} // namespace std

src/sirit.cpp

@@ -59,7 +59,7 @@ std::vector<u8> Module::Assemble() const {
     WriteSet(stream, execution_modes);
     WriteSet(stream, debug);
     WriteSet(stream, annotations);
-    WriteSet(stream, sorted_declarations);
+    WriteSet(stream, declarations);
     WriteSet(stream, global_variables);
     WriteSet(stream, code);
 
@@ -74,14 +74,13 @@ void Module::AddCapability(spv::Capability capability) {
     capabilities.insert(capability);
 }
 
-void Module::SetMemoryModel(spv::AddressingModel addressing_model_,
+void Module::SetMemoryModel(spv::AddressingModel addressing_model_, spv::MemoryModel memory_model_) {
-                            spv::MemoryModel memory_model_) {
     this->addressing_model = addressing_model_;
     this->memory_model = memory_model_;
 }
 
-void Module::AddEntryPoint(spv::ExecutionModel execution_model, Id entry_point, std::string name,
+void Module::AddEntryPoint(spv::ExecutionModel execution_model, Id entry_point,
-                           const std::vector<Id>& interfaces) {
+                           std::string name, const std::vector<Id>& interfaces) {
     auto op{std::make_unique<Op>(spv::Op::OpEntryPoint)};
     op->Add(static_cast<u32>(execution_model));
     op->Add(entry_point);
@@ -122,12 +121,14 @@ Id Module::AddCode(spv::Op opcode, std::optional<u32> id) {
 }
 
 Id Module::AddDeclaration(std::unique_ptr<Op> op) {
-    const auto [it, is_inserted] = declarations.emplace(std::move(op));
+    const auto& found{std::find_if(declarations.begin(), declarations.end(),
-    const Id id = it->get();
+                                   [&op](const auto& other) { return *other == *op; })};
-    if (is_inserted) {
+    if (found != declarations.end()) {
-        sorted_declarations.push_back(id);
+        return found->get();
-        ++bound;
     }
+    const auto id = op.get();
+    declarations.push_back(std::move(op));
+    bound++;
     return id;
 }