// Copyright (c) 2016 Google Inc.

//

// 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.

// This file contains utility functions for spv_parsed_operand_t.

#include "source/parsed_operand.h"

#include <cassert>

#include "source/util/hex_float.h"

namespace spvtools {

void EmitNumericLiteral(std::ostream* out, const spv_parsed_instruction_t& inst,

                        const spv_parsed_operand_t& operand) {

  if (operand.type != SPV_OPERAND_TYPE_LITERAL_INTEGER &&

      operand.type != SPV_OPERAND_TYPE_LITERAL_FLOAT &&

      operand.type != SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER &&

      operand.type != SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER &&

      operand.type != SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER)

    return;

  if (operand.num_words < 1) return;

  // TODO(dneto): Support more than 64-bits at a time.

  if (operand.num_words > 2) return;

  const uint32_t word = inst.words[operand.offset];

  if (operand.num_words == 1) {

    switch (operand.number_kind) {

      case SPV_NUMBER_SIGNED_INT:

        *out << int32_t(word);

        break;

      case SPV_NUMBER_UNSIGNED_INT:

        *out << word;

        break;

      case SPV_NUMBER_FLOATING:

        switch (operand.fp_encoding) {

          case SPV_FP_ENCODING_IEEE754_BINARY16:

            *out << spvtools::utils::FloatProxy<spvtools::utils::Float16>(

                uint16_t(word & 0xFFFF));

            break;

          case SPV_FP_ENCODING_IEEE754_BINARY32:

            *out << spvtools::utils::FloatProxy<float>(word);

            break;

          case SPV_FP_ENCODING_FLOAT8_E4M3:

            *out << spvtools::utils::FloatProxy<spvtools::utils::Float8_E4M3>(

                uint8_t(word & 0xFF));

            break;

          case SPV_FP_ENCODING_FLOAT8_E5M2:

            *out << spvtools::utils::FloatProxy<spvtools::utils::Float8_E5M2>(

                uint8_t(word & 0xFF));

            break;

          case SPV_FP_ENCODING_BFLOAT16:

            *out << spvtools::utils::FloatProxy<spvtools::utils::BFloat16>(

                uint16_t(word & 0xFFFF));

            break;

          case SPV_FP_ENCODING_UNKNOWN:

            switch (operand.number_bit_width) {

              case 16:

                *out << spvtools::utils::FloatProxy<spvtools::utils::Float16>(

                    uint16_t(word & 0xFFFF));

                break;

              case 32:

                *out << spvtools::utils::FloatProxy<float>(word);

                break;

            }

          default:

            break;

        }

        break;

      default:

        break;

    }

  } else if (operand.num_words == 2) {

    // Multi-word numbers are presented with lower order words first.

    uint64_t bits =

        uint64_t(word) | (uint64_t(inst.words[operand.offset + 1]) << 32);

    switch (operand.number_kind) {

      case SPV_NUMBER_SIGNED_INT:

        *out << int64_t(bits);

        break;

      case SPV_NUMBER_UNSIGNED_INT:

        *out << bits;

        break;

      case SPV_NUMBER_FLOATING:

        // Assume only 64-bit floats.

        *out << spvtools::utils::FloatProxy<double>(bits);

        break;

      default:

        break;

    }

  }

}

}  // namespace spvtools