Added HexFloat helper class to print out floating point numbers.

TODO Add double tests before we actually use this.

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6f65fb4..ee3f80e 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -104,6 +104,7 @@ set(SPIRV_SOURCES
   ${CMAKE_CURRENT_SOURCE_DIR}/include/libspirv/libspirv.h
   ${CMAKE_CURRENT_SOURCE_DIR}/include/util/bitutils.h
   ${CMAKE_CURRENT_SOURCE_DIR}/source/assembly_grammar.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/include/util/hex_float.h
   ${CMAKE_CURRENT_SOURCE_DIR}/source/binary.h
   ${CMAKE_CURRENT_SOURCE_DIR}/source/diagnostic.h
   ${CMAKE_CURRENT_SOURCE_DIR}/source/endian.h
@@ -190,6 +191,7 @@ if (NOT ${SPIRV_SKIP_EXECUTABLES})
       ${CMAKE_CURRENT_SOURCE_DIR}/test/ExtInstGLSLstd450.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/FixWord.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/GeneratorMagicNumber.cpp
+      ${CMAKE_CURRENT_SOURCE_DIR}/test/HexFloat.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/ImmediateInt.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/LibspirvMacros.cpp
       ${CMAKE_CURRENT_SOURCE_DIR}/test/NamedId.cpp

diff --git a/include/util/hex_float.h b/include/util/hex_float.h
new file mode 100644 (file)
index 0000000..1583bb8
--- /dev/null
+++ b/include/util/hex_float.h
@@ -0,0 +1,222 @@
+// Copyright (c) 2015 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#ifndef _LIBSPIRV_UTIL_HEX_FLOAT_H_
+#define _LIBSPIRV_UTIL_HEX_FLOAT_H_
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <iostream>
+#include <limits>
+
+#include "bitutils.h"
+
+namespace spvutils {
+
+// This is an example traits. It is not meant to be used in practice, but will
+// be the default for any non-specialized type.
+template <typename T>
+struct HexFloatTraits {
+  // Integer type that can store this hex-float.
+  typedef void uint_type;
+  // Signed integer type that can store this hex-float.
+  typedef void int_type;
+  // The number of bits that are actually relevant in the uint_type.
+  // This allows us to deal with, for example, 24-bit values in a 32-bit
+  // integer.
+  static const uint32_t num_used_bits = 0;
+  // Number of bits that represent the exponent.
+  static const uint32_t num_exponent_bits = 0;
+  // Number of bits that represent the fractional part.
+  static const uint32_t num_fraction_bits = 0;
+  // The bias of the exponent. (How much we need to subtract from the stored
+  // value to get the correct value.)
+  static const uint32_t exponent_bias = 0;
+};
+
+// Traits for IEEE float.
+// 1 sign bit, 8 exponent bits, 23 fractional bits.
+template <>
+struct HexFloatTraits<float> {
+  typedef uint32_t uint_type;
+  typedef int32_t int_type;
+  static const uint_type num_used_bits = 32;
+  static const uint_type num_exponent_bits = 8;
+  static const uint_type num_fraction_bits = 23;
+  static const uint_type exponent_bias = 127;
+};
+
+// Traits for IEEE double.
+// 1 sign bit, 11 exponent bits, 52 fractional bits.
+template <>
+struct HexFloatTraits<double> {
+  typedef uint64_t uint_type;
+  typedef int64_t int_type;
+  static const uint_type num_used_bits = 64;
+  static const uint_type num_exponent_bits = 11;
+  static const uint_type num_fraction_bits = 52;
+  static const uint_type exponent_bias = 1023;
+};
+
+// Template class that houses a floating pointer number.
+// It exposes a number of constants based on the provided traits to
+// assist in interpreting the bits of the value.
+template <typename T, typename Traits = HexFloatTraits<T>>
+class HexFloat {
+ public:
+  using uint_type = typename Traits::uint_type;
+  using int_type = typename Traits::int_type;
+
+  explicit HexFloat(T f) : value_(f) {}
+  T value() const { return value_; }
+  void set_value(T f) { value_ = f; }
+
+  // These are all written like this because it is convenient to have
+  // compile-time constants for all of these values.
+
+  // Pass-through values to save typing.
+  static const uint32_t num_used_bits = Traits::num_used_bits;
+  static const uint32_t exponent_bias = Traits::exponent_bias;
+  static const uint32_t num_exponent_bits = Traits::num_exponent_bits;
+  static const uint32_t num_fraction_bits = Traits::num_fraction_bits;
+
+  // Number of bits to shift left to set the highest relevant bit.
+  static const uint32_t top_bit_left_shift = num_used_bits - 1;
+  // How many nibbles (hex characters) the fractional part takes up.
+  static const uint32_t fraction_nibbles = (num_fraction_bits + 3) / 4;
+  // If the fractional part does not fit evenly into a hex character (4-bits)
+  // then we have to left-shift to get rid of leading 0s. This is the amount
+  // we have to shift (might be 0).
+  static const uint32_t num_overflow_bits =
+      fraction_nibbles * 4 -  num_fraction_bits;
+
+  // The representation of the fraction, not the actual bits. This
+  // includes the leading bit that is usually implicit.
+  static const uint_type fraction_represent_mask =
+      spvutils::SetBits<uint_type, 0, num_fraction_bits + 1>::get;
+
+  // The topmost bit in the fraction. (The first non-implicit bit).
+  static const uint_type fraction_top_bit =
+      uint_type(1) << num_fraction_bits + num_overflow_bits - 1;
+
+  // The mask for the encoded fraction. It does not include the
+  // implicit bit.
+  static const uint_type fraction_encode_mask =
+      spvutils::SetBits<uint_type, 0, num_fraction_bits>::get;
+
+  // The bit that is used as a sign.
+  static const uint_type sign_mask = uint_type(1) << top_bit_left_shift;
+
+  // The bits that represent the exponent.
+  static const uint_type exponent_mask =
+      spvutils::SetBits<uint_type, num_fraction_bits, num_exponent_bits>::get;
+
+  // How far left the exponent is shifted.
+  static const uint32_t exponent_left_shift = num_fraction_bits;
+
+  // How far from the right edge the fraction is shifted.
+  static const uint32_t fraction_right_shift =
+      (sizeof(uint_type)*8) - num_fraction_bits;
+
+ private:
+  T value_;
+
+  static_assert(num_used_bits ==
+                    Traits::num_exponent_bits + Traits::num_fraction_bits + 1,
+                "The number of bits do not fit");
+};
+
+// Outputs the given HexFloat to the stream.
+template <typename T, typename Traits>
+std::ostream& operator<<(std::ostream& os, const HexFloat<T, Traits>& value) {
+  using HF = HexFloat<T, Traits>;
+  using uint_type = typename HF::uint_type;
+  using int_type = typename HF::int_type;
+
+  static_assert(HF::num_used_bits != 0,
+                "num_used_bits must be non-zero for a valid float");
+  static_assert(HF::num_exponent_bits != 0,
+                "num_exponent_bits must be non-zero for a valid float");
+  static_assert(HF::num_fraction_bits != 0,
+                "num_fractin_bits must be non-zero for a valid float");
+  static_assert(HF::num_overflow_bits != 0,
+                "num_exponent_bits must be non-zero for a valid float");
+
+  const uint_type bits = spvutils::BitwiseCast<uint_type>(value.value());
+  const char* const sign = (bits & HF::sign_mask) ? "-" : "";
+  const uint_type exponent = (bits & HF::exponent_mask) >> HF::num_fraction_bits;
+
+  uint_type fraction = (bits & HF::fraction_encode_mask)
+                       << HF::num_overflow_bits;
+
+  const bool is_zero = exponent == 0 && fraction == 0;
+  const bool is_denorm = exponent == 0 && !is_zero;
+
+  // exponent contains the biased exponent we have to convert it back into
+  // the normal range.
+  int_type int_exponent = static_cast<int_type>(exponent) - HF::exponent_bias;
+  // If the number is all zeros, then we actually have to NOT shift the
+  // exponent.
+  int_exponent = is_zero ? 0 : int_exponent;
+
+  // If we are denorm, then start shifting, and decreasing the exponent until
+  // our leading bit is 1.
+
+  if (is_denorm) {
+    while ((fraction & HF::fraction_top_bit) == 0) {
+      fraction <<= 1;
+      int_exponent -= 1;
+    }
+    // Since this is denormalized, we have to consume the leading 1 since it
+    // will end up being implicit.
+    fraction <<= 1;  // eat the leading 1
+    fraction &= HF::fraction_represent_mask;
+  }
+
+  uint_type fraction_nibbles = HF::fraction_nibbles;
+  // We do not have to display any trailing 0s, since this represents the
+  // fractional part.
+  while (fraction_nibbles > 0 && (fraction & 0xF) == 0) {
+    // Shift off any trailing values;
+    fraction >>= 4;
+    --fraction_nibbles;
+  }
+
+  os << sign << "0x" << (is_zero ? '0' : '1');
+  if (fraction_nibbles) {
+    // Make sure to keep the leading 0s in place, since this is the fractional
+    // part.
+    os << "." << std::setw(fraction_nibbles) << std::setfill('0') << std::hex
+       << fraction;
+  }
+  os << "p" << std::dec << (int_exponent >= 0 ? "+" : "") << int_exponent;
+  return os;
+}
+}
+
+#endif  // _LIBSPIRV_UTIL_HEX_FLOAT_H_

diff --git a/test/HexFloat.cpp b/test/HexFloat.cpp
new file mode 100644 (file)
index 0000000..a6cafa4
--- /dev/null
+++ b/test/HexFloat.cpp
@@ -0,0 +1,118 @@
+// Copyright (c) 2015 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and/or associated documentation files (the
+// "Materials"), to deal in the Materials without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Materials, and to
+// permit persons to whom the Materials are furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
+// KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
+// SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
+//    https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+
+#include "UnitSPIRV.h"
+#include "util/hex_float.h"
+
+#include <gmock/gmock.h>
+#include <tuple>
+#include <sstream>
+#include <string>
+
+
+namespace {
+using ::testing::Eq;
+
+using HexFloatEncodeTest =
+    ::testing::TestWithParam<std::pair<float, std::string>>;
+
+TEST_P(HexFloatEncodeTest, EncodeCorrectly) {
+  std::stringstream ss;
+  ss << spvutils::HexFloat<float>(std::get<0>(GetParam()));
+  EXPECT_THAT(ss.str(), Eq(std::get<1>(GetParam())));
+}
+
+INSTANTIATE_TEST_CASE_P(
+    Float32Tests, HexFloatEncodeTest,
+    ::testing::ValuesIn(std::vector<std::pair<float, std::string>>({
+        {0.f, "0x0p+0"},
+        {1.f, "0x1p+0"},
+        {2.f, "0x1p+1"},
+        {3.f, "0x1.8p+1"},
+        {0.5f, "0x1p-1"},
+        {0.25f, "0x1p-2"},
+        {0.75f, "0x1.8p-1"},
+        {-0.f, "-0x0p+0"},
+        {-1.f, "-0x1p+0"},
+        {-0.5f, "-0x1p-1"},
+        {-0.25f, "-0x1p-2"},
+        {-0.75f, "-0x1.8p-1"},
+
+        // Larger numbers
+        {512.f, "0x1p+9"},
+        {-512.f, "-0x1p+9"},
+        {1024.f, "0x1p+10"},
+        {-1024.f, "-0x1p+10"},
+        {1024.f + 8.f, "0x1.02p+10"},
+        {-1024.f - 8.f, "-0x1.02p+10"},
+
+        // Small numbers
+        {1.0f / 512.f, "0x1p-9"},
+        {1.0f / -512.f, "-0x1p-9"},
+        {1.0f / 1024.f, "0x1p-10"},
+        {1.0f / -1024.f, "-0x1p-10"},
+        {1.0f / 1024.f + 1.0f / 8.f, "0x1.02p-3"},
+        {1.0f / -1024.f - 1.0f / 8.f, "-0x1.02p-3"},
+
+        // lowest non-denorm
+        {1.0 / (powf(2.0f, 126.0f)), "0x1p-126"},
+        {-1.0 / (powf(2.0f, 126.0f)), "-0x1p-126"},
+
+        // Denormalized values
+        {1.0 / (powf(2.0f, 127.0f)), "0x1p-127"},
+        {(1.0 / (powf(2.0f, 127.0f))) / 2.0f, "0x1p-128"},
+        {(1.0 / (powf(2.0f, 127.0f))) / 4.0f, "0x1p-129"},
+        {(1.0 / (powf(2.0f, 127.0f))) / 8.0f, "0x1p-130"},
+        {-1.0 / (powf(2.0f, 127.0f)), "-0x1p-127"},
+        {(-1.0 / (powf(2.0f, 127.0f))) / 2.0f, "-0x1p-128"},
+        {(-1.0 / (powf(2.0f, 127.0f))) / 4.0f, "-0x1p-129"},
+        {(-1.0 / (powf(2.0f, 127.0f))) / 8.0f, "-0x1p-130"},
+
+        {(1.0 / (powf(2.0f, 127.0f))) +
+          ((1.0 / (powf(2.0f, 127.0f))) / 2.0f), "0x1.8p-127"},
+        {(1.0 / (powf(2.0f, 127.0f)) / 2.0f) +
+          ((1.0 / (powf(2.0f, 127.0f))) / 4.0f), "0x1.8p-128"},
+
+
+        // Various NAN and INF cases
+        {spvutils::BitwiseCast<float>(0xFF800000), "-0x1p+128"},         // -inf
+        {spvutils::BitwiseCast<float>(0x7F800000), "0x1p+128"},          // inf
+        {spvutils::BitwiseCast<float>(0xFF800000), "-0x1p+128"},         // -nan
+        {spvutils::BitwiseCast<float>(0xFF800100), "-0x1.0002p+128"},    // -nan
+        {spvutils::BitwiseCast<float>(0xFF800c00), "-0x1.0018p+128"},    // -nan
+        {spvutils::BitwiseCast<float>(0xFF80F000), "-0x1.01ep+128"},     // -nan
+        {spvutils::BitwiseCast<float>(0xFFFFFFFF), "-0x1.fffffep+128"},  // -nan
+        {spvutils::BitwiseCast<float>(0x7F800000), "0x1p+128"},          // +nan
+        {spvutils::BitwiseCast<float>(0x7F800100), "0x1.0002p+128"},     // +nan
+        {spvutils::BitwiseCast<float>(0x7F800c00), "0x1.0018p+128"},     // +nan
+        {spvutils::BitwiseCast<float>(0x7F80F000), "0x1.01ep+128"},      // +nan
+        {spvutils::BitwiseCast<float>(0x7FFFFFFF), "0x1.fffffep+128"},   // +nan
+    })));
+
+// TODO(awoloszyn): Add double tests
+// TODO(awoloszyn): Add fp16 tests and HexFloatTraits.
+
+}