spirv-fuzz: Report fresh ids in transformations (#3856)

Adds a virtual method, GetFreshIds(), to Transformation. Every
transformation uses this to indicate which ids in its protobuf message
are fresh ids. This means that when replaying a sequence of
transformations the replayer can obtain a smallest id that is not in
use by the module already and that will not be used by any
transformation by necessity. Ids greater than or equal to this id
can be used as overflow ids.

Fixes #3851.

source/fuzz/counter_overflow_id_source.cpp

@@ -18,13 +18,19 @@ namespace spvtools {
 namespace fuzz {
 
 CounterOverflowIdSource::CounterOverflowIdSource(uint32_t first_available_id)
-    : next_available_id_(first_available_id) {}
+    : next_available_id_(first_available_id), issued_ids_() {}
 
 bool CounterOverflowIdSource::HasOverflowIds() const { return true; }
 
 uint32_t CounterOverflowIdSource::GetNextOverflowId() {
+  issued_ids_.insert(next_available_id_);
   return next_available_id_++;
 }
 
+const std::unordered_set<uint32_t>&
+CounterOverflowIdSource::GetIssuedOverflowIds() const {
+  return issued_ids_;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/counter_overflow_id_source.h

@@ -35,8 +35,12 @@ class CounterOverflowIdSource : public OverflowIdSource {
   //  account for the case where the maximum allowed id is reached.
   uint32_t GetNextOverflowId() override;
 
+  const std::unordered_set<uint32_t>& GetIssuedOverflowIds() const override;
+
  private:
   uint32_t next_available_id_;
+
+  std::unordered_set<uint32_t> issued_ids_;
 };
 
 }  // namespace fuzz

source/fuzz/overflow_id_source.h

@@ -16,6 +16,7 @@
 #define SOURCE_FUZZ_OVERFLOW_ID_SOURCE_H_
 
 #include <cstdint>
+#include <unordered_set>
 
 namespace spvtools {
 namespace fuzz {
@@ -98,6 +99,10 @@ class OverflowIdSource {
   // Precondition: HasOverflowIds() must hold.  Returns the next available
   // overflow id.
   virtual uint32_t GetNextOverflowId() = 0;
+
+  // Returns the set of overflow ids from this source that have been previously
+  // issued via calls to GetNextOverflowId().
+  virtual const std::unordered_set<uint32_t>& GetIssuedOverflowIds() const = 0;
 };
 
 }  // namespace fuzz

source/fuzz/protobufs/spvtoolsfuzz.proto

@@ -738,11 +738,12 @@ message TransformationAddFunction {
   // Id of an existing global value with the same return type as the function
   // that can be used to replace OpKill and OpReachable instructions with
   // ReturnValue instructions.  Ignored if the function has void return type.
+  // Only relevant if |is_livesafe| holds.
   uint32 kill_unreachable_return_value_id = 6;
 
   // A mapping (represented as a sequence) from every access chain result id in
   // the function to the ids required to clamp its indices to ensure they are in
-  // bounds.
+  // bounds; only relevant if |is_livesafe| holds.
   repeated AccessChainClampingInfo access_chain_clamping_info = 7;
 
 }

source/fuzz/replayer.cpp

@@ -14,6 +14,7 @@
 
 #include "source/fuzz/replayer.h"
 
+#include <algorithm>
 #include <memory>
 #include <utility>
 
@@ -33,15 +34,14 @@ Replayer::Replayer(
     const std::vector<uint32_t>& binary_in,
     const protobufs::FactSequence& initial_facts,
     const protobufs::TransformationSequence& transformation_sequence_in,
-    uint32_t num_transformations_to_apply, uint32_t first_overflow_id,
+    uint32_t num_transformations_to_apply, bool validate_during_replay,
-    bool validate_during_replay, spv_validator_options validator_options)
+    spv_validator_options validator_options)
     : target_env_(target_env),
       consumer_(std::move(consumer)),
       binary_in_(binary_in),
       initial_facts_(initial_facts),
       transformation_sequence_in_(transformation_sequence_in),
       num_transformations_to_apply_(num_transformations_to_apply),
-      first_overflow_id_(first_overflow_id),
       validate_during_replay_(validate_during_replay),
       validator_options_(validator_options) {}
 
@@ -90,13 +90,24 @@ Replayer::ReplayerResult Replayer::Run() {
     last_valid_binary = binary_in_;
   }
 
+  // We find the smallest id that is (a) not in use by the original module, and
+  // (b) not used by any transformation in the sequence to be replayed.  This
+  // serves as a starting id from which to issue overflow ids if they are
+  // required during replay.
+  uint32_t first_overflow_id = ir_context->module()->id_bound();
+  for (auto& transformation : transformation_sequence_in_.transformation()) {
+    auto fresh_ids = Transformation::FromMessage(transformation)->GetFreshIds();
+    if (!fresh_ids.empty()) {
+      first_overflow_id =
+          std::max(first_overflow_id,
+                   *std::max_element(fresh_ids.begin(), fresh_ids.end()));
+    }
+  }
+
   std::unique_ptr<TransformationContext> transformation_context =
-      first_overflow_id_ == 0
+      MakeUnique<TransformationContext>(
-          ? MakeUnique<TransformationContext>(
+          MakeUnique<FactManager>(ir_context.get()), validator_options_,
-                MakeUnique<FactManager>(ir_context.get()), validator_options_)
+          MakeUnique<CounterOverflowIdSource>(first_overflow_id));
-          : MakeUnique<TransformationContext>(
-                MakeUnique<FactManager>(ir_context.get()), validator_options_,
-                MakeUnique<CounterOverflowIdSource>(first_overflow_id_));
   transformation_context->GetFactManager()->AddFacts(consumer_, initial_facts_);
 
   // We track the largest id bound observed, to ensure that it only increases

source/fuzz/replayer.h

@@ -50,8 +50,7 @@ class Replayer {
            const std::vector<uint32_t>& binary_in,
            const protobufs::FactSequence& initial_facts,
            const protobufs::TransformationSequence& transformation_sequence_in,
-           uint32_t num_transformations_to_apply, uint32_t first_overflow_id,
+           uint32_t num_transformations_to_apply, bool validate_during_replay,
-           bool validate_during_replay,
            spv_validator_options validator_options);
 
   // Disables copy/move constructor/assignment operations.
@@ -67,11 +66,6 @@ class Replayer {
   // the input binary and the context in which it will execute are provided via
   // |initial_facts_|.
   //
-  // |first_overflow_id_| should be set to 0 if overflow ids are not available
-  // during replay.  Otherwise |first_overflow_id_| must be larger than any id
-  // referred to in |binary_in_| or |transformation_sequence_in_|, and overflow
-  // ids will be available during replay starting from this value.
-  //
   // On success, returns a successful result status together with the
   // transformations that were applied, the IR for the transformed module, and
   // the transformation context that arises from applying these transformations.
@@ -98,10 +92,6 @@ class Replayer {
   // The number of transformations that should be replayed.
   const uint32_t num_transformations_to_apply_;
 
-  // Zero if overflow ids are not available, otherwise hold the value of the
-  // smallest id that may be used for overflow purposes.
-  const uint32_t first_overflow_id_;
-
   // Controls whether the validator should be run after every replay step.
   const bool validate_during_replay_;
 

source/fuzz/shrinker.cpp

@@ -109,8 +109,7 @@ Shrinker::ShrinkerResult Shrinker::Run() {
                transformation_sequence_in_,
                static_cast<uint32_t>(
                    transformation_sequence_in_.transformation_size()),
-               /* No overflow ids */ 0, validate_during_replay_,
+               validate_during_replay_, validator_options_)
-               validator_options_)
           .Run();
   if (initial_replay_result.status !=
       Replayer::ReplayerResultStatus::kComplete) {
@@ -135,12 +134,6 @@ Shrinker::ShrinkerResult Shrinker::Run() {
             std::vector<uint32_t>(), protobufs::TransformationSequence()};
   }
 
-  // The largest id used by the module before any shrinking has been applied
-  // serves as the first id that can be used for overflow purposes.
-  const uint32_t first_overflow_id = GetIdBound(current_best_binary);
-  assert(first_overflow_id >= GetIdBound(binary_in_) &&
-         "Applying transformations should only increase a module's id bound.");
-
   uint32_t attempt = 0;  // Keeps track of the number of shrink attempts that
                          // have been tried, whether successful or not.
 
@@ -202,7 +195,7 @@ Shrinker::ShrinkerResult Shrinker::Run() {
               transformations_with_chunk_removed,
               static_cast<uint32_t>(
                   transformations_with_chunk_removed.transformation_size()),
-              first_overflow_id, validate_during_replay_, validator_options_)
+              validate_during_replay_, validator_options_)
               .Run();
       if (replay_result.status != Replayer::ReplayerResultStatus::kComplete) {
         // Replay should not fail; if it does, we need to abort shrinking.

source/fuzz/transformation.h

@@ -16,6 +16,7 @@
 #define SOURCE_FUZZ_TRANSFORMATION_H_
 
 #include <memory>
+#include <unordered_set>
 
 #include "source/fuzz/protobufs/spirvfuzz_protobufs.h"
 #include "source/fuzz/transformation_context.h"
@@ -58,6 +59,13 @@ namespace fuzz {
 
 class Transformation {
  public:
+  virtual ~Transformation();
+
+  // Factory method to obtain a transformation object from the protobuf
+  // representation of a transformation given by |message|.
+  static std::unique_ptr<Transformation> FromMessage(
+      const protobufs::Transformation& message);
+
   // A precondition that determines whether the transformation can be cleanly
   // applied in a semantics-preserving manner to the SPIR-V module given by
   // |ir_context|, in the presence of facts and other contextual information
@@ -77,16 +85,13 @@ class Transformation {
   virtual void Apply(opt::IRContext* ir_context,
                      TransformationContext* transformation_context) const = 0;
 
+  // Returns the set of fresh ids that appear in the transformation's protobuf
+  // message.
+  virtual std::unordered_set<uint32_t> GetFreshIds() const = 0;
+
   // Turns the transformation into a protobuf message for serialization.
   virtual protobufs::Transformation ToMessage() const = 0;
 
-  virtual ~Transformation();
-
-  // Factory method to obtain a transformation object from the protobuf
-  // representation of a transformation given by |message|.
-  static std::unique_ptr<Transformation> FromMessage(
-      const protobufs::Transformation& message);
-
   // Helper that returns true if and only if (a) |id| is a fresh id for the
   // module, and (b) |id| is not in |ids_used_by_this_transformation|, a set of
   // ids already known to be in use by a transformation.  This is useful when

source/fuzz/transformation_access_chain.cpp

@@ -407,5 +407,14 @@ bool TransformationAccessChain::ValidIndexToComposite(
   return true;
 }
 
+std::unordered_set<uint32_t> TransformationAccessChain::GetFreshIds() const {
+  std::unordered_set<uint32_t> result = {message_.fresh_id()};
+  for (auto& fresh_ids_for_clamping : message_.fresh_ids_for_clamping()) {
+    result.insert(fresh_ids_for_clamping.first());
+    result.insert(fresh_ids_for_clamping.second());
+  }
+  return result;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_access_chain.h

@@ -76,6 +76,8 @@ class TransformationAccessChain : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_bit_instruction_synonym.cpp

@@ -230,5 +230,14 @@ void TransformationAddBitInstructionSynonym::AddOpBitwiseOrOpNotSynonym(
       MakeDataDescriptor(bit_instruction->result_id(), {}));
 }
 
+std::unordered_set<uint32_t>
+TransformationAddBitInstructionSynonym::GetFreshIds() const {
+  std::unordered_set<uint32_t> result;
+  for (auto id : message_.fresh_ids()) {
+    result.insert(id);
+  }
+  return result;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_bit_instruction_synonym.h

@@ -120,6 +120,8 @@ class TransformationAddBitInstructionSynonym : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns the number of fresh ids required to apply the transformation.

source/fuzz/transformation_add_constant_boolean.cpp

@@ -63,5 +63,10 @@ protobufs::Transformation TransformationAddConstantBoolean::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddConstantBoolean::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_constant_boolean.h

@@ -44,6 +44,8 @@ class TransformationAddConstantBoolean : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_constant_composite.cpp

@@ -133,5 +133,10 @@ protobufs::Transformation TransformationAddConstantComposite::ToMessage()
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddConstantComposite::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_constant_composite.h

@@ -50,6 +50,8 @@ class TransformationAddConstantComposite : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_constant_null.cpp

@@ -62,5 +62,10 @@ protobufs::Transformation TransformationAddConstantNull::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddConstantNull::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_constant_null.h

@@ -42,6 +42,8 @@ class TransformationAddConstantNull : public Transformation {
   void Apply(opt::IRContext* context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_constant_scalar.cpp

@@ -90,5 +90,10 @@ protobufs::Transformation TransformationAddConstantScalar::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddConstantScalar::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_constant_scalar.h

@@ -47,6 +47,8 @@ class TransformationAddConstantScalar : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_copy_memory.cpp

@@ -189,5 +189,9 @@ bool TransformationAddCopyMemory::CanUsePointeeWithCopyMemory(
   }
 }
 
+std::unordered_set<uint32_t> TransformationAddCopyMemory::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_copy_memory.h

@@ -54,6 +54,8 @@ class TransformationAddCopyMemory : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if we can copy memory from |instruction| using OpCopyMemory.

source/fuzz/transformation_add_dead_block.cpp

@@ -189,5 +189,9 @@ protobufs::Transformation TransformationAddDeadBlock::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddDeadBlock::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_dead_block.h

@@ -53,6 +53,8 @@ class TransformationAddDeadBlock : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_dead_break.cpp

@@ -211,5 +211,9 @@ void TransformationAddDeadBreak::ApplyImpl(
       message_.phi_id());
 }
 
+std::unordered_set<uint32_t> TransformationAddDeadBreak::GetFreshIds() const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_dead_break.h

@@ -61,6 +61,8 @@ class TransformationAddDeadBreak : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_dead_continue.cpp

@@ -158,5 +158,10 @@ void TransformationAddDeadContinue::ApplyImpl(
       message_.phi_id());
 }
 
+std::unordered_set<uint32_t> TransformationAddDeadContinue::GetFreshIds()
+    const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_dead_continue.h

@@ -63,6 +63,8 @@ class TransformationAddDeadContinue : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_function.cpp

@@ -927,5 +927,29 @@ opt::Instruction* TransformationAddFunction::FollowCompositeIndex(
   return ir_context->get_def_use_mgr()->GetDef(sub_object_type_id);
 }
 
+std::unordered_set<uint32_t> TransformationAddFunction::GetFreshIds() const {
+  std::unordered_set<uint32_t> result;
+  for (auto& instruction : message_.instruction()) {
+    result.insert(instruction.result_id());
+  }
+  if (message_.is_livesafe()) {
+    result.insert(message_.loop_limiter_variable_id());
+    for (auto& loop_limiter_info : message_.loop_limiter_info()) {
+      result.insert(loop_limiter_info.load_id());
+      result.insert(loop_limiter_info.increment_id());
+      result.insert(loop_limiter_info.compare_id());
+      result.insert(loop_limiter_info.logical_op_id());
+    }
+    for (auto& access_chain_clamping_info :
+         message_.access_chain_clamping_info()) {
+      for (auto& pair : access_chain_clamping_info.compare_and_select_ids()) {
+        result.insert(pair.first());
+        result.insert(pair.second());
+      }
+    }
+  }
+  return result;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_function.h

@@ -56,6 +56,8 @@ class TransformationAddFunction : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Helper method that, given composite type |composite_type_inst|, returns the

source/fuzz/transformation_add_global_undef.cpp

@@ -58,5 +58,9 @@ protobufs::Transformation TransformationAddGlobalUndef::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddGlobalUndef::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_global_undef.h

@@ -41,6 +41,8 @@ class TransformationAddGlobalUndef : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_global_variable.cpp

@@ -115,5 +115,10 @@ protobufs::Transformation TransformationAddGlobalVariable::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddGlobalVariable::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_global_variable.h

@@ -55,6 +55,8 @@ class TransformationAddGlobalVariable : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_image_sample_unused_components.cpp

@@ -113,5 +113,10 @@ TransformationAddImageSampleUnusedComponents::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t>
+TransformationAddImageSampleUnusedComponents::GetFreshIds() const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_image_sample_unused_components.h

@@ -45,6 +45,8 @@ class TransformationAddImageSampleUnusedComponents : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_local_variable.cpp

@@ -88,5 +88,10 @@ protobufs::Transformation TransformationAddLocalVariable::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddLocalVariable::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_local_variable.h

@@ -50,6 +50,8 @@ class TransformationAddLocalVariable : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_loop_preheader.cpp

@@ -221,5 +221,14 @@ protobufs::Transformation TransformationAddLoopPreheader::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddLoopPreheader::GetFreshIds()
+    const {
+  std::unordered_set<uint32_t> result = {message_.fresh_id()};
+  for (auto id : message_.phi_id()) {
+    result.insert(id);
+  }
+  return result;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_loop_preheader.h

@@ -45,6 +45,8 @@ class TransformationAddLoopPreheader : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_loop_to_create_int_constant_synonym.cpp

@@ -423,5 +423,13 @@ TransformationAddLoopToCreateIntConstantSynonym::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t>
+TransformationAddLoopToCreateIntConstantSynonym::GetFreshIds() const {
+  return {message_.syn_id(),          message_.loop_id(),
+          message_.ctr_id(),          message_.temp_id(),
+          message_.eventual_syn_id(), message_.incremented_ctr_id(),
+          message_.cond_id(),         message_.additional_block_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_loop_to_create_int_constant_synonym.h

@@ -57,6 +57,8 @@ class TransformationAddLoopToCreateIntConstantSynonym : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_no_contraction_decoration.cpp

@@ -105,5 +105,10 @@ bool TransformationAddNoContractionDecoration::IsArithmetic(uint32_t opcode) {
   }
 }
 
+std::unordered_set<uint32_t>
+TransformationAddNoContractionDecoration::GetFreshIds() const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_no_contraction_decoration.h

@@ -44,6 +44,8 @@ class TransformationAddNoContractionDecoration : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if and only if |opcode| is the opcode of an arithmetic

source/fuzz/transformation_add_opphi_synonym.cpp

@@ -193,5 +193,10 @@ bool TransformationAddOpPhiSynonym::CheckTypeIsAllowed(
   return false;
 }
 
+std::unordered_set<uint32_t> TransformationAddOpPhiSynonym::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_opphi_synonym.h

@@ -61,6 +61,8 @@ class TransformationAddOpPhiSynonym : public Transformation {
   // enabled and the storage class is Workgroup or StorageBuffer.
   static bool CheckTypeIsAllowed(opt::IRContext* ir_context, uint32_t type_id);
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_parameter.cpp

@@ -211,5 +211,9 @@ bool TransformationAddParameter::IsParameterTypeSupported(
   }
 }
 
+std::unordered_set<uint32_t> TransformationAddParameter::GetFreshIds() const {
+  return {message_.parameter_fresh_id(), message_.function_type_fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_parameter.h

@@ -56,6 +56,8 @@ class TransformationAddParameter : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if the type of the parameter is supported by this

source/fuzz/transformation_add_relaxed_decoration.cpp

@@ -142,5 +142,10 @@ bool TransformationAddRelaxedDecoration::IsNumeric(uint32_t opcode) {
   }
 }
 
+std::unordered_set<uint32_t> TransformationAddRelaxedDecoration::GetFreshIds()
+    const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_relaxed_decoration.h

@@ -45,6 +45,8 @@ class TransformationAddRelaxedDecoration : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if and only if |opcode| is the opcode of an instruction

source/fuzz/transformation_add_spec_constant_op.cpp

@@ -81,5 +81,10 @@ protobufs::Transformation TransformationAddSpecConstantOp::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddSpecConstantOp::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_spec_constant_op.h

@@ -46,6 +46,8 @@ class TransformationAddSpecConstantOp : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_synonym.cpp

@@ -320,5 +320,9 @@ bool TransformationAddSynonym::IsAdditionalConstantRequired(
   }
 }
 
+std::unordered_set<uint32_t> TransformationAddSynonym::GetFreshIds() const {
+  return {message_.synonym_fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_synonym.h

@@ -53,6 +53,8 @@ class TransformationAddSynonym : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if we can create a synonym of |inst| according to the

source/fuzz/transformation_add_type_array.cpp

@@ -84,5 +84,9 @@ protobufs::Transformation TransformationAddTypeArray::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeArray::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_array.h

@@ -45,6 +45,8 @@ class TransformationAddTypeArray : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_boolean.cpp

@@ -57,5 +57,9 @@ protobufs::Transformation TransformationAddTypeBoolean::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeBoolean::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_boolean.h

@@ -39,6 +39,8 @@ class TransformationAddTypeBoolean : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_float.cpp

@@ -78,5 +78,9 @@ protobufs::Transformation TransformationAddTypeFloat::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeFloat::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_float.h

@@ -41,6 +41,8 @@ class TransformationAddTypeFloat : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_function.cpp

@@ -80,5 +80,10 @@ protobufs::Transformation TransformationAddTypeFunction::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeFunction::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_function.h

@@ -49,6 +49,8 @@ class TransformationAddTypeFunction : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_int.cpp

@@ -88,5 +88,9 @@ protobufs::Transformation TransformationAddTypeInt::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeInt::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_int.h

@@ -42,6 +42,8 @@ class TransformationAddTypeInt : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_matrix.cpp

@@ -67,5 +67,9 @@ protobufs::Transformation TransformationAddTypeMatrix::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeMatrix::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_matrix.h

@@ -43,6 +43,8 @@ class TransformationAddTypeMatrix : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_pointer.cpp

@@ -62,5 +62,9 @@ protobufs::Transformation TransformationAddTypePointer::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypePointer::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_pointer.h

@@ -43,6 +43,8 @@ class TransformationAddTypePointer : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_struct.cpp

@@ -74,5 +74,9 @@ protobufs::Transformation TransformationAddTypeStruct::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeStruct::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_struct.h

@@ -47,6 +47,8 @@ class TransformationAddTypeStruct : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_add_type_vector.cpp

@@ -61,5 +61,9 @@ protobufs::Transformation TransformationAddTypeVector::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAddTypeVector::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_add_type_vector.h

@@ -43,6 +43,8 @@ class TransformationAddTypeVector : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_adjust_branch_weights.cpp

@@ -93,5 +93,10 @@ protobufs::Transformation TransformationAdjustBranchWeights::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationAdjustBranchWeights::GetFreshIds()
+    const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_adjust_branch_weights.h

@@ -45,6 +45,8 @@ class TransformationAdjustBranchWeights : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_composite_construct.cpp

@@ -310,5 +310,10 @@ protobufs::Transformation TransformationCompositeConstruct::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationCompositeConstruct::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_composite_construct.h

@@ -61,6 +61,8 @@ class TransformationCompositeConstruct : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_composite_extract.cpp

@@ -135,5 +135,10 @@ protobufs::Transformation TransformationCompositeExtract::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationCompositeExtract::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_composite_extract.h

@@ -54,6 +54,8 @@ class TransformationCompositeExtract : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_composite_insert.cpp

@@ -220,5 +220,10 @@ bool TransformationCompositeInsert::IsCompositeInstructionSupported(
   return true;
 }
 
+std::unordered_set<uint32_t> TransformationCompositeInsert::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_composite_insert.h

@@ -55,6 +55,8 @@ class TransformationCompositeInsert : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Checks if |instruction| is a instruction of a composite type supported by

source/fuzz/transformation_compute_data_synonym_fact_closure.cpp

@@ -48,5 +48,10 @@ TransformationComputeDataSynonymFactClosure::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t>
+TransformationComputeDataSynonymFactClosure::GetFreshIds() const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_compute_data_synonym_fact_closure.h

@@ -41,6 +41,8 @@ class TransformationComputeDataSynonymFactClosure : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_context.cpp

@@ -35,6 +35,14 @@ class NullOverflowIdSource : public OverflowIdSource {
     assert(false && "Bad attempt to request an overflow id.");
     return 0;
   }
+
+  const std::unordered_set<uint32_t>& GetIssuedOverflowIds() const override {
+    assert(false && "Operation not supported.");
+    return placeholder_;
+  }
+
+ private:
+  std::unordered_set<uint32_t> placeholder_;
 };
 
 }  // namespace

source/fuzz/transformation_duplicate_region_with_selection.cpp

@@ -600,5 +600,21 @@ TransformationDuplicateRegionWithSelection::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t>
+TransformationDuplicateRegionWithSelection::GetFreshIds() const {
+  std::unordered_set<uint32_t> result = {message_.new_entry_fresh_id(),
+                                         message_.merge_label_fresh_id()};
+  for (auto& pair : message_.original_label_to_duplicate_label()) {
+    result.insert(pair.second());
+  }
+  for (auto& pair : message_.original_id_to_duplicate_id()) {
+    result.insert(pair.second());
+  }
+  for (auto& pair : message_.original_id_to_phi_id()) {
+    result.insert(pair.second());
+  }
+  return result;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_duplicate_region_with_selection.h

@@ -66,6 +66,8 @@ class TransformationDuplicateRegionWithSelection : public Transformation {
       opt::IRContext* ir_context, opt::BasicBlock* entry_block,
       opt::BasicBlock* exit_block);
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_equation_instruction.cpp

@@ -282,5 +282,10 @@ uint32_t TransformationEquationInstruction::MaybeGetResultTypeId(
   }
 }
 
+std::unordered_set<uint32_t> TransformationEquationInstruction::GetFreshIds()
+    const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_equation_instruction.h

@@ -60,6 +60,8 @@ class TransformationEquationInstruction : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_flatten_conditional_branch.cpp

@@ -699,5 +699,18 @@ bool TransformationFlattenConditionalBranch::InstructionCanBeHandled(
   return true;
 }
 
+std::unordered_set<uint32_t>
+TransformationFlattenConditionalBranch::GetFreshIds() const {
+  std::unordered_set<uint32_t> result;
+  for (auto& side_effect_wrapper_info : message_.side_effect_wrapper_info()) {
+    result.insert(side_effect_wrapper_info.merge_block_id());
+    result.insert(side_effect_wrapper_info.execute_block_id());
+    result.insert(side_effect_wrapper_info.actual_result_id());
+    result.insert(side_effect_wrapper_info.alternative_block_id());
+    result.insert(side_effect_wrapper_info.placeholder_result_id());
+  }
+  return result;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_flatten_conditional_branch.h

@@ -53,6 +53,8 @@ class TransformationFlattenConditionalBranch : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if the conditional headed by |header| can be flattened,

source/fuzz/transformation_function_call.cpp

@@ -185,5 +185,9 @@ protobufs::Transformation TransformationFunctionCall::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationFunctionCall::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_function_call.h

@@ -55,6 +55,8 @@ class TransformationFunctionCall : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_inline_function.cpp

@@ -292,5 +292,13 @@ void TransformationInlineFunction::AdaptInlinedInstruction(
   }
 }
 
+std::unordered_set<uint32_t> TransformationInlineFunction::GetFreshIds() const {
+  std::unordered_set<uint32_t> result;
+  for (auto& pair : message_.result_id_map()) {
+    result.insert(pair.second());
+  }
+  return result;
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_inline_function.h

@@ -52,6 +52,8 @@ class TransformationInlineFunction : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if |function_call_instruction| is defined, is an

source/fuzz/transformation_invert_comparison_operator.cpp

@@ -174,5 +174,10 @@ protobufs::Transformation TransformationInvertComparisonOperator::ToMessage()
   return result;
 }
 
+std::unordered_set<uint32_t>
+TransformationInvertComparisonOperator::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_invert_comparison_operator.h

@@ -45,6 +45,8 @@ class TransformationInvertComparisonOperator : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Returns true if |opcode| is supported by this transformation.

source/fuzz/transformation_load.cpp

@@ -98,5 +98,9 @@ protobufs::Transformation TransformationLoad::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationLoad::GetFreshIds() const {
+  return {message_.fresh_id()};
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_load.h

@@ -49,6 +49,8 @@ class TransformationLoad : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
  private:

source/fuzz/transformation_make_vector_operation_dynamic.cpp

@@ -107,5 +107,10 @@ bool TransformationMakeVectorOperationDynamic::IsVectorOperation(
   return true;
 }
 
+std::unordered_set<uint32_t>
+TransformationMakeVectorOperationDynamic::GetFreshIds() const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools

source/fuzz/transformation_make_vector_operation_dynamic.h

@@ -46,6 +46,8 @@ class TransformationMakeVectorOperationDynamic : public Transformation {
   void Apply(opt::IRContext* ir_context,
              TransformationContext* transformation_context) const override;
 
+  std::unordered_set<uint32_t> GetFreshIds() const override;
+
   protobufs::Transformation ToMessage() const override;
 
   // Checks |instruction| is defined, is an OpCompositeExtract/Insert

source/fuzz/transformation_merge_blocks.cpp

@@ -78,5 +78,9 @@ protobufs::Transformation TransformationMergeBlocks::ToMessage() const {
   return result;
 }
 
+std::unordered_set<uint32_t> TransformationMergeBlocks::GetFreshIds() const {
+  return std::unordered_set<uint32_t>();
+}
+
 }  // namespace fuzz
 }  // namespace spvtools