/**
 ******************************************************************************
 * Xenia : Xbox 360 Emulator Research Project                                 *
 ******************************************************************************
 * Copyright 2020 Ben Vanik. All rights reserved.                             *
 * Released under the BSD license - see LICENSE in the root for more details. *
 ******************************************************************************
 */

#include "xenia/gpu/spirv_shader_translator.h"

#include <memory>

#include "third_party/glslang/SPIRV/GLSL.std.450.h"
#include "xenia/base/assert.h"
#include "xenia/base/math.h"

namespace xe {
namespace gpu {

void SpirvShaderTranslator::ProcessAluInstruction(
    const ParsedAluInstruction& instr) {
  if (instr.IsNop()) {
    // Don't even disassemble or update predication.
    return;
  }

  UpdateInstructionPredication(instr.is_predicated, instr.predicate_condition);

  // Floating-point arithmetic operations (addition, subtraction, negation,
  // multiplication, division, modulo - see isArithmeticOperation in
  // propagateNoContraction of glslang; though for some reason it's not applied
  // to SPIR-V OpDot, at least in the February 16, 2020 version installed on
  // http://shader-playground.timjones.io/) must have the NoContraction
  // decoration to prevent reordering to make sure floating-point calculations
  // are optimized predictably and exactly the same in different shaders to
  // allow for multipass rendering (in addition to the Invariant decoration on
  // outputs).

  // Whether the instruction has changed the predicate, and it needs to be
  // checked again later.
  bool predicate_written_vector = false;
  spv::Id vector_result =
      ProcessVectorAluOperation(instr, predicate_written_vector);
  // TODO(Triang3l): Process the ALU scalar operation.

  StoreResult(instr.vector_and_constant_result, vector_result);

  if (predicate_written_vector) {
    cf_exec_predicate_written_ = true;
    CloseInstructionPredication();
  }
}

spv::Id SpirvShaderTranslator::ProcessVectorAluOperation(
    const ParsedAluInstruction& instr, bool& predicate_written) {
  predicate_written = false;

  uint32_t used_result_components =
      instr.vector_and_constant_result.GetUsedResultComponents();
  if (!used_result_components &&
      !AluVectorOpHasSideEffects(instr.vector_opcode)) {
    return spv::NoResult;
  }
  uint32_t used_result_component_count = xe::bit_count(used_result_components);

  // Load operand storage without swizzle and sign modifiers.
  // A small shortcut, operands of cube are the same, but swizzled.
  uint32_t operand_count;
  if (instr.vector_opcode == ucode::AluVectorOpcode::kCube) {
    operand_count = 1;
  } else {
    operand_count = instr.vector_operand_count;
  }
  spv::Id operand_storage[3] = {};
  for (uint32_t i = 0; i < operand_count; ++i) {
    operand_storage[i] = LoadOperandStorage(instr.vector_operands[i]);
  }
  spv::Id result_type =
      used_result_component_count
          ? type_float_vectors_[used_result_component_count - 1]
          : spv::NoType;

  // In case the paired scalar instruction (if processed first) terminates the
  // block (like via OpKill).
  EnsureBuildPointAvailable();

  // Lookup table for variants of instructions with similar structure.
  static const unsigned int kOps[] = {
      static_cast<unsigned int>(spv::OpNop),                   // kAdd
      static_cast<unsigned int>(spv::OpNop),                   // kMul
      static_cast<unsigned int>(spv::OpFOrdGreaterThanEqual),  // kMax
      static_cast<unsigned int>(spv::OpFOrdLessThan),          // kMin
      static_cast<unsigned int>(spv::OpFOrdEqual),             // kSeq
      static_cast<unsigned int>(spv::OpFOrdGreaterThan),       // kSgt
      static_cast<unsigned int>(spv::OpFOrdGreaterThanEqual),  // kSge
      static_cast<unsigned int>(spv::OpFUnordNotEqual),        // kSne
      static_cast<unsigned int>(GLSLstd450Fract),              // kFrc
      static_cast<unsigned int>(GLSLstd450Trunc),              // kTrunc
      static_cast<unsigned int>(GLSLstd450Floor),              // kFloor
      static_cast<unsigned int>(spv::OpNop),                   // kMad
      static_cast<unsigned int>(spv::OpFOrdEqual),             // kCndEq
      static_cast<unsigned int>(spv::OpFOrdGreaterThanEqual),  // kCndGe
      static_cast<unsigned int>(spv::OpFOrdGreaterThan),       // kCndGt
      static_cast<unsigned int>(spv::OpNop),                   // kDp4
      static_cast<unsigned int>(spv::OpNop),                   // kDp3
      static_cast<unsigned int>(spv::OpNop),                   // kDp2Add
      static_cast<unsigned int>(spv::OpNop),                   // kCube
      static_cast<unsigned int>(spv::OpNop),                   // kMax4
      static_cast<unsigned int>(spv::OpFOrdEqual),             // kSetpEqPush
      static_cast<unsigned int>(spv::OpFUnordNotEqual),        // kSetpNePush
      static_cast<unsigned int>(spv::OpFOrdGreaterThan),       // kSetpGtPush
      static_cast<unsigned int>(spv::OpFOrdGreaterThanEqual),  // kSetpGePush
      static_cast<unsigned int>(spv::OpFOrdEqual),             // kKillEq
      static_cast<unsigned int>(spv::OpFOrdGreaterThan),       // kKillGt
      static_cast<unsigned int>(spv::OpFOrdGreaterThanEqual),  // kKillGe
      static_cast<unsigned int>(spv::OpFUnordNotEqual),        // kKillNe
      static_cast<unsigned int>(spv::OpNop),                   // kDst
      static_cast<unsigned int>(spv::OpNop),                   // kMaxA
  };

  switch (instr.vector_opcode) {
    case ucode::AluVectorOpcode::kAdd: {
      spv::Id result = builder_->createBinOp(
          spv::OpFAdd, result_type,
          GetOperandComponents(operand_storage[0], instr.vector_operands[0],
                               used_result_components),
          GetOperandComponents(operand_storage[1], instr.vector_operands[1],
                               used_result_components));
      builder_->addDecoration(result, spv::DecorationNoContraction);
      return result;
    }
    case ucode::AluVectorOpcode::kMul:
    case ucode::AluVectorOpcode::kMad: {
      spv::Id multiplicands[2];
      for (uint32_t i = 0; i < 2; ++i) {
        multiplicands[i] =
            GetOperandComponents(operand_storage[i], instr.vector_operands[i],
                                 used_result_components);
      }
      spv::Id result = builder_->createBinOp(
          spv::OpFMul, result_type, multiplicands[0], multiplicands[1]);
      builder_->addDecoration(result, spv::DecorationNoContraction);
      uint32_t multiplicands_different =
          used_result_components &
          ~instr.vector_operands[0].GetIdenticalComponents(
              instr.vector_operands[1]);
      if (multiplicands_different) {
        // Shader Model 3: +0 or denormal * anything = +-0.
        spv::Id different_operands[2] = {multiplicands[0], multiplicands[1]};
        spv::Id different_result = result;
        uint32_t different_count = xe::bit_count(multiplicands_different);
        spv::Id different_type = type_float_vectors_[different_count - 1];
        // Extract the different components, if not all are different.
        if (multiplicands_different != used_result_components) {
          uint_vector_temp_.clear();
          uint_vector_temp_.reserve(different_count);
          uint32_t components_remaining = used_result_components;
          for (uint32_t i = 0; i < used_result_component_count; ++i) {
            uint32_t component;
            xe::bit_scan_forward(components_remaining, &component);
            components_remaining &= ~(1 << component);
            if (multiplicands_different & (1 << component)) {
              uint_vector_temp_.push_back(i);
            }
          }
          assert_true(uint_vector_temp_.size() == different_count);
          if (different_count > 1) {
            for (uint32_t i = 0; i < 2; ++i) {
              different_operands[i] = builder_->createRvalueSwizzle(
                  spv::NoPrecision, different_type, different_operands[i],
                  uint_vector_temp_);
            }
            different_result = builder_->createRvalueSwizzle(
                spv::NoPrecision, different_type, different_result,
                uint_vector_temp_);
          } else {
            for (uint32_t i = 0; i < 2; ++i) {
              different_operands[i] = builder_->createCompositeExtract(
                  different_operands[i], different_type, uint_vector_temp_[0]);
            }
            different_result = builder_->createCompositeExtract(
                different_result, different_type, uint_vector_temp_[0]);
          }
        }
        // Check if the different components in any of the operands are zero,
        // even if the other is NaN - if min(|a|, |b|) is 0.
        for (uint32_t i = 0; i < 2; ++i) {
          if (instr.vector_operands[i].is_absolute_value &&
              !instr.vector_operands[i].is_negated) {
            continue;
          }
          id_vector_temp_.clear();
          id_vector_temp_.push_back(different_operands[i]);
          different_operands[i] = builder_->createBuiltinCall(
              different_type, ext_inst_glsl_std_450_, GLSLstd450FAbs,
              id_vector_temp_);
        }
        id_vector_temp_.clear();
        id_vector_temp_.reserve(2);
        id_vector_temp_.push_back(different_operands[0]);
        id_vector_temp_.push_back(different_operands[1]);
        spv::Id different_abs_min =
            builder_->createBuiltinCall(different_type, ext_inst_glsl_std_450_,
                                        GLSLstd450NMin, id_vector_temp_);
        spv::Id different_zero = builder_->createBinOp(
            spv::OpFOrdEqual, type_bool_vectors_[different_count - 1],
            different_abs_min, const_float_vectors_0_[different_count - 1]);
        // Replace with +0.
        different_result = builder_->createTriOp(
            spv::OpSelect, different_type, different_zero,
            const_float_vectors_0_[different_count - 1], different_result);
        // Insert the different components back to the result.
        if (multiplicands_different != used_result_components) {
          if (different_count > 1) {
            std::unique_ptr<spv::Instruction> shuffle_op =
                std::make_unique<spv::Instruction>(
                    builder_->getUniqueId(), result_type, spv::OpVectorShuffle);
            shuffle_op->addIdOperand(result);
            shuffle_op->addIdOperand(different_result);
            uint32_t components_remaining = used_result_components;
            unsigned int different_shuffle_index = used_result_component_count;
            for (uint32_t i = 0; i < used_result_component_count; ++i) {
              uint32_t component;
              xe::bit_scan_forward(components_remaining, &component);
              components_remaining &= ~(1 << component);
              shuffle_op->addImmediateOperand(
                  (multiplicands_different & (1 << component))
                      ? different_shuffle_index++
                      : i);
            }
            result = shuffle_op->getResultId();
            builder_->getBuildPoint()->addInstruction(std::move(shuffle_op));
          } else {
            result = builder_->createCompositeInsert(
                different_result, result, result_type,
                xe::bit_count(used_result_components &
                              (multiplicands_different - 1)));
          }
        } else {
          result = different_result;
        }
      }
      if (instr.vector_opcode == ucode::AluVectorOpcode::kMad) {
        // Not replacing true `0 + term` with conditional selection of the term
        // because +0 + -0 should result in +0, not -0.
        result = builder_->createBinOp(
            spv::OpFAdd, result_type, result,
            GetOperandComponents(operand_storage[2], instr.vector_operands[2],
                                 used_result_components));
        builder_->addDecoration(result, spv::DecorationNoContraction);
      }
      return result;
    }

    case ucode::AluVectorOpcode::kMax:
    case ucode::AluVectorOpcode::kMin: {
      spv::Id operand_0 = GetOperandComponents(
          operand_storage[0], instr.vector_operands[0], used_result_components);
      // max is commonly used as mov.
      uint32_t identical = instr.vector_operands[0].GetIdenticalComponents(
                               instr.vector_operands[1]) &
                           used_result_components;
      if (identical == used_result_components) {
        // All components are identical - mov.
        return operand_0;
      }
      spv::Id operand_1 = GetOperandComponents(
          operand_storage[1], instr.vector_operands[1], used_result_components);
      // Shader Model 3 NaN behavior (a op b ? a : b, not SPIR-V FMax/FMin which
      // are undefined for NaN or NMax/NMin which return the non-NaN operand).
      spv::Op op = spv::Op(kOps[size_t(instr.vector_opcode)]);
      if (!identical) {
        // All components are different - max/min of the scalars or the entire
        // vectors.
        return builder_->createTriOp(
            spv::OpSelect, result_type,
            builder_->createBinOp(
                op, type_bool_vectors_[used_result_component_count - 1],
                operand_0, operand_1),
            operand_0, operand_1);
      }
      // Mixed identical and different components.
      assert_true(used_result_component_count > 1);
      id_vector_temp_.clear();
      id_vector_temp_.reserve(used_result_component_count);
      uint32_t components_remaining = used_result_components;
      for (uint32_t i = 0; i < used_result_component_count; ++i) {
        spv::Id result_component =
            builder_->createCompositeExtract(operand_0, type_float_, i);
        uint32_t component_index;
        xe::bit_scan_forward(components_remaining, &component_index);
        components_remaining &= ~(1 << component_index);
        if (!(identical & (1 << component_index))) {
          spv::Id operand_1_component =
              builder_->createCompositeExtract(operand_1, type_float_, i);
          result_component = builder_->createTriOp(
              spv::OpSelect, type_float_,
              builder_->createBinOp(op, type_bool_, result_component,
                                    operand_1_component),
              result_component, operand_1_component);
        }
        id_vector_temp_.push_back(result_component);
      }
      return builder_->createCompositeConstruct(result_type, id_vector_temp_);
    }

    case ucode::AluVectorOpcode::kSeq:
    case ucode::AluVectorOpcode::kSgt:
    case ucode::AluVectorOpcode::kSge:
    case ucode::AluVectorOpcode::kSne:
      return builder_->createTriOp(
          spv::OpSelect, result_type,
          builder_->createBinOp(
              spv::Op(kOps[size_t(instr.vector_opcode)]),
              type_bool_vectors_[used_result_component_count - 1],
              GetOperandComponents(operand_storage[0], instr.vector_operands[0],
                                   used_result_components),
              GetOperandComponents(operand_storage[1], instr.vector_operands[1],
                                   used_result_components)),
          const_float_vectors_1_[used_result_component_count - 1],
          const_float_vectors_0_[used_result_component_count - 1]);

    case ucode::AluVectorOpcode::kFrc:
    case ucode::AluVectorOpcode::kTrunc:
    case ucode::AluVectorOpcode::kFloor:
      id_vector_temp_.clear();
      id_vector_temp_.push_back(GetOperandComponents(operand_storage[0],
                                                     instr.vector_operands[0],
                                                     used_result_components));
      return builder_->createBuiltinCall(
          result_type, ext_inst_glsl_std_450_,
          GLSLstd450(kOps[size_t(instr.vector_opcode)]), id_vector_temp_);

    case ucode::AluVectorOpcode::kCndEq:
    case ucode::AluVectorOpcode::kCndGe:
    case ucode::AluVectorOpcode::kCndGt:
      return builder_->createTriOp(
          spv::OpSelect, result_type,
          builder_->createBinOp(
              spv::Op(kOps[size_t(instr.vector_opcode)]),
              type_bool_vectors_[used_result_component_count - 1],
              GetOperandComponents(operand_storage[0], instr.vector_operands[0],
                                   used_result_components),
              const_float_vectors_0_[used_result_component_count - 1]),
          GetOperandComponents(operand_storage[1], instr.vector_operands[1],
                               used_result_components),
          GetOperandComponents(operand_storage[2], instr.vector_operands[2],
                               used_result_components));

    case ucode::AluVectorOpcode::kDp4:
    case ucode::AluVectorOpcode::kDp3:
    case ucode::AluVectorOpcode::kDp2Add: {
      // Not using OpDot for predictable optimization (especially addition
      // order) and NoContraction (which, for some reason, isn't placed on dot
      // in glslang as of the February 16, 2020 version).
      uint32_t component_count;
      if (instr.vector_opcode == ucode::AluVectorOpcode::kDp2Add) {
        component_count = 2;
      } else if (instr.vector_opcode == ucode::AluVectorOpcode::kDp3) {
        component_count = 3;
      } else {
        component_count = 4;
      }
      uint32_t component_mask = (1 << component_count) - 1;
      spv::Id operands[2];
      for (uint32_t i = 0; i < 2; ++i) {
        operands[i] = GetOperandComponents(
            operand_storage[i], instr.vector_operands[i], component_mask);
      }
      uint32_t different =
          component_mask & ~instr.vector_operands[0].GetIdenticalComponents(
                               instr.vector_operands[1]);
      spv::Id result = spv::NoResult;
      for (uint32_t i = 0; i < component_count; ++i) {
        spv::Id operand_components[2];
        for (unsigned int j = 0; j < 2; ++j) {
          operand_components[j] =
              builder_->createCompositeExtract(operands[j], type_float_, i);
        }
        spv::Id product =
            builder_->createBinOp(spv::OpFMul, type_float_,
                                  operand_components[0], operand_components[1]);
        builder_->addDecoration(product, spv::DecorationNoContraction);
        if (different & (1 << i)) {
          // Shader Model 3: +0 or denormal * anything = +-0.
          // Check if the different components in any of the operands are zero,
          // even if the other is NaN - if min(|a|, |b|) is 0.
          for (uint32_t j = 0; j < 2; ++j) {
            if (instr.vector_operands[j].is_absolute_value &&
                !instr.vector_operands[j].is_negated) {
              continue;
            }
            id_vector_temp_.clear();
            id_vector_temp_.push_back(operand_components[j]);
            operand_components[j] =
                builder_->createBuiltinCall(type_float_, ext_inst_glsl_std_450_,
                                            GLSLstd450FAbs, id_vector_temp_);
          }
          id_vector_temp_.clear();
          id_vector_temp_.reserve(2);
          id_vector_temp_.push_back(operand_components[0]);
          id_vector_temp_.push_back(operand_components[1]);
          product = builder_->createTriOp(
              spv::OpSelect, type_float_,
              builder_->createBinOp(spv::OpFOrdEqual, type_bool_,
                                    builder_->createBuiltinCall(
                                        type_float_, ext_inst_glsl_std_450_,
                                        GLSLstd450NMin, id_vector_temp_),
                                    const_float_0_),
              const_float_0_, product);
        }
        if (!i) {
          result = product;
          continue;
        }
        result =
            builder_->createBinOp(spv::OpFAdd, type_float_, result, product);
        builder_->addDecoration(result, spv::DecorationNoContraction);
      }
      if (instr.vector_opcode == ucode::AluVectorOpcode::kDp2Add) {
        result = builder_->createBinOp(
            spv::OpFAdd, type_float_, result,
            GetOperandComponents(operand_storage[2], instr.vector_operands[2],
                                 0b0001));
        builder_->addDecoration(result, spv::DecorationNoContraction);
      }
      return result;
    }

    case ucode::AluVectorOpcode::kCube: {
      // operands[0] is .z_xy.
      // Result is T coordinate, S coordinate, 2 * major axis, face ID.
      // Skipping the second component of the operand, so 120, not 230.
      spv::Id operand_vector = GetOperandComponents(
          operand_storage[0], instr.vector_operands[0], 0b1101);
      // Remapped from ZXY (Z_XY without the skipped component) to XYZ.
      spv::Id operand[3];
      for (unsigned int i = 0; i < 3; ++i) {
        operand[i] = builder_->createCompositeExtract(operand_vector,
                                                      type_float_, (i + 1) % 3);
      }
      spv::Id operand_abs[3];
      if (!instr.vector_operands[0].is_absolute_value ||
          instr.vector_operands[0].is_negated) {
        for (unsigned int i = 0; i < 3; ++i) {
          id_vector_temp_.clear();
          id_vector_temp_.push_back(operand[i]);
          operand_abs[i] =
              builder_->createBuiltinCall(type_float_, ext_inst_glsl_std_450_,
                                          GLSLstd450FAbs, id_vector_temp_);
        }
      } else {
        for (unsigned int i = 0; i < 3; ++i) {
          operand_abs[i] = operand[i];
        }
      }
      spv::Id operand_neg[3] = {};
      if (used_result_components & 0b0001) {
        operand_neg[1] =
            builder_->createUnaryOp(spv::OpFNegate, type_float_, operand[1]);
        builder_->addDecoration(operand_neg[1], spv::DecorationNoContraction);
      }
      if (used_result_components & 0b0010) {
        operand_neg[0] =
            builder_->createUnaryOp(spv::OpFNegate, type_float_, operand[0]);
        builder_->addDecoration(operand_neg[0], spv::DecorationNoContraction);
        operand_neg[2] =
            builder_->createUnaryOp(spv::OpFNegate, type_float_, operand[2]);
        builder_->addDecoration(operand_neg[2], spv::DecorationNoContraction);
      }

      // Check if the major axis is Z (abs(z) >= abs(x) && abs(z) >= abs(y)).
      // Selection merge must be the penultimate instruction in the block, check
      // the condition before it.
      spv::Id ma_z_condition = builder_->createBinOp(
          spv::OpLogicalAnd, type_bool_,
          builder_->createBinOp(spv::OpFOrdGreaterThanEqual, type_bool_,
                                operand_abs[2], operand_abs[0]),
          builder_->createBinOp(spv::OpFOrdGreaterThanEqual, type_bool_,
                                operand_abs[2], operand_abs[1]));
      spv::Function& function = builder_->getBuildPoint()->getParent();
      spv::Block& ma_z_block = builder_->makeNewBlock();
      spv::Block& ma_yx_block = builder_->makeNewBlock();
      spv::Block* ma_merge_block =
          new spv::Block(builder_->getUniqueId(), function);
      {
        std::unique_ptr<spv::Instruction> selection_merge_op =
            std::make_unique<spv::Instruction>(spv::OpSelectionMerge);
        selection_merge_op->addIdOperand(ma_merge_block->getId());
        selection_merge_op->addImmediateOperand(spv::SelectionControlMaskNone);
        builder_->getBuildPoint()->addInstruction(
            std::move(selection_merge_op));
      }
      builder_->createConditionalBranch(ma_z_condition, &ma_z_block,
                                        &ma_yx_block);

      builder_->setBuildPoint(&ma_z_block);
      // The major axis is Z.
      spv::Id ma_z_result[4] = {};
      // tc = -y
      ma_z_result[0] = operand_neg[1];
      // ma/2 = z
      ma_z_result[2] = operand[2];
      if (used_result_components & 0b1010) {
        spv::Id z_is_neg = builder_->createBinOp(
            spv::OpFOrdLessThan, type_bool_, operand[2], const_float_0_);
        if (used_result_components & 0b0010) {
          // sc = z < 0.0 ? -x : x
          ma_z_result[1] = builder_->createTriOp(
              spv::OpSelect, type_float_, z_is_neg, operand_neg[0], operand[0]);
        }
        if (used_result_components & 0b1000) {
          // id = z < 0.0 ? 5.0 : 4.0
          ma_z_result[3] =
              builder_->createTriOp(spv::OpSelect, type_float_, z_is_neg,
                                    builder_->makeFloatConstant(5.0f),
                                    builder_->makeFloatConstant(4.0f));
        }
      }
      builder_->createBranch(ma_merge_block);

      builder_->setBuildPoint(&ma_yx_block);
      // The major axis is not Z - create an inner conditional to check if the
      // major axis is Y (abs(y) >= abs(x)).
      // Selection merge must be the penultimate instruction in the block, check
      // the condition before it.
      spv::Id ma_y_condition =
          builder_->createBinOp(spv::OpFOrdGreaterThanEqual, type_bool_,
                                operand_abs[1], operand_abs[0]);
      spv::Block& ma_y_block = builder_->makeNewBlock();
      spv::Block& ma_x_block = builder_->makeNewBlock();
      spv::Block& ma_yx_merge_block = builder_->makeNewBlock();
      {
        std::unique_ptr<spv::Instruction> selection_merge_op =
            std::make_unique<spv::Instruction>(spv::OpSelectionMerge);
        selection_merge_op->addIdOperand(ma_yx_merge_block.getId());
        selection_merge_op->addImmediateOperand(spv::SelectionControlMaskNone);
        builder_->getBuildPoint()->addInstruction(
            std::move(selection_merge_op));
      }
      builder_->createConditionalBranch(ma_y_condition, &ma_y_block,
                                        &ma_x_block);

      builder_->setBuildPoint(&ma_y_block);
      // The major axis is Y.
      spv::Id ma_y_result[4] = {};
      // sc = x
      ma_y_result[1] = operand[0];
      // ma/2 = y
      ma_y_result[2] = operand[1];
      if (used_result_components & 0b1001) {
        spv::Id y_is_neg = builder_->createBinOp(
            spv::OpFOrdLessThan, type_bool_, operand[1], const_float_0_);
        if (used_result_components & 0b0001) {
          // tc = y < 0.0 ? -z : z
          ma_y_result[0] = builder_->createTriOp(
              spv::OpSelect, type_float_, y_is_neg, operand_neg[2], operand[2]);
          // id = y < 0.0 ? 3.0 : 2.0
          ma_y_result[3] =
              builder_->createTriOp(spv::OpSelect, type_float_, y_is_neg,
                                    builder_->makeFloatConstant(3.0f),
                                    builder_->makeFloatConstant(2.0f));
        }
      }
      builder_->createBranch(&ma_yx_merge_block);

      builder_->setBuildPoint(&ma_x_block);
      // The major axis is X.
      spv::Id ma_x_result[4] = {};
      // tc = -y
      ma_x_result[0] = operand_neg[1];
      // ma/2 = x
      ma_x_result[2] = operand[2];
      if (used_result_components & 0b1010) {
        spv::Id x_is_neg = builder_->createBinOp(
            spv::OpFOrdLessThan, type_bool_, operand[0], const_float_0_);
        if (used_result_components & 0b0010) {
          // sc = x < 0.0 ? z : -z
          ma_x_result[1] = builder_->createTriOp(
              spv::OpSelect, type_float_, x_is_neg, operand[2], operand_neg[2]);
        }
        if (used_result_components & 0b1000) {
          // id = x < 0.0 ? 1.0 : 0.0
          ma_x_result[3] =
              builder_->createTriOp(spv::OpSelect, type_float_, x_is_neg,
                                    const_float_1_, const_float_0_);
        }
      }
      builder_->createBranch(&ma_yx_merge_block);

      builder_->setBuildPoint(&ma_yx_merge_block);
      // The major axis is Y or X - choose the options of the result from Y and
      // X.
      spv::Id ma_yx_result[4] = {};
      for (uint32_t i = 0; i < 4; ++i) {
        if (!(used_result_components & (1 << i))) {
          continue;
        }
        std::unique_ptr<spv::Instruction> phi_op =
            std::make_unique<spv::Instruction>(builder_->getUniqueId(),
                                               type_float_, spv::OpPhi);
        phi_op->addIdOperand(ma_y_result[i]);
        phi_op->addIdOperand(ma_y_block.getId());
        phi_op->addIdOperand(ma_x_result[i]);
        phi_op->addIdOperand(ma_x_block.getId());
        ma_yx_result[i] = phi_op->getResultId();
        builder_->getBuildPoint()->addInstruction(std::move(phi_op));
      }
      builder_->createBranch(ma_merge_block);

      function.addBlock(ma_merge_block);
      builder_->setBuildPoint(ma_merge_block);
      // Choose the result options from Z and YX cases.
      id_vector_temp_.clear();
      id_vector_temp_.reserve(used_result_component_count);
      for (uint32_t i = 0; i < 4; ++i) {
        if (!(used_result_components & (1 << i))) {
          continue;
        }
        std::unique_ptr<spv::Instruction> phi_op =
            std::make_unique<spv::Instruction>(builder_->getUniqueId(),
                                               type_float_, spv::OpPhi);
        phi_op->addIdOperand(ma_z_result[i]);
        phi_op->addIdOperand(ma_z_block.getId());
        phi_op->addIdOperand(ma_yx_result[i]);
        phi_op->addIdOperand(ma_yx_merge_block.getId());
        id_vector_temp_.push_back(phi_op->getResultId());
        builder_->getBuildPoint()->addInstruction(std::move(phi_op));
      }
      assert_true(id_vector_temp_.size() == used_result_component_count);
      if (used_result_component_count == 1) {
        // Only one component - not composite.
        return id_vector_temp_[0];
      }
      return builder_->createCompositeConstruct(
          type_float_vectors_[used_result_component_count - 1],
          id_vector_temp_);
    }

    // TODO(Triang3l): Handle all instructions.
    default:
      break;
  }

  // Invalid instruction.
  return spv::NoResult;
}

}  // namespace gpu
}  // namespace xe