diff --git a/source/fuzz/CMakeLists.txt b/source/fuzz/CMakeLists.txt
index a0e7ed8..63a6625 100644
--- a/source/fuzz/CMakeLists.txt
+++ b/source/fuzz/CMakeLists.txt
@@ -86,6 +86,7 @@
         fuzzer_pass_copy_objects.h
         fuzzer_pass_donate_modules.h
         fuzzer_pass_duplicate_regions_with_selections.h
+        fuzzer_pass_expand_vector_reductions.h
         fuzzer_pass_flatten_conditional_branches.h
         fuzzer_pass_inline_functions.h
         fuzzer_pass_invert_comparison_operators.h
@@ -179,6 +180,7 @@
         transformation_context.h
         transformation_duplicate_region_with_selection.h
         transformation_equation_instruction.h
+        transformation_expand_vector_reduction.h
         transformation_flatten_conditional_branch.h
         transformation_function_call.h
         transformation_inline_function.h
@@ -274,6 +276,7 @@
         fuzzer_pass_copy_objects.cpp
         fuzzer_pass_donate_modules.cpp
         fuzzer_pass_duplicate_regions_with_selections.cpp
+        fuzzer_pass_expand_vector_reductions.cpp
         fuzzer_pass_flatten_conditional_branches.cpp
         fuzzer_pass_inline_functions.cpp
         fuzzer_pass_invert_comparison_operators.cpp
@@ -365,6 +368,7 @@
         transformation_context.cpp
         transformation_duplicate_region_with_selection.cpp
         transformation_equation_instruction.cpp
+        transformation_expand_vector_reduction.cpp
         transformation_flatten_conditional_branch.cpp
         transformation_function_call.cpp
         transformation_inline_function.cpp
diff --git a/source/fuzz/fuzzer.cpp b/source/fuzz/fuzzer.cpp
index f326656..4361283 100644
--- a/source/fuzz/fuzzer.cpp
+++ b/source/fuzz/fuzzer.cpp
@@ -55,6 +55,7 @@
 #include "source/fuzz/fuzzer_pass_copy_objects.h"
 #include "source/fuzz/fuzzer_pass_donate_modules.h"
 #include "source/fuzz/fuzzer_pass_duplicate_regions_with_selections.h"
+#include "source/fuzz/fuzzer_pass_expand_vector_reductions.h"
 #include "source/fuzz/fuzzer_pass_flatten_conditional_branches.h"
 #include "source/fuzz/fuzzer_pass_inline_functions.h"
 #include "source/fuzz/fuzzer_pass_interchange_signedness_of_integer_operands.h"
@@ -259,6 +260,7 @@
                                                   donor_suppliers_);
     MaybeAddRepeatedPass<FuzzerPassDuplicateRegionsWithSelections>(
         &pass_instances);
+    MaybeAddRepeatedPass<FuzzerPassExpandVectorReductions>(&pass_instances);
     MaybeAddRepeatedPass<FuzzerPassFlattenConditionalBranches>(&pass_instances);
     MaybeAddRepeatedPass<FuzzerPassInlineFunctions>(&pass_instances);
     MaybeAddRepeatedPass<FuzzerPassInvertComparisonOperators>(&pass_instances);
diff --git a/source/fuzz/fuzzer_context.cpp b/source/fuzz/fuzzer_context.cpp
index 3a27d6f..65904dc 100644
--- a/source/fuzz/fuzzer_context.cpp
+++ b/source/fuzz/fuzzer_context.cpp
@@ -81,6 +81,8 @@
 const std::pair<uint32_t, uint32_t> kChanceOfDonatingAdditionalModule = {5, 50};
 const std::pair<uint32_t, uint32_t> kChanceOfDuplicatingRegionWithSelection = {
     20, 50};
+const std::pair<uint32_t, uint32_t> kChanceOfExpandingVectorReduction = {20,
+                                                                         90};
 const std::pair<uint32_t, uint32_t> kChanceOfFlatteningConditionalBranch = {45,
                                                                             95};
 const std::pair<uint32_t, uint32_t> kChanceOfGoingDeeperToExtractComposite = {
@@ -266,6 +268,8 @@
       ChooseBetweenMinAndMax(kChanceOfDonatingAdditionalModule);
   chance_of_duplicating_region_with_selection_ =
       ChooseBetweenMinAndMax(kChanceOfDuplicatingRegionWithSelection);
+  chance_of_expanding_vector_reduction_ =
+      ChooseBetweenMinAndMax(kChanceOfExpandingVectorReduction);
   chance_of_flattening_conditional_branch_ =
       ChooseBetweenMinAndMax(kChanceOfFlatteningConditionalBranch);
   chance_of_going_deeper_to_extract_composite_ =
diff --git a/source/fuzz/fuzzer_context.h b/source/fuzz/fuzzer_context.h
index b230af3..9193dfc 100644
--- a/source/fuzz/fuzzer_context.h
+++ b/source/fuzz/fuzzer_context.h
@@ -216,6 +216,9 @@
   uint32_t GetChanceOfDuplicatingRegionWithSelection() {
     return chance_of_duplicating_region_with_selection_;
   }
+  uint32_t GetChanceOfExpandingVectorReduction() {
+    return chance_of_expanding_vector_reduction_;
+  }
   uint32_t GetChanceOfFlatteningConditionalBranch() {
     return chance_of_flattening_conditional_branch_;
   }
@@ -461,6 +464,7 @@
   uint32_t chance_of_creating_int_synonyms_using_loops_;
   uint32_t chance_of_donating_additional_module_;
   uint32_t chance_of_duplicating_region_with_selection_;
+  uint32_t chance_of_expanding_vector_reduction_;
   uint32_t chance_of_flattening_conditional_branch_;
   uint32_t chance_of_going_deeper_to_extract_composite_;
   uint32_t chance_of_going_deeper_to_insert_in_composite_;
diff --git a/source/fuzz/fuzzer_pass_expand_vector_reductions.cpp b/source/fuzz/fuzzer_pass_expand_vector_reductions.cpp
new file mode 100644
index 0000000..1416fe0
--- /dev/null
+++ b/source/fuzz/fuzzer_pass_expand_vector_reductions.cpp
@@ -0,0 +1,67 @@
+// Copyright (c) 2020 André Perez Maselco
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "source/fuzz/fuzzer_pass_expand_vector_reductions.h"
+
+#include "source/fuzz/fuzzer_util.h"
+#include "source/fuzz/instruction_descriptor.h"
+#include "source/fuzz/transformation_expand_vector_reduction.h"
+
+namespace spvtools {
+namespace fuzz {
+
+FuzzerPassExpandVectorReductions::FuzzerPassExpandVectorReductions(
+    opt::IRContext* ir_context, TransformationContext* transformation_context,
+    FuzzerContext* fuzzer_context,
+    protobufs::TransformationSequence* transformations)
+    : FuzzerPass(ir_context, transformation_context, fuzzer_context,
+                 transformations) {}
+
+FuzzerPassExpandVectorReductions::~FuzzerPassExpandVectorReductions() = default;
+
+void FuzzerPassExpandVectorReductions::Apply() {
+  for (auto& function : *GetIRContext()->module()) {
+    for (auto& block : function) {
+      for (auto& instruction : block) {
+        // Randomly decides whether the transformation will be applied.
+        if (!GetFuzzerContext()->ChoosePercentage(
+                GetFuzzerContext()->GetChanceOfExpandingVectorReduction())) {
+          continue;
+        }
+
+        // |instruction| must be OpAny or OpAll.
+        if (instruction.opcode() != SpvOpAny &&
+            instruction.opcode() != SpvOpAll) {
+          continue;
+        }
+
+        // It must be able to make a synonym of |instruction|.
+        if (!fuzzerutil::CanMakeSynonymOf(
+                GetIRContext(), *GetTransformationContext(), &instruction)) {
+          continue;
+        }
+
+        // Applies the expand vector reduction transformation.
+        ApplyTransformation(TransformationExpandVectorReduction(
+            instruction.result_id(),
+            GetFuzzerContext()->GetFreshIds(
+                TransformationExpandVectorReduction::GetRequiredFreshIdCount(
+                    GetIRContext(), &instruction))));
+      }
+    }
+  }
+}
+
+}  // namespace fuzz
+}  // namespace spvtools
diff --git a/source/fuzz/fuzzer_pass_expand_vector_reductions.h b/source/fuzz/fuzzer_pass_expand_vector_reductions.h
new file mode 100644
index 0000000..ae3238b
--- /dev/null
+++ b/source/fuzz/fuzzer_pass_expand_vector_reductions.h
@@ -0,0 +1,41 @@
+// Copyright (c) 2020 André Perez Maselco
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SOURCE_FUZZ_FUZZER_PASS_EXPAND_VECTOR_REDUCTIONS_H_
+#define SOURCE_FUZZ_FUZZER_PASS_EXPAND_VECTOR_REDUCTIONS_H_
+
+#include "source/fuzz/fuzzer_pass.h"
+
+namespace spvtools {
+namespace fuzz {
+
+// This fuzzer pass adds synonyms for the OpAny and OpAll instructions. It
+// iterates over the module, checks if there are any OpAny or OpAll applicable
+// instructions and randomly applies the expand vector reduction transformation.
+class FuzzerPassExpandVectorReductions : public FuzzerPass {
+ public:
+  FuzzerPassExpandVectorReductions(
+      opt::IRContext* ir_context, TransformationContext* transformation_context,
+      FuzzerContext* fuzzer_context,
+      protobufs::TransformationSequence* transformations);
+
+  ~FuzzerPassExpandVectorReductions();
+
+  void Apply() override;
+};
+
+}  // namespace fuzz
+}  // namespace spvtools
+
+#endif  // SOURCE_FUZZ_FUZZER_PASS_EXPAND_VECTOR_REDUCTIONS_H_
diff --git a/source/fuzz/pass_management/repeated_pass_instances.h b/source/fuzz/pass_management/repeated_pass_instances.h
index 5f479fb..80ac087 100644
--- a/source/fuzz/pass_management/repeated_pass_instances.h
+++ b/source/fuzz/pass_management/repeated_pass_instances.h
@@ -43,6 +43,7 @@
 #include "source/fuzz/fuzzer_pass_copy_objects.h"
 #include "source/fuzz/fuzzer_pass_donate_modules.h"
 #include "source/fuzz/fuzzer_pass_duplicate_regions_with_selections.h"
+#include "source/fuzz/fuzzer_pass_expand_vector_reductions.h"
 #include "source/fuzz/fuzzer_pass_flatten_conditional_branches.h"
 #include "source/fuzz/fuzzer_pass_inline_functions.h"
 #include "source/fuzz/fuzzer_pass_invert_comparison_operators.h"
@@ -137,6 +138,7 @@
   REPEATED_PASS_INSTANCE(CopyObjects);
   REPEATED_PASS_INSTANCE(DonateModules);
   REPEATED_PASS_INSTANCE(DuplicateRegionsWithSelections);
+  REPEATED_PASS_INSTANCE(ExpandVectorReductions);
   REPEATED_PASS_INSTANCE(FlattenConditionalBranches);
   REPEATED_PASS_INSTANCE(InlineFunctions);
   REPEATED_PASS_INSTANCE(InvertComparisonOperators);
diff --git a/source/fuzz/pass_management/repeated_pass_recommender_standard.cpp b/source/fuzz/pass_management/repeated_pass_recommender_standard.cpp
index 7121c33..a933848 100644
--- a/source/fuzz/pass_management/repeated_pass_recommender_standard.cpp
+++ b/source/fuzz/pass_management/repeated_pass_recommender_standard.cpp
@@ -206,6 +206,10 @@
     // - Parts of duplicated regions can be outlined
     return RandomOrderAndNonNull({pass_instances_->GetOutlineFunctions()});
   }
+  if (&pass == pass_instances_->GetExpandVectorReductions()) {
+    // - Adding OpAny and OpAll synonyms creates opportunities to apply synonyms
+    return RandomOrderAndNonNull({pass_instances_->GetApplyIdSynonyms()});
+  }
   if (&pass == pass_instances_->GetFlattenConditionalBranches()) {
     // - Parts of flattened selections can be outlined
     // - The flattening transformation introduces constants and irrelevant ids
diff --git a/source/fuzz/protobufs/spvtoolsfuzz.proto b/source/fuzz/protobufs/spvtoolsfuzz.proto
index 20116c7..770a2dd 100644
--- a/source/fuzz/protobufs/spvtoolsfuzz.proto
+++ b/source/fuzz/protobufs/spvtoolsfuzz.proto
@@ -556,6 +556,7 @@
     TransformationReplaceBranchFromDeadBlockWithExit replace_branch_from_dead_block_with_exit = 82;
     TransformationWrapEarlyTerminatorInFunction wrap_early_terminator_in_function = 83;
     TransformationMergeFunctionReturns merge_function_returns = 84;
+    TransformationExpandVectorReduction expand_vector_reduction = 85;
     // Add additional option using the next available number.
   }
 }
@@ -1417,6 +1418,21 @@
 
 }
 
+message TransformationExpandVectorReduction {
+
+  // A transformation that adds synonyms for OpAny and OpAll instructions by
+  // evaluating each vector component with the corresponding logical operation.
+  // There is a SPIR-V code example in the header file of the transformation
+  // class that can help understand the transformation.
+
+  // The OpAny or OpAll instruction result id.
+  uint32 instruction_result_id = 1;
+
+  // The fresh ids required to apply the transformation.
+  repeated uint32 fresh_ids = 2;
+
+}
+
 message TransformationFlattenConditionalBranch {
 
   // A transformation that takes a selection construct with a header
diff --git a/source/fuzz/transformation.cpp b/source/fuzz/transformation.cpp
index c8bf879..ebbc393 100644
--- a/source/fuzz/transformation.cpp
+++ b/source/fuzz/transformation.cpp
@@ -57,6 +57,7 @@
 #include "source/fuzz/transformation_compute_data_synonym_fact_closure.h"
 #include "source/fuzz/transformation_duplicate_region_with_selection.h"
 #include "source/fuzz/transformation_equation_instruction.h"
+#include "source/fuzz/transformation_expand_vector_reduction.h"
 #include "source/fuzz/transformation_flatten_conditional_branch.h"
 #include "source/fuzz/transformation_function_call.h"
 #include "source/fuzz/transformation_inline_function.h"
@@ -225,6 +226,9 @@
     case protobufs::Transformation::TransformationCase::kEquationInstruction:
       return MakeUnique<TransformationEquationInstruction>(
           message.equation_instruction());
+    case protobufs::Transformation::TransformationCase::kExpandVectorReduction:
+      return MakeUnique<TransformationExpandVectorReduction>(
+          message.expand_vector_reduction());
     case protobufs::Transformation::TransformationCase::
         kFlattenConditionalBranch:
       return MakeUnique<TransformationFlattenConditionalBranch>(
diff --git a/source/fuzz/transformation_expand_vector_reduction.cpp b/source/fuzz/transformation_expand_vector_reduction.cpp
new file mode 100644
index 0000000..640aea2
--- /dev/null
+++ b/source/fuzz/transformation_expand_vector_reduction.cpp
@@ -0,0 +1,170 @@
+// Copyright (c) 2020 André Perez Maselco
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "source/fuzz/transformation_expand_vector_reduction.h"
+
+#include "source/fuzz/fuzzer_util.h"
+#include "source/fuzz/instruction_descriptor.h"
+
+namespace spvtools {
+namespace fuzz {
+
+TransformationExpandVectorReduction::TransformationExpandVectorReduction(
+    const spvtools::fuzz::protobufs::TransformationExpandVectorReduction&
+        message)
+    : message_(message) {}
+
+TransformationExpandVectorReduction::TransformationExpandVectorReduction(
+    const uint32_t instruction_result_id,
+    const std::vector<uint32_t>& fresh_ids) {
+  message_.set_instruction_result_id(instruction_result_id);
+  *message_.mutable_fresh_ids() =
+      google::protobuf::RepeatedField<google::protobuf::uint32>(
+          fresh_ids.begin(), fresh_ids.end());
+}
+
+bool TransformationExpandVectorReduction::IsApplicable(
+    opt::IRContext* ir_context, const TransformationContext& /*unused*/) const {
+  auto* instruction =
+      ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id());
+
+  // |instruction| must be defined.
+  if (!instruction) {
+    return false;
+  }
+
+  // |instruction| must be OpAny or OpAll.
+  if (instruction->opcode() != SpvOpAny && instruction->opcode() != SpvOpAll) {
+    return false;
+  }
+
+  // |message_.fresh_ids.size| must have the exact number of fresh ids required
+  // to apply the transformation.
+  if (static_cast<uint32_t>(message_.fresh_ids().size()) !=
+      GetRequiredFreshIdCount(ir_context, instruction)) {
+    return false;
+  }
+
+  std::set<uint32_t> ids_used_by_this_transformation;
+  for (uint32_t fresh_id : message_.fresh_ids()) {
+    // All ids in |message_.fresh_ids| must be fresh.
+    if (!fuzzerutil::IsFreshId(ir_context, fresh_id)) {
+      return false;
+    }
+
+    // All fresh ids need to be distinct.
+    if (!CheckIdIsFreshAndNotUsedByThisTransformation(
+            fresh_id, ir_context, &ids_used_by_this_transformation)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void TransformationExpandVectorReduction::Apply(
+    opt::IRContext* ir_context,
+    TransformationContext* transformation_context) const {
+  auto* instruction =
+      ir_context->get_def_use_mgr()->GetDef(message_.instruction_result_id());
+  auto* vector = ir_context->get_def_use_mgr()->GetDef(
+      instruction->GetSingleWordInOperand(0));
+  uint32_t vector_component_count = ir_context->get_type_mgr()
+                                        ->GetType(vector->type_id())
+                                        ->AsVector()
+                                        ->element_count();
+
+  // Fresh id iterator.
+  auto fresh_id = message_.fresh_ids().begin();
+
+  // |vector_components| are the ids of the extracted components from |vector|.
+  std::vector<uint32_t> vector_components;
+
+  for (uint32_t i = 0; i < vector_component_count; i++) {
+    // Extracts the i-th |vector| component.
+    auto vector_component = opt::Instruction(
+        ir_context, SpvOpCompositeExtract, instruction->type_id(), *fresh_id++,
+        {{SPV_OPERAND_TYPE_ID, {vector->result_id()}},
+         {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}});
+    instruction->InsertBefore(MakeUnique<opt::Instruction>(vector_component));
+    fuzzerutil::UpdateModuleIdBound(ir_context, vector_component.result_id());
+    vector_components.push_back(vector_component.result_id());
+  }
+
+  // The first two |vector| components are used in the first logical operation.
+  auto logical_instruction = opt::Instruction(
+      ir_context,
+      instruction->opcode() == SpvOpAny ? SpvOpLogicalOr : SpvOpLogicalAnd,
+      instruction->type_id(), *fresh_id++,
+      {{SPV_OPERAND_TYPE_ID, {vector_components[0]}},
+       {SPV_OPERAND_TYPE_ID, {vector_components[1]}}});
+  instruction->InsertBefore(MakeUnique<opt::Instruction>(logical_instruction));
+  fuzzerutil::UpdateModuleIdBound(ir_context, logical_instruction.result_id());
+
+  // Evaluates the remaining components.
+  for (uint32_t i = 2; i < vector_components.size(); i++) {
+    logical_instruction = opt::Instruction(
+        ir_context, logical_instruction.opcode(), instruction->type_id(),
+        *fresh_id++,
+        {{SPV_OPERAND_TYPE_ID, {vector_components[i]}},
+         {SPV_OPERAND_TYPE_ID, {logical_instruction.result_id()}}});
+    instruction->InsertBefore(
+        MakeUnique<opt::Instruction>(logical_instruction));
+    fuzzerutil::UpdateModuleIdBound(ir_context,
+                                    logical_instruction.result_id());
+  }
+
+  ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone);
+
+  // If it's possible to make a synonym of |instruction|, then add the fact that
+  // the last |logical_instruction| is a synonym of |instruction|.
+  if (fuzzerutil::CanMakeSynonymOf(ir_context, *transformation_context,
+                                   instruction)) {
+    transformation_context->GetFactManager()->AddFactDataSynonym(
+        MakeDataDescriptor(logical_instruction.result_id(), {}),
+        MakeDataDescriptor(instruction->result_id(), {}));
+  }
+}
+
+protobufs::Transformation TransformationExpandVectorReduction::ToMessage()
+    const {
+  protobufs::Transformation result;
+  *result.mutable_expand_vector_reduction() = message_;
+  return result;
+}
+
+uint32_t TransformationExpandVectorReduction::GetRequiredFreshIdCount(
+    opt::IRContext* ir_context, opt::Instruction* instruction) {
+  // For each vector component, 1 OpCompositeExtract and 1 OpLogical* (except
+  // for the first component) instructions will be inserted.
+  return 2 * ir_context->get_type_mgr()
+                 ->GetType(ir_context->get_def_use_mgr()
+                               ->GetDef(instruction->GetSingleWordInOperand(0))
+                               ->type_id())
+                 ->AsVector()
+                 ->element_count() -
+         1;
+}
+
+std::unordered_set<uint32_t> TransformationExpandVectorReduction::GetFreshIds()
+    const {
+  std::unordered_set<uint32_t> result;
+  for (auto id : message_.fresh_ids()) {
+    result.insert(id);
+  }
+  return result;
+}
+
+}  // namespace fuzz
+}  // namespace spvtools
diff --git a/source/fuzz/transformation_expand_vector_reduction.h b/source/fuzz/transformation_expand_vector_reduction.h
new file mode 100644
index 0000000..e4cc953
--- /dev/null
+++ b/source/fuzz/transformation_expand_vector_reduction.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2020 André Perez Maselco
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SOURCE_FUZZ_TRANSFORMATION_EXPAND_VECTOR_REDUCTION_H_
+#define SOURCE_FUZZ_TRANSFORMATION_EXPAND_VECTOR_REDUCTION_H_
+
+#include "source/fuzz/protobufs/spirvfuzz_protobufs.h"
+#include "source/fuzz/transformation.h"
+#include "source/fuzz/transformation_context.h"
+#include "source/opt/ir_context.h"
+
+namespace spvtools {
+namespace fuzz {
+
+// clang-format off
+// SPIR-V code to help understand the transformation.
+//
+// -------------------------------------------------------------------------------
+// |           Reference shader           |            Variant shader            |
+// -------------------------------------------------------------------------------
+// |       OpCapability Shader            |       OpCapability Shader            |
+// |  %1 = OpExtInstImport "GLSL.std.450" |  %1 = OpExtInstImport "GLSL.std.450" |
+// |       OpMemoryModel Logical GLSL450  |       OpMemoryModel Logical GLSL450  |
+// |       OpEntryPoint Vertex %9 "main"  |       OpEntryPoint Vertex %9 "main"  |
+// |                                      |                                      |
+// | ; Types                              | ; Types                              |
+// |  %2 = OpTypeBool                     |  %2 = OpTypeBool                     |
+// |  %3 = OpTypeVector %2 2              |  %3 = OpTypeVector %2 2              |
+// |  %4 = OpTypeVoid                     |  %4 = OpTypeVoid                     |
+// |  %5 = OpTypeFunction %4              |  %5 = OpTypeFunction %4              |
+// |                                      |                                      |
+// | ; Constants                          | ; Constants                          |
+// |  %6 = OpConstantTrue %2              |  %6 = OpConstantTrue %2              |
+// |  %7 = OpConstantFalse %2             |  %7 = OpConstantFalse %2             |
+// |  %8 = OpConstantComposite %3 %6 %7   |  %8 = OpConstantComposite %3 %6 %7   |
+// |                                      |                                      |
+// | ; main function                      | ; main function                      |
+// |  %9 = OpFunction %4 None %5          |  %9 = OpFunction %4 None %5          |
+// | %10 = OpLabel                        | %10 = OpLabel                        |
+// | %11 = OpAny %2 %8                    |                                      |
+// | %12 = OpAll %2 %8                    | ; Add OpAny synonym                  |
+// |       OpReturn                       | %13 = OpCompositeExtract %2 %8 0     |
+// |       OpFunctionEnd                  | %14 = OpCompositeExtract %2 %8 1     |
+// |                                      | %15 = OpLogicalOr %2 %13 %14         |
+// |                                      | %11 = OpAny %2 %8                    |
+// |                                      |                                      |
+// |                                      | ; Add OpAll synonym                  |
+// |                                      | %16 = OpCompositeExtract %2 %8 0     |
+// |                                      | %17 = OpCompositeExtract %2 %8 1     |
+// |                                      | %18 = OpLogicalAnd %2 %16 %17        |
+// |                                      | %12 = OpAll %2 %8                    |
+// |                                      |       OpReturn                       |
+// |                                      |       OpFunctionEnd                  |
+// -------------------------------------------------------------------------------
+//
+// %11 and %15 are synonymous
+// %12 and %18 are synonymous
+// clang-format on
+class TransformationExpandVectorReduction : public Transformation {
+ public:
+  explicit TransformationExpandVectorReduction(
+      const protobufs::TransformationExpandVectorReduction& message);
+
+  TransformationExpandVectorReduction(const uint32_t instruction_result_id,
+                                      const std::vector<uint32_t>& fresh_ids);
+
+  // - |message_.instruction_result_id| must be OpAny or OpAll.
+  // - |message_.fresh_ids| must be fresh ids needed to apply the
+  //   transformation.
+  bool IsApplicable(
+      opt::IRContext* ir_context,
+      const TransformationContext& transformation_context) const override;
+
+  // Adds synonyms for OpAny and OpAll instructions by evaluating each vector
+  // component with the corresponding logical operation.
+  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.
+  static uint32_t GetRequiredFreshIdCount(opt::IRContext* ir_context,
+                                          opt::Instruction* instruction);
+
+ private:
+  protobufs::TransformationExpandVectorReduction message_;
+};
+
+}  // namespace fuzz
+}  // namespace spvtools
+
+#endif  // SOURCE_FUZZ_TRANSFORMATION_EXPAND_VECTOR_REDUCTION_H_
diff --git a/test/fuzz/CMakeLists.txt b/test/fuzz/CMakeLists.txt
index 866a924..2e93293 100644
--- a/test/fuzz/CMakeLists.txt
+++ b/test/fuzz/CMakeLists.txt
@@ -73,6 +73,7 @@
           transformation_compute_data_synonym_fact_closure_test.cpp
           transformation_duplicate_region_with_selection_test.cpp
           transformation_equation_instruction_test.cpp
+          transformation_expand_vector_reduction_test.cpp
           transformation_flatten_conditional_branch_test.cpp
           transformation_function_call_test.cpp
           transformation_inline_function_test.cpp
diff --git a/test/fuzz/transformation_expand_vector_reduction_test.cpp b/test/fuzz/transformation_expand_vector_reduction_test.cpp
new file mode 100644
index 0000000..ae5c4af
--- /dev/null
+++ b/test/fuzz/transformation_expand_vector_reduction_test.cpp
@@ -0,0 +1,284 @@
+// Copyright (c) 2020 André Perez Maselco
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "source/fuzz/transformation_expand_vector_reduction.h"
+
+#include "gtest/gtest.h"
+#include "source/fuzz/fuzzer_util.h"
+#include "source/fuzz/instruction_descriptor.h"
+#include "test/fuzz/fuzz_test_util.h"
+
+namespace spvtools {
+namespace fuzz {
+namespace {
+
+TEST(TransformationExpandVectorReductionTest, IsApplicable) {
+  std::string reference_shader = R"(
+               OpCapability Shader
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %9 "main"
+
+          ; Types
+          %2 = OpTypeBool
+          %3 = OpTypeVector %2 2
+          %4 = OpTypeVoid
+          %5 = OpTypeFunction %4
+
+          ; Constants
+          %6 = OpConstantTrue %2
+          %7 = OpConstantFalse %2
+          %8 = OpConstantComposite %3 %6 %7
+
+          ; main function
+          %9 = OpFunction %4 None %5
+         %10 = OpLabel
+         %11 = OpAny %2 %8
+         %12 = OpAll %2 %8
+               OpReturn
+               OpFunctionEnd
+  )";
+
+  const auto env = SPV_ENV_UNIVERSAL_1_5;
+  const auto consumer = nullptr;
+  const auto context =
+      BuildModule(env, consumer, reference_shader, kFuzzAssembleOption);
+
+  spvtools::ValidatorOptions validator_options;
+  TransformationContext transformation_context(
+      MakeUnique<FactManager>(context.get()), validator_options);
+  ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
+                                               kConsoleMessageConsumer));
+
+  // Tests undefined instruction.
+  auto transformation = TransformationExpandVectorReduction(13, {14, 15, 16});
+  ASSERT_FALSE(
+      transformation.IsApplicable(context.get(), transformation_context));
+
+  // Tests non OpAny or OpAll instruction.
+  transformation = TransformationExpandVectorReduction(10, {13, 14, 15});
+  ASSERT_FALSE(
+      transformation.IsApplicable(context.get(), transformation_context));
+
+  // Tests the number of fresh ids being different than the necessary.
+  transformation = TransformationExpandVectorReduction(11, {13, 14});
+  ASSERT_FALSE(
+      transformation.IsApplicable(context.get(), transformation_context));
+
+  transformation = TransformationExpandVectorReduction(12, {13, 14, 15, 16});
+  ASSERT_FALSE(
+      transformation.IsApplicable(context.get(), transformation_context));
+
+  // Tests non-fresh ids.
+  transformation = TransformationExpandVectorReduction(11, {12, 13, 14});
+  ASSERT_FALSE(
+      transformation.IsApplicable(context.get(), transformation_context));
+
+  // Tests duplicated fresh ids.
+  transformation = TransformationExpandVectorReduction(11, {13, 13, 14});
+  ASSERT_FALSE(
+      transformation.IsApplicable(context.get(), transformation_context));
+
+  // Tests applicable transformations.
+  transformation = TransformationExpandVectorReduction(11, {13, 14, 15});
+  ASSERT_TRUE(
+      transformation.IsApplicable(context.get(), transformation_context));
+
+  transformation = TransformationExpandVectorReduction(12, {13, 14, 15});
+  ASSERT_TRUE(
+      transformation.IsApplicable(context.get(), transformation_context));
+}
+
+TEST(TransformationExpandVectorReductionTest, Apply) {
+  std::string reference_shader = R"(
+               OpCapability Shader
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %13 "main"
+
+          ; Types
+          %2 = OpTypeBool
+          %3 = OpTypeVector %2 2
+          %4 = OpTypeVector %2 3
+          %5 = OpTypeVector %2 4
+          %6 = OpTypeVoid
+          %7 = OpTypeFunction %6
+
+          ; Constants
+          %8 = OpConstantTrue %2
+          %9 = OpConstantFalse %2
+         %10 = OpConstantComposite %3 %8 %9
+         %11 = OpConstantComposite %4 %8 %9 %8
+         %12 = OpConstantComposite %5 %8 %9 %8 %9
+
+         ; main function
+         %13 = OpFunction %6 None %7
+         %14 = OpLabel
+
+         ; OpAny for 2-dimensional vector
+         %15 = OpAny %2 %10
+
+         ; OpAny for 3-dimensional vector
+         %16 = OpAny %2 %11
+
+         ; OpAny for 4-dimensional vector
+         %17 = OpAny %2 %12
+
+         ; OpAll for 2-dimensional vector
+         %18 = OpAll %2 %10
+
+         ; OpAll for 3-dimensional vector
+         %19 = OpAll %2 %11
+
+         ; OpAll for 4-dimensional vector
+         %20 = OpAll %2 %12
+               OpReturn
+               OpFunctionEnd
+  )";
+
+  const auto env = SPV_ENV_UNIVERSAL_1_5;
+  const auto consumer = nullptr;
+  const auto context =
+      BuildModule(env, consumer, reference_shader, kFuzzAssembleOption);
+
+  spvtools::ValidatorOptions validator_options;
+  TransformationContext transformation_context(
+      MakeUnique<FactManager>(context.get()), validator_options);
+  ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
+                                               kConsoleMessageConsumer));
+
+  // Adds OpAny synonym for 2-dimensional vector.
+  auto transformation = TransformationExpandVectorReduction(15, {21, 22, 23});
+  ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
+  ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous(
+      MakeDataDescriptor(23, {}), MakeDataDescriptor(15, {})));
+
+  // Adds OpAny synonym for 3-dimensional vector.
+  transformation =
+      TransformationExpandVectorReduction(16, {24, 25, 26, 27, 28});
+  ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
+  ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous(
+      MakeDataDescriptor(28, {}), MakeDataDescriptor(16, {})));
+
+  // Adds OpAny synonym for 4-dimensional vector.
+  transformation =
+      TransformationExpandVectorReduction(17, {29, 30, 31, 32, 33, 34, 35});
+  ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
+  ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous(
+      MakeDataDescriptor(35, {}), MakeDataDescriptor(17, {})));
+
+  // Adds OpAll synonym for 2-dimensional vector.
+  transformation = TransformationExpandVectorReduction(18, {36, 37, 38});
+  ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
+  ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous(
+      MakeDataDescriptor(38, {}), MakeDataDescriptor(18, {})));
+
+  // Adds OpAll synonym for 3-dimensional vector.
+  transformation =
+      TransformationExpandVectorReduction(19, {39, 40, 41, 42, 43});
+  ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
+  ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous(
+      MakeDataDescriptor(43, {}), MakeDataDescriptor(19, {})));
+
+  // Adds OpAll synonym for 4-dimensional vector.
+  transformation =
+      TransformationExpandVectorReduction(20, {44, 45, 46, 47, 48, 49, 50});
+  ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
+  ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous(
+      MakeDataDescriptor(50, {}), MakeDataDescriptor(20, {})));
+
+  std::string variant_shader = R"(
+               OpCapability Shader
+          %1 = OpExtInstImport "GLSL.std.450"
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint Vertex %13 "main"
+
+          ; Types
+          %2 = OpTypeBool
+          %3 = OpTypeVector %2 2
+          %4 = OpTypeVector %2 3
+          %5 = OpTypeVector %2 4
+          %6 = OpTypeVoid
+          %7 = OpTypeFunction %6
+
+          ; Constants
+          %8 = OpConstantTrue %2
+          %9 = OpConstantFalse %2
+         %10 = OpConstantComposite %3 %8 %9
+         %11 = OpConstantComposite %4 %8 %9 %8
+         %12 = OpConstantComposite %5 %8 %9 %8 %9
+
+         ; main function
+         %13 = OpFunction %6 None %7
+         %14 = OpLabel
+
+         ; Add OpAny synonym for 2-dimensional vector
+         %21 = OpCompositeExtract %2 %10 0
+         %22 = OpCompositeExtract %2 %10 1
+         %23 = OpLogicalOr %2 %21 %22
+         %15 = OpAny %2 %10
+
+         ; Add OpAny synonym for 3-dimensional vector
+         %24 = OpCompositeExtract %2 %11 0
+         %25 = OpCompositeExtract %2 %11 1
+         %26 = OpCompositeExtract %2 %11 2
+         %27 = OpLogicalOr %2 %24 %25
+         %28 = OpLogicalOr %2 %26 %27
+         %16 = OpAny %2 %11
+
+         ; Add OpAny synonym for 4-dimensional vector
+         %29 = OpCompositeExtract %2 %12 0
+         %30 = OpCompositeExtract %2 %12 1
+         %31 = OpCompositeExtract %2 %12 2
+         %32 = OpCompositeExtract %2 %12 3
+         %33 = OpLogicalOr %2 %29 %30
+         %34 = OpLogicalOr %2 %31 %33
+         %35 = OpLogicalOr %2 %32 %34
+         %17 = OpAny %2 %12
+
+         ; Add OpAll synonym for 2-dimensional vector
+         %36 = OpCompositeExtract %2 %10 0
+         %37 = OpCompositeExtract %2 %10 1
+         %38 = OpLogicalAnd %2 %36 %37
+         %18 = OpAll %2 %10
+
+         ; Add OpAll synonym for 3-dimensional vector
+         %39 = OpCompositeExtract %2 %11 0
+         %40 = OpCompositeExtract %2 %11 1
+         %41 = OpCompositeExtract %2 %11 2
+         %42 = OpLogicalAnd %2 %39 %40
+         %43 = OpLogicalAnd %2 %41 %42
+         %19 = OpAll %2 %11
+
+         ; Add OpAll synonym for 4-dimensional vector
+         %44 = OpCompositeExtract %2 %12 0
+         %45 = OpCompositeExtract %2 %12 1
+         %46 = OpCompositeExtract %2 %12 2
+         %47 = OpCompositeExtract %2 %12 3
+         %48 = OpLogicalAnd %2 %44 %45
+         %49 = OpLogicalAnd %2 %46 %48
+         %50 = OpLogicalAnd %2 %47 %49
+         %20 = OpAll %2 %12
+               OpReturn
+               OpFunctionEnd
+  )";
+
+  ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
+                                               kConsoleMessageConsumer));
+  ASSERT_TRUE(IsEqual(env, variant_shader, context.get()));
+}
+
+}  // namespace
+}  // namespace fuzz
+}  // namespace spvtools