source/fuzz/transformation_replace_linear_algebra_instruction.cpp

// 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_replace_linear_algebra_instruction.h"

#include "source/fuzz/fuzzer_util.h"
#include "source/fuzz/instruction_descriptor.h"

namespace spvtools {
namespace fuzz {

TransformationReplaceLinearAlgebraInstruction::
    TransformationReplaceLinearAlgebraInstruction(
        protobufs::TransformationReplaceLinearAlgebraInstruction message)
    : message_(std::move(message)) {}

TransformationReplaceLinearAlgebraInstruction::
    TransformationReplaceLinearAlgebraInstruction(
        const std::vector<uint32_t>& fresh_ids,
        const protobufs::InstructionDescriptor& instruction_descriptor) {
  for (auto fresh_id : fresh_ids) {
    message_.add_fresh_ids(fresh_id);
  }
  *message_.mutable_instruction_descriptor() = instruction_descriptor;
}

bool TransformationReplaceLinearAlgebraInstruction::IsApplicable(
    opt::IRContext* ir_context, const TransformationContext& /*unused*/) const {
  auto instruction =
      FindInstruction(message_.instruction_descriptor(), ir_context);

  // It must be a linear algebra instruction.
  if (!spvOpcodeIsLinearAlgebra(instruction->opcode())) {
    return false;
  }

  // |message_.fresh_ids.size| must be the exact number of fresh ids needed to
  // apply the transformation.
  if (static_cast<uint32_t>(message_.fresh_ids().size()) !=
      GetRequiredFreshIdCount(ir_context, instruction)) {
    return false;
  }

  // All ids in |message_.fresh_ids| must be fresh.
  for (uint32_t fresh_id : message_.fresh_ids()) {
    if (!fuzzerutil::IsFreshId(ir_context, fresh_id)) {
      return false;
    }
  }

  return true;
}

void TransformationReplaceLinearAlgebraInstruction::Apply(
    opt::IRContext* ir_context, TransformationContext* /*unused*/) const {
  auto linear_algebra_instruction =
      FindInstruction(message_.instruction_descriptor(), ir_context);

  switch (linear_algebra_instruction->opcode()) {
    case spv::Op::OpTranspose:
      ReplaceOpTranspose(ir_context, linear_algebra_instruction);
      break;
    case spv::Op::OpVectorTimesScalar:
      ReplaceOpVectorTimesScalar(ir_context, linear_algebra_instruction);
      break;
    case spv::Op::OpMatrixTimesScalar:
      ReplaceOpMatrixTimesScalar(ir_context, linear_algebra_instruction);
      break;
    case spv::Op::OpVectorTimesMatrix:
      ReplaceOpVectorTimesMatrix(ir_context, linear_algebra_instruction);
      break;
    case spv::Op::OpMatrixTimesVector:
      ReplaceOpMatrixTimesVector(ir_context, linear_algebra_instruction);
      break;
    case spv::Op::OpMatrixTimesMatrix:
      ReplaceOpMatrixTimesMatrix(ir_context, linear_algebra_instruction);
      break;
    case spv::Op::OpOuterProduct:
      ReplaceOpOuterProduct(ir_context, linear_algebra_instruction);
      break;
    case spv::Op::OpDot:
      ReplaceOpDot(ir_context, linear_algebra_instruction);
      break;
    default:
      assert(false && "Should be unreachable.");
      break;
  }

  ir_context->InvalidateAnalysesExceptFor(opt::IRContext::kAnalysisNone);
}

protobufs::Transformation
TransformationReplaceLinearAlgebraInstruction::ToMessage() const {
  protobufs::Transformation result;
  *result.mutable_replace_linear_algebra_instruction() = message_;
  return result;
}

uint32_t TransformationReplaceLinearAlgebraInstruction::GetRequiredFreshIdCount(
    opt::IRContext* ir_context, opt::Instruction* instruction) {
  // TODO(https://github.com/KhronosGroup/SPIRV-Tools/issues/3354):
  // Right now we only support certain operations.
  switch (instruction->opcode()) {
    case spv::Op::OpTranspose: {
      // For each matrix row, |2 * matrix_column_count| OpCompositeExtract and 1
      // OpCompositeConstruct will be inserted.
      auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(0));
      uint32_t matrix_column_count =
          ir_context->get_type_mgr()
              ->GetType(matrix_instruction->type_id())
              ->AsMatrix()
              ->element_count();
      uint32_t matrix_row_count = ir_context->get_type_mgr()
                                      ->GetType(matrix_instruction->type_id())
                                      ->AsMatrix()
                                      ->element_type()
                                      ->AsVector()
                                      ->element_count();
      return matrix_row_count * (2 * matrix_column_count + 1);
    }
    case spv::Op::OpVectorTimesScalar:
      // For each vector component, 1 OpCompositeExtract and 1 OpFMul 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();
    case spv::Op::OpMatrixTimesScalar: {
      // For each matrix column, |1 + column.size| OpCompositeExtract,
      // |column.size| OpFMul and 1 OpCompositeConstruct instructions will be
      // inserted.
      auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(0));
      auto matrix_type =
          ir_context->get_type_mgr()->GetType(matrix_instruction->type_id());
      return 2 * matrix_type->AsMatrix()->element_count() *
             (1 + matrix_type->AsMatrix()
                      ->element_type()
                      ->AsVector()
                      ->element_count());
    }
    case spv::Op::OpVectorTimesMatrix: {
      // For each vector component, 1 OpCompositeExtract instruction will be
      // inserted. For each matrix column, |1 + vector_component_count|
      // OpCompositeExtract, |vector_component_count| OpFMul and
      // |vector_component_count - 1| OpFAdd instructions will be inserted.
      auto vector_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(0));
      auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(1));
      uint32_t vector_component_count =
          ir_context->get_type_mgr()
              ->GetType(vector_instruction->type_id())
              ->AsVector()
              ->element_count();
      uint32_t matrix_column_count =
          ir_context->get_type_mgr()
              ->GetType(matrix_instruction->type_id())
              ->AsMatrix()
              ->element_count();
      return vector_component_count * (3 * matrix_column_count + 1);
    }
    case spv::Op::OpMatrixTimesVector: {
      // For each matrix column, |1 + matrix_row_count| OpCompositeExtract
      // will be inserted. For each matrix row, |matrix_column_count| OpFMul and
      // |matrix_column_count - 1| OpFAdd instructions will be inserted. For
      // each vector component, 1 OpCompositeExtract instruction will be
      // inserted.
      auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(0));
      uint32_t matrix_column_count =
          ir_context->get_type_mgr()
              ->GetType(matrix_instruction->type_id())
              ->AsMatrix()
              ->element_count();
      uint32_t matrix_row_count = ir_context->get_type_mgr()
                                      ->GetType(matrix_instruction->type_id())
                                      ->AsMatrix()
                                      ->element_type()
                                      ->AsVector()
                                      ->element_count();
      return 3 * matrix_column_count * matrix_row_count +
             2 * matrix_column_count - matrix_row_count;
    }
    case spv::Op::OpMatrixTimesMatrix: {
      // For each matrix 2 column, 1 OpCompositeExtract, 1 OpCompositeConstruct,
      // |3 * matrix_1_row_count * matrix_1_column_count| OpCompositeExtract,
      // |matrix_1_row_count * matrix_1_column_count| OpFMul,
      // |matrix_1_row_count * (matrix_1_column_count - 1)| OpFAdd instructions
      // will be inserted.
      auto matrix_1_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(0));
      uint32_t matrix_1_column_count =
          ir_context->get_type_mgr()
              ->GetType(matrix_1_instruction->type_id())
              ->AsMatrix()
              ->element_count();
      uint32_t matrix_1_row_count =
          ir_context->get_type_mgr()
              ->GetType(matrix_1_instruction->type_id())
              ->AsMatrix()
              ->element_type()
              ->AsVector()
              ->element_count();

      auto matrix_2_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(1));
      uint32_t matrix_2_column_count =
          ir_context->get_type_mgr()
              ->GetType(matrix_2_instruction->type_id())
              ->AsMatrix()
              ->element_count();
      return matrix_2_column_count *
             (2 + matrix_1_row_count * (5 * matrix_1_column_count - 1));
    }
    case spv::Op::OpOuterProduct: {
      // For each |vector_2| component, |vector_1_component_count + 1|
      // OpCompositeExtract, |vector_1_component_count| OpFMul and 1
      // OpCompositeConstruct instructions will be inserted.
      auto vector_1_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(0));
      auto vector_2_instruction = ir_context->get_def_use_mgr()->GetDef(
          instruction->GetSingleWordInOperand(1));
      uint32_t vector_1_component_count =
          ir_context->get_type_mgr()
              ->GetType(vector_1_instruction->type_id())
              ->AsVector()
              ->element_count();
      uint32_t vector_2_component_count =
          ir_context->get_type_mgr()
              ->GetType(vector_2_instruction->type_id())
              ->AsVector()
              ->element_count();
      return 2 * vector_2_component_count * (vector_1_component_count + 1);
    }
    case spv::Op::OpDot:
      // For each pair of vector components, 2 OpCompositeExtract and 1 OpFMul
      // will be inserted. The first two OpFMul instructions will result the
      // first OpFAdd instruction to be inserted. For each remaining OpFMul, 1
      // OpFAdd will be inserted. The last OpFAdd instruction is got by changing
      // the OpDot instruction.
      return 4 * ir_context->get_type_mgr()
                     ->GetType(
                         ir_context->get_def_use_mgr()
                             ->GetDef(instruction->GetSingleWordInOperand(0))
                             ->type_id())
                     ->AsVector()
                     ->element_count() -
             2;
    default:
      assert(false && "Unsupported linear algebra instruction.");
      return 0;
  }
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpTranspose(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets OpTranspose instruction information.
  auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  uint32_t matrix_column_count = ir_context->get_type_mgr()
                                     ->GetType(matrix_instruction->type_id())
                                     ->AsMatrix()
                                     ->element_count();
  auto matrix_column_type = ir_context->get_type_mgr()
                                ->GetType(matrix_instruction->type_id())
                                ->AsMatrix()
                                ->element_type();
  auto matrix_column_component_type =
      matrix_column_type->AsVector()->element_type();
  uint32_t matrix_row_count = matrix_column_type->AsVector()->element_count();
  auto resulting_matrix_column_type =
      ir_context->get_type_mgr()
          ->GetType(linear_algebra_instruction->type_id())
          ->AsMatrix()
          ->element_type();

  uint32_t fresh_id_index = 0;
  std::vector<uint32_t> result_column_ids(matrix_row_count);
  for (uint32_t i = 0; i < matrix_row_count; i++) {
    std::vector<uint32_t> column_component_ids(matrix_column_count);
    for (uint32_t j = 0; j < matrix_column_count; j++) {
      // Extracts the matrix column.
      uint32_t matrix_column_id = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpCompositeExtract,
          ir_context->get_type_mgr()->GetId(matrix_column_type),
          matrix_column_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}},
               {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}})));

      // Extracts the matrix column component.
      column_component_ids[j] = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpCompositeExtract,
          ir_context->get_type_mgr()->GetId(matrix_column_component_type),
          column_component_ids[j],
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {matrix_column_id}},
               {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));
    }

    // Inserts the resulting matrix column.
    opt::Instruction::OperandList in_operands;
    for (auto& column_component_id : column_component_ids) {
      in_operands.push_back({SPV_OPERAND_TYPE_ID, {column_component_id}});
    }
    result_column_ids[i] = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeConstruct,
        ir_context->get_type_mgr()->GetId(resulting_matrix_column_type),
        result_column_ids[i], opt::Instruction::OperandList(in_operands)));
  }

  // The OpTranspose instruction is changed to an OpCompositeConstruct
  // instruction.
  linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct);
  linear_algebra_instruction->SetInOperand(0, {result_column_ids[0]});
  for (uint32_t i = 1; i < result_column_ids.size(); i++) {
    linear_algebra_instruction->AddOperand(
        {SPV_OPERAND_TYPE_ID, {result_column_ids[i]}});
  }

  fuzzerutil::UpdateModuleIdBound(
      ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1));
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpVectorTimesScalar(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets OpVectorTimesScalar in operands.
  auto vector = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  auto scalar = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(1));

  uint32_t vector_component_count = ir_context->get_type_mgr()
                                        ->GetType(vector->type_id())
                                        ->AsVector()
                                        ->element_count();
  std::vector<uint32_t> float_multiplication_ids(vector_component_count);
  uint32_t fresh_id_index = 0;

  for (uint32_t i = 0; i < vector_component_count; i++) {
    // Extracts |vector| component.
    uint32_t vector_extract_id = message_.fresh_ids(fresh_id_index++);
    fuzzerutil::UpdateModuleIdBound(ir_context, vector_extract_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract, scalar->type_id(),
        vector_extract_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

    // Multiplies the |vector| component with the |scalar|.
    uint32_t float_multiplication_id = message_.fresh_ids(fresh_id_index++);
    float_multiplication_ids[i] = float_multiplication_id;
    fuzzerutil::UpdateModuleIdBound(ir_context, float_multiplication_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpFMul, scalar->type_id(), float_multiplication_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector_extract_id}},
             {SPV_OPERAND_TYPE_ID, {scalar->result_id()}}})));
  }

  // The OpVectorTimesScalar instruction is changed to an OpCompositeConstruct
  // instruction.
  linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct);
  linear_algebra_instruction->SetInOperand(0, {float_multiplication_ids[0]});
  linear_algebra_instruction->SetInOperand(1, {float_multiplication_ids[1]});
  for (uint32_t i = 2; i < float_multiplication_ids.size(); i++) {
    linear_algebra_instruction->AddOperand(
        {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[i]}});
  }
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpMatrixTimesScalar(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets OpMatrixTimesScalar in operands.
  auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  auto scalar_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(1));

  // Gets matrix information.
  uint32_t matrix_column_count = ir_context->get_type_mgr()
                                     ->GetType(matrix_instruction->type_id())
                                     ->AsMatrix()
                                     ->element_count();
  auto matrix_column_type = ir_context->get_type_mgr()
                                ->GetType(matrix_instruction->type_id())
                                ->AsMatrix()
                                ->element_type();
  uint32_t matrix_column_size = matrix_column_type->AsVector()->element_count();

  std::vector<uint32_t> composite_construct_ids(matrix_column_count);
  uint32_t fresh_id_index = 0;

  for (uint32_t i = 0; i < matrix_column_count; i++) {
    // Extracts |matrix| column.
    uint32_t matrix_extract_id = message_.fresh_ids(fresh_id_index++);
    fuzzerutil::UpdateModuleIdBound(ir_context, matrix_extract_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        ir_context->get_type_mgr()->GetId(matrix_column_type),
        matrix_extract_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

    std::vector<uint32_t> float_multiplication_ids(matrix_column_size);

    for (uint32_t j = 0; j < matrix_column_size; j++) {
      // Extracts |column| component.
      uint32_t column_extract_id = message_.fresh_ids(fresh_id_index++);
      fuzzerutil::UpdateModuleIdBound(ir_context, column_extract_id);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpCompositeExtract,
          scalar_instruction->type_id(), column_extract_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {matrix_extract_id}},
               {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}})));

      // Multiplies the |column| component with the |scalar|.
      float_multiplication_ids[j] = message_.fresh_ids(fresh_id_index++);
      fuzzerutil::UpdateModuleIdBound(ir_context, float_multiplication_ids[j]);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFMul, scalar_instruction->type_id(),
          float_multiplication_ids[j],
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {column_extract_id}},
               {SPV_OPERAND_TYPE_ID, {scalar_instruction->result_id()}}})));
    }

    // Constructs a new column multiplied by |scalar|.
    opt::Instruction::OperandList composite_construct_in_operands;
    for (uint32_t& float_multiplication_id : float_multiplication_ids) {
      composite_construct_in_operands.push_back(
          {SPV_OPERAND_TYPE_ID, {float_multiplication_id}});
    }
    composite_construct_ids[i] = message_.fresh_ids(fresh_id_index++);
    fuzzerutil::UpdateModuleIdBound(ir_context, composite_construct_ids[i]);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeConstruct,
        ir_context->get_type_mgr()->GetId(matrix_column_type),
        composite_construct_ids[i], composite_construct_in_operands));
  }

  // The OpMatrixTimesScalar instruction is changed to an OpCompositeConstruct
  // instruction.
  linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct);
  linear_algebra_instruction->SetInOperand(0, {composite_construct_ids[0]});
  linear_algebra_instruction->SetInOperand(1, {composite_construct_ids[1]});
  for (uint32_t i = 2; i < composite_construct_ids.size(); i++) {
    linear_algebra_instruction->AddOperand(
        {SPV_OPERAND_TYPE_ID, {composite_construct_ids[i]}});
  }
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpVectorTimesMatrix(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets vector information.
  auto vector_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  uint32_t vector_component_count = ir_context->get_type_mgr()
                                        ->GetType(vector_instruction->type_id())
                                        ->AsVector()
                                        ->element_count();
  auto vector_component_type = ir_context->get_type_mgr()
                                   ->GetType(vector_instruction->type_id())
                                   ->AsVector()
                                   ->element_type();

  // Extracts vector components.
  uint32_t fresh_id_index = 0;
  std::vector<uint32_t> vector_component_ids(vector_component_count);
  for (uint32_t i = 0; i < vector_component_count; i++) {
    vector_component_ids[i] = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        ir_context->get_type_mgr()->GetId(vector_component_type),
        vector_component_ids[i],
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector_instruction->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));
  }

  // Gets matrix information.
  auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(1));
  uint32_t matrix_column_count = ir_context->get_type_mgr()
                                     ->GetType(matrix_instruction->type_id())
                                     ->AsMatrix()
                                     ->element_count();
  auto matrix_column_type = ir_context->get_type_mgr()
                                ->GetType(matrix_instruction->type_id())
                                ->AsMatrix()
                                ->element_type();

  std::vector<uint32_t> result_component_ids(matrix_column_count);
  for (uint32_t i = 0; i < matrix_column_count; i++) {
    // Extracts matrix column.
    uint32_t matrix_extract_id = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        ir_context->get_type_mgr()->GetId(matrix_column_type),
        matrix_extract_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

    std::vector<uint32_t> float_multiplication_ids(vector_component_count);
    for (uint32_t j = 0; j < vector_component_count; j++) {
      // Extracts column component.
      uint32_t column_extract_id = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpCompositeExtract,
          ir_context->get_type_mgr()->GetId(vector_component_type),
          column_extract_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {matrix_extract_id}},
               {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}})));

      // Multiplies corresponding vector and column components.
      float_multiplication_ids[j] = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFMul,
          ir_context->get_type_mgr()->GetId(vector_component_type),
          float_multiplication_ids[j],
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {vector_component_ids[j]}},
               {SPV_OPERAND_TYPE_ID, {column_extract_id}}})));
    }

    // Adds the multiplication results.
    std::vector<uint32_t> float_add_ids;
    uint32_t float_add_id = message_.fresh_ids(fresh_id_index++);
    float_add_ids.push_back(float_add_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpFAdd,
        ir_context->get_type_mgr()->GetId(vector_component_type), float_add_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}},
             {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}})));
    for (uint32_t j = 2; j < float_multiplication_ids.size(); j++) {
      float_add_id = message_.fresh_ids(fresh_id_index++);
      float_add_ids.push_back(float_add_id);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFAdd,
          ir_context->get_type_mgr()->GetId(vector_component_type),
          float_add_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[j]}},
               {SPV_OPERAND_TYPE_ID, {float_add_ids[j - 2]}}})));
    }

    result_component_ids[i] = float_add_ids.back();
  }

  // The OpVectorTimesMatrix instruction is changed to an OpCompositeConstruct
  // instruction.
  linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct);
  linear_algebra_instruction->SetInOperand(0, {result_component_ids[0]});
  linear_algebra_instruction->SetInOperand(1, {result_component_ids[1]});
  for (uint32_t i = 2; i < result_component_ids.size(); i++) {
    linear_algebra_instruction->AddOperand(
        {SPV_OPERAND_TYPE_ID, {result_component_ids[i]}});
  }

  fuzzerutil::UpdateModuleIdBound(
      ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1));
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpMatrixTimesVector(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets matrix information.
  auto matrix_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  uint32_t matrix_column_count = ir_context->get_type_mgr()
                                     ->GetType(matrix_instruction->type_id())
                                     ->AsMatrix()
                                     ->element_count();
  auto matrix_column_type = ir_context->get_type_mgr()
                                ->GetType(matrix_instruction->type_id())
                                ->AsMatrix()
                                ->element_type();
  uint32_t matrix_row_count = matrix_column_type->AsVector()->element_count();

  // Extracts matrix columns.
  uint32_t fresh_id_index = 0;
  std::vector<uint32_t> matrix_column_ids(matrix_column_count);
  for (uint32_t i = 0; i < matrix_column_count; i++) {
    matrix_column_ids[i] = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        ir_context->get_type_mgr()->GetId(matrix_column_type),
        matrix_column_ids[i],
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {matrix_instruction->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));
  }

  // Gets vector information.
  auto vector_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(1));
  auto vector_component_type = ir_context->get_type_mgr()
                                   ->GetType(vector_instruction->type_id())
                                   ->AsVector()
                                   ->element_type();

  // Extracts vector components.
  std::vector<uint32_t> vector_component_ids(matrix_column_count);
  for (uint32_t i = 0; i < matrix_column_count; i++) {
    vector_component_ids[i] = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        ir_context->get_type_mgr()->GetId(vector_component_type),
        vector_component_ids[i],
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector_instruction->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));
  }

  std::vector<uint32_t> result_component_ids(matrix_row_count);
  for (uint32_t i = 0; i < matrix_row_count; i++) {
    std::vector<uint32_t> float_multiplication_ids(matrix_column_count);
    for (uint32_t j = 0; j < matrix_column_count; j++) {
      // Extracts column component.
      uint32_t column_extract_id = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpCompositeExtract,
          ir_context->get_type_mgr()->GetId(vector_component_type),
          column_extract_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {matrix_column_ids[j]}},
               {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

      // Multiplies corresponding vector and column components.
      float_multiplication_ids[j] = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFMul,
          ir_context->get_type_mgr()->GetId(vector_component_type),
          float_multiplication_ids[j],
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {column_extract_id}},
               {SPV_OPERAND_TYPE_ID, {vector_component_ids[j]}}})));
    }

    // Adds the multiplication results.
    std::vector<uint32_t> float_add_ids;
    uint32_t float_add_id = message_.fresh_ids(fresh_id_index++);
    float_add_ids.push_back(float_add_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpFAdd,
        ir_context->get_type_mgr()->GetId(vector_component_type), float_add_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}},
             {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}})));
    for (uint32_t j = 2; j < float_multiplication_ids.size(); j++) {
      float_add_id = message_.fresh_ids(fresh_id_index++);
      float_add_ids.push_back(float_add_id);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFAdd,
          ir_context->get_type_mgr()->GetId(vector_component_type),
          float_add_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[j]}},
               {SPV_OPERAND_TYPE_ID, {float_add_ids[j - 2]}}})));
    }

    result_component_ids[i] = float_add_ids.back();
  }

  // The OpMatrixTimesVector instruction is changed to an OpCompositeConstruct
  // instruction.
  linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct);
  linear_algebra_instruction->SetInOperand(0, {result_component_ids[0]});
  linear_algebra_instruction->SetInOperand(1, {result_component_ids[1]});
  for (uint32_t i = 2; i < result_component_ids.size(); i++) {
    linear_algebra_instruction->AddOperand(
        {SPV_OPERAND_TYPE_ID, {result_component_ids[i]}});
  }

  fuzzerutil::UpdateModuleIdBound(
      ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1));
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpMatrixTimesMatrix(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets matrix 1 information.
  auto matrix_1_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  uint32_t matrix_1_column_count =
      ir_context->get_type_mgr()
          ->GetType(matrix_1_instruction->type_id())
          ->AsMatrix()
          ->element_count();
  auto matrix_1_column_type = ir_context->get_type_mgr()
                                  ->GetType(matrix_1_instruction->type_id())
                                  ->AsMatrix()
                                  ->element_type();
  auto matrix_1_column_component_type =
      matrix_1_column_type->AsVector()->element_type();
  uint32_t matrix_1_row_count =
      matrix_1_column_type->AsVector()->element_count();

  // Gets matrix 2 information.
  auto matrix_2_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(1));
  uint32_t matrix_2_column_count =
      ir_context->get_type_mgr()
          ->GetType(matrix_2_instruction->type_id())
          ->AsMatrix()
          ->element_count();
  auto matrix_2_column_type = ir_context->get_type_mgr()
                                  ->GetType(matrix_2_instruction->type_id())
                                  ->AsMatrix()
                                  ->element_type();

  uint32_t fresh_id_index = 0;
  std::vector<uint32_t> result_column_ids(matrix_2_column_count);
  for (uint32_t i = 0; i < matrix_2_column_count; i++) {
    // Extracts matrix 2 column.
    uint32_t matrix_2_column_id = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        ir_context->get_type_mgr()->GetId(matrix_2_column_type),
        matrix_2_column_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {matrix_2_instruction->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

    std::vector<uint32_t> column_component_ids(matrix_1_row_count);
    for (uint32_t j = 0; j < matrix_1_row_count; j++) {
      std::vector<uint32_t> float_multiplication_ids(matrix_1_column_count);
      for (uint32_t k = 0; k < matrix_1_column_count; k++) {
        // Extracts matrix 1 column.
        uint32_t matrix_1_column_id = message_.fresh_ids(fresh_id_index++);
        linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
            ir_context, spv::Op::OpCompositeExtract,
            ir_context->get_type_mgr()->GetId(matrix_1_column_type),
            matrix_1_column_id,
            opt::Instruction::OperandList(
                {{SPV_OPERAND_TYPE_ID, {matrix_1_instruction->result_id()}},
                 {SPV_OPERAND_TYPE_LITERAL_INTEGER, {k}}})));

        // Extracts matrix 1 column component.
        uint32_t matrix_1_column_component_id =
            message_.fresh_ids(fresh_id_index++);
        linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
            ir_context, spv::Op::OpCompositeExtract,
            ir_context->get_type_mgr()->GetId(matrix_1_column_component_type),
            matrix_1_column_component_id,
            opt::Instruction::OperandList(
                {{SPV_OPERAND_TYPE_ID, {matrix_1_column_id}},
                 {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}})));

        // Extracts matrix 2 column component.
        uint32_t matrix_2_column_component_id =
            message_.fresh_ids(fresh_id_index++);
        linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
            ir_context, spv::Op::OpCompositeExtract,
            ir_context->get_type_mgr()->GetId(matrix_1_column_component_type),
            matrix_2_column_component_id,
            opt::Instruction::OperandList(
                {{SPV_OPERAND_TYPE_ID, {matrix_2_column_id}},
                 {SPV_OPERAND_TYPE_LITERAL_INTEGER, {k}}})));

        // Multiplies corresponding matrix 1 and matrix 2 column components.
        float_multiplication_ids[k] = message_.fresh_ids(fresh_id_index++);
        linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
            ir_context, spv::Op::OpFMul,
            ir_context->get_type_mgr()->GetId(matrix_1_column_component_type),
            float_multiplication_ids[k],
            opt::Instruction::OperandList(
                {{SPV_OPERAND_TYPE_ID, {matrix_1_column_component_id}},
                 {SPV_OPERAND_TYPE_ID, {matrix_2_column_component_id}}})));
      }

      // Adds the multiplication results.
      std::vector<uint32_t> float_add_ids;
      uint32_t float_add_id = message_.fresh_ids(fresh_id_index++);
      float_add_ids.push_back(float_add_id);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFAdd,
          ir_context->get_type_mgr()->GetId(matrix_1_column_component_type),
          float_add_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}},
               {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}})));
      for (uint32_t k = 2; k < float_multiplication_ids.size(); k++) {
        float_add_id = message_.fresh_ids(fresh_id_index++);
        float_add_ids.push_back(float_add_id);
        linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
            ir_context, spv::Op::OpFAdd,
            ir_context->get_type_mgr()->GetId(matrix_1_column_component_type),
            float_add_id,
            opt::Instruction::OperandList(
                {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[k]}},
                 {SPV_OPERAND_TYPE_ID, {float_add_ids[k - 2]}}})));
      }

      column_component_ids[j] = float_add_ids.back();
    }

    // Inserts the resulting matrix column.
    opt::Instruction::OperandList in_operands;
    for (auto& column_component_id : column_component_ids) {
      in_operands.push_back({SPV_OPERAND_TYPE_ID, {column_component_id}});
    }
    result_column_ids[i] = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeConstruct,
        ir_context->get_type_mgr()->GetId(matrix_1_column_type),
        result_column_ids[i], opt::Instruction::OperandList(in_operands)));
  }

  // The OpMatrixTimesMatrix instruction is changed to an OpCompositeConstruct
  // instruction.
  linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct);
  linear_algebra_instruction->SetInOperand(0, {result_column_ids[0]});
  linear_algebra_instruction->SetInOperand(1, {result_column_ids[1]});
  for (uint32_t i = 2; i < result_column_ids.size(); i++) {
    linear_algebra_instruction->AddOperand(
        {SPV_OPERAND_TYPE_ID, {result_column_ids[i]}});
  }

  fuzzerutil::UpdateModuleIdBound(
      ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1));
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpOuterProduct(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets vector 1 information.
  auto vector_1_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  uint32_t vector_1_component_count =
      ir_context->get_type_mgr()
          ->GetType(vector_1_instruction->type_id())
          ->AsVector()
          ->element_count();
  auto vector_1_component_type = ir_context->get_type_mgr()
                                     ->GetType(vector_1_instruction->type_id())
                                     ->AsVector()
                                     ->element_type();

  // Gets vector 2 information.
  auto vector_2_instruction = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(1));
  uint32_t vector_2_component_count =
      ir_context->get_type_mgr()
          ->GetType(vector_2_instruction->type_id())
          ->AsVector()
          ->element_count();

  uint32_t fresh_id_index = 0;
  std::vector<uint32_t> result_column_ids(vector_2_component_count);
  for (uint32_t i = 0; i < vector_2_component_count; i++) {
    // Extracts |vector_2| component.
    uint32_t vector_2_component_id = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        ir_context->get_type_mgr()->GetId(vector_1_component_type),
        vector_2_component_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector_2_instruction->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

    std::vector<uint32_t> column_component_ids(vector_1_component_count);
    for (uint32_t j = 0; j < vector_1_component_count; j++) {
      // Extracts |vector_1| component.
      uint32_t vector_1_component_id = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpCompositeExtract,
          ir_context->get_type_mgr()->GetId(vector_1_component_type),
          vector_1_component_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {vector_1_instruction->result_id()}},
               {SPV_OPERAND_TYPE_LITERAL_INTEGER, {j}}})));

      // Multiplies |vector_1| and |vector_2| components.
      column_component_ids[j] = message_.fresh_ids(fresh_id_index++);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFMul,
          ir_context->get_type_mgr()->GetId(vector_1_component_type),
          column_component_ids[j],
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {vector_2_component_id}},
               {SPV_OPERAND_TYPE_ID, {vector_1_component_id}}})));
    }

    // Inserts the resulting matrix column.
    opt::Instruction::OperandList in_operands;
    for (auto& column_component_id : column_component_ids) {
      in_operands.push_back({SPV_OPERAND_TYPE_ID, {column_component_id}});
    }
    result_column_ids[i] = message_.fresh_ids(fresh_id_index++);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeConstruct,
        vector_1_instruction->type_id(), result_column_ids[i], in_operands));
  }

  // The OpOuterProduct instruction is changed to an OpCompositeConstruct
  // instruction.
  linear_algebra_instruction->SetOpcode(spv::Op::OpCompositeConstruct);
  linear_algebra_instruction->SetInOperand(0, {result_column_ids[0]});
  linear_algebra_instruction->SetInOperand(1, {result_column_ids[1]});
  for (uint32_t i = 2; i < result_column_ids.size(); i++) {
    linear_algebra_instruction->AddOperand(
        {SPV_OPERAND_TYPE_ID, {result_column_ids[i]}});
  }

  fuzzerutil::UpdateModuleIdBound(
      ir_context, message_.fresh_ids(message_.fresh_ids().size() - 1));
}

