source/parsed_operand.cpp

   1 // Copyright (c) 2016 Google Inc.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 // This file contains utility functions for spv_parsed_operand_t.
  16
  17 #include "source/parsed_operand.h"
  18
  19 #include <cassert>
  20 #include "source/util/hex_float.h"
  21
  22 namespace spvtools {
  23
  24 void EmitNumericLiteral(std::ostream* out, const spv_parsed_instruction_t& inst,
  25                         const spv_parsed_operand_t& operand) {
  26   if (operand.type != SPV_OPERAND_TYPE_LITERAL_INTEGER &&
  27       operand.type != SPV_OPERAND_TYPE_LITERAL_FLOAT &&
  28       operand.type != SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER &&
  29       operand.type != SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER &&
  30       operand.type != SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER)
  31     return;
  32   if (operand.num_words < 1) return;
  33   // TODO(dneto): Support more than 64-bits at a time.
  34   if (operand.num_words > 2) return;
  35
  36   const uint32_t word = inst.words[operand.offset];
  37   if (operand.num_words == 1) {
  38     switch (operand.number_kind) {
  39       case SPV_NUMBER_SIGNED_INT:
  40         *out << int32_t(word);
  41         break;
  42       case SPV_NUMBER_UNSIGNED_INT:
  43         *out << word;
  44         break;
  45       case SPV_NUMBER_FLOATING:
  46         if (operand.number_bit_width == 16) {
  47           *out << spvtools::utils::FloatProxy<spvtools::utils::Float16>(
  48               uint16_t(word & 0xFFFF));
  49         } else {
  50           // Assume 32-bit floats.
  51           *out << spvtools::utils::FloatProxy<float>(word);
  52         }
  53         break;
  54       default:
  55         break;
  56     }
  57   } else if (operand.num_words == 2) {
  58     // Multi-word numbers are presented with lower order words first.
  59     uint64_t bits =
  60         uint64_t(word) | (uint64_t(inst.words[operand.offset + 1]) << 32);
  61     switch (operand.number_kind) {
  62       case SPV_NUMBER_SIGNED_INT:
  63         *out << int64_t(bits);
  64         break;
  65       case SPV_NUMBER_UNSIGNED_INT:
  66         *out << bits;
  67         break;
  68       case SPV_NUMBER_FLOATING:
  69         // Assume only 64-bit floats.
  70         *out << spvtools::utils::FloatProxy<double>(bits);
  71         break;
  72       default:
  73         break;
  74     }
  75   }
  76 }
  77 }  // namespace spvtools