void TransformationReplaceLinearAlgebraInstruction::ReplaceOpDot(
    opt::IRContext* ir_context,
    opt::Instruction* linear_algebra_instruction) const {
  // Gets OpDot in operands.
  auto vector_1 = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(0));
  auto vector_2 = ir_context->get_def_use_mgr()->GetDef(
      linear_algebra_instruction->GetSingleWordInOperand(1));

  uint32_t vectors_component_count = ir_context->get_type_mgr()
                                         ->GetType(vector_1->type_id())
                                         ->AsVector()
                                         ->element_count();
  std::vector<uint32_t> float_multiplication_ids(vectors_component_count);
  uint32_t fresh_id_index = 0;

  for (uint32_t i = 0; i < vectors_component_count; i++) {
    // Extracts |vector_1| component.
    uint32_t vector_1_extract_id = message_.fresh_ids(fresh_id_index++);
    fuzzerutil::UpdateModuleIdBound(ir_context, vector_1_extract_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        linear_algebra_instruction->type_id(), vector_1_extract_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector_1->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

    // Extracts |vector_2| component.
    uint32_t vector_2_extract_id = message_.fresh_ids(fresh_id_index++);
    fuzzerutil::UpdateModuleIdBound(ir_context, vector_2_extract_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpCompositeExtract,
        linear_algebra_instruction->type_id(), vector_2_extract_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector_2->result_id()}},
             {SPV_OPERAND_TYPE_LITERAL_INTEGER, {i}}})));

    // Multiplies the pair of components.
    float_multiplication_ids[i] = message_.fresh_ids(fresh_id_index++);
    fuzzerutil::UpdateModuleIdBound(ir_context, float_multiplication_ids[i]);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpFMul, linear_algebra_instruction->type_id(),
        float_multiplication_ids[i],
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {vector_1_extract_id}},
             {SPV_OPERAND_TYPE_ID, {vector_2_extract_id}}})));
  }

  // If the vector has 2 components, then there will be 2 float multiplication
  // instructions.
  if (vectors_component_count == 2) {
    linear_algebra_instruction->SetOpcode(spv::Op::OpFAdd);
    linear_algebra_instruction->SetInOperand(0, {float_multiplication_ids[0]});
    linear_algebra_instruction->SetInOperand(1, {float_multiplication_ids[1]});
  } else {
    // The first OpFAdd instruction has as operands the first two OpFMul
    // instructions.
    std::vector<uint32_t> float_add_ids;
    uint32_t float_add_id = message_.fresh_ids(fresh_id_index++);
    float_add_ids.push_back(float_add_id);
    fuzzerutil::UpdateModuleIdBound(ir_context, float_add_id);
    linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
        ir_context, spv::Op::OpFAdd, linear_algebra_instruction->type_id(),
        float_add_id,
        opt::Instruction::OperandList(
            {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[0]}},
             {SPV_OPERAND_TYPE_ID, {float_multiplication_ids[1]}}})));

    // The remaining OpFAdd instructions has as operands an OpFMul and an OpFAdd
    // instruction.
    for (uint32_t i = 2; i < float_multiplication_ids.size() - 1; i++) {
      float_add_id = message_.fresh_ids(fresh_id_index++);
      fuzzerutil::UpdateModuleIdBound(ir_context, float_add_id);
      float_add_ids.push_back(float_add_id);
      linear_algebra_instruction->InsertBefore(MakeUnique<opt::Instruction>(
          ir_context, spv::Op::OpFAdd, linear_algebra_instruction->type_id(),
          float_add_id,
          opt::Instruction::OperandList(
              {{SPV_OPERAND_TYPE_ID, {float_multiplication_ids[i]}},
               {SPV_OPERAND_TYPE_ID, {float_add_ids[i - 2]}}})));
    }

    // The last OpFAdd instruction is got by changing some of the OpDot
    // instruction attributes.
    linear_algebra_instruction->SetOpcode(spv::Op::OpFAdd);
    linear_algebra_instruction->SetInOperand(
        0, {float_multiplication_ids[float_multiplication_ids.size() - 1]});
    linear_algebra_instruction->SetInOperand(
        1, {float_add_ids[float_add_ids.size() - 1]});
  }
}

std::unordered_set<uint32_t>
TransformationReplaceLinearAlgebraInstruction::GetFreshIds() const {
  std::unordered_set<uint32_t> result;
  for (auto id : message_.fresh_ids()) {
    result.insert(id);
  }
  return result;
}

}  // namespace fuzz
}  // namespace spvtools