12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151 |
- // Copyright (c) 2015-2016 The Khronos Group 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.
- #ifndef SOURCE_UTIL_HEX_FLOAT_H_
- #define SOURCE_UTIL_HEX_FLOAT_H_
- #include <cassert>
- #include <cctype>
- #include <cmath>
- #include <cstdint>
- #include <iomanip>
- #include <limits>
- #include <sstream>
- #include <vector>
- #include "source/util/bitutils.h"
- #ifndef __GNUC__
- #define GCC_VERSION 0
- #else
- #define GCC_VERSION \
- (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
- #endif
- namespace spvtools {
- namespace utils {
- class Float16 {
- public:
- Float16(uint16_t v) : val(v) {}
- Float16() = default;
- static bool isNan(const Float16& val) {
- return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) != 0);
- }
- // Returns true if the given value is any kind of infinity.
- static bool isInfinity(const Float16& val) {
- return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) == 0);
- }
- Float16(const Float16& other) { val = other.val; }
- uint16_t get_value() const { return val; }
- // Returns the maximum normal value.
- static Float16 max() { return Float16(0x7bff); }
- // Returns the lowest normal value.
- static Float16 lowest() { return Float16(0xfbff); }
- private:
- uint16_t val;
- };
- // To specialize this type, you must override uint_type to define
- // an unsigned integer that can fit your floating point type.
- // You must also add a isNan function that returns true if
- // a value is Nan.
- template <typename T>
- struct FloatProxyTraits {
- using uint_type = void;
- };
- template <>
- struct FloatProxyTraits<float> {
- using uint_type = uint32_t;
- static bool isNan(float f) { return std::isnan(f); }
- // Returns true if the given value is any kind of infinity.
- static bool isInfinity(float f) { return std::isinf(f); }
- // Returns the maximum normal value.
- static float max() { return std::numeric_limits<float>::max(); }
- // Returns the lowest normal value.
- static float lowest() { return std::numeric_limits<float>::lowest(); }
- // Returns the value as the native floating point format.
- static float getAsFloat(const uint_type& t) { return BitwiseCast<float>(t); }
- // Returns the bits from the given floating pointer number.
- static uint_type getBitsFromFloat(const float& t) {
- return BitwiseCast<uint_type>(t);
- }
- // Returns the bitwidth.
- static uint32_t width() { return 32u; }
- };
- template <>
- struct FloatProxyTraits<double> {
- using uint_type = uint64_t;
- static bool isNan(double f) { return std::isnan(f); }
- // Returns true if the given value is any kind of infinity.
- static bool isInfinity(double f) { return std::isinf(f); }
- // Returns the maximum normal value.
- static double max() { return std::numeric_limits<double>::max(); }
- // Returns the lowest normal value.
- static double lowest() { return std::numeric_limits<double>::lowest(); }
- // Returns the value as the native floating point format.
- static double getAsFloat(const uint_type& t) {
- return BitwiseCast<double>(t);
- }
- // Returns the bits from the given floating pointer number.
- static uint_type getBitsFromFloat(const double& t) {
- return BitwiseCast<uint_type>(t);
- }
- // Returns the bitwidth.
- static uint32_t width() { return 64u; }
- };
- template <>
- struct FloatProxyTraits<Float16> {
- using uint_type = uint16_t;
- static bool isNan(Float16 f) { return Float16::isNan(f); }
- // Returns true if the given value is any kind of infinity.
- static bool isInfinity(Float16 f) { return Float16::isInfinity(f); }
- // Returns the maximum normal value.
- static Float16 max() { return Float16::max(); }
- // Returns the lowest normal value.
- static Float16 lowest() { return Float16::lowest(); }
- // Returns the value as the native floating point format.
- static Float16 getAsFloat(const uint_type& t) { return Float16(t); }
- // Returns the bits from the given floating pointer number.
- static uint_type getBitsFromFloat(const Float16& t) { return t.get_value(); }
- // Returns the bitwidth.
- static uint32_t width() { return 16u; }
- };
- // Since copying a floating point number (especially if it is NaN)
- // does not guarantee that bits are preserved, this class lets us
- // store the type and use it as a float when necessary.
- template <typename T>
- class FloatProxy {
- public:
- using uint_type = typename FloatProxyTraits<T>::uint_type;
- // Since this is to act similar to the normal floats,
- // do not initialize the data by default.
- FloatProxy() = default;
- // Intentionally non-explicit. This is a proxy type so
- // implicit conversions allow us to use it more transparently.
- FloatProxy(T val) { data_ = FloatProxyTraits<T>::getBitsFromFloat(val); }
- // Intentionally non-explicit. This is a proxy type so
- // implicit conversions allow us to use it more transparently.
- FloatProxy(uint_type val) { data_ = val; }
- // This is helpful to have and is guaranteed not to stomp bits.
- FloatProxy<T> operator-() const {
- return static_cast<uint_type>(data_ ^
- (uint_type(0x1) << (sizeof(T) * 8 - 1)));
- }
- // Returns the data as a floating point value.
- T getAsFloat() const { return FloatProxyTraits<T>::getAsFloat(data_); }
- // Returns the raw data.
- uint_type data() const { return data_; }
- // Returns a vector of words suitable for use in an Operand.
- std::vector<uint32_t> GetWords() const {
- std::vector<uint32_t> words;
- if (FloatProxyTraits<T>::width() == 64) {
- FloatProxyTraits<double>::uint_type d = data();
- words.push_back(static_cast<uint32_t>(d));
- words.push_back(static_cast<uint32_t>(d >> 32));
- } else {
- words.push_back(static_cast<uint32_t>(data()));
- }
- return words;
- }
- // Returns true if the value represents any type of NaN.
- bool isNan() { return FloatProxyTraits<T>::isNan(getAsFloat()); }
- // Returns true if the value represents any type of infinity.
- bool isInfinity() { return FloatProxyTraits<T>::isInfinity(getAsFloat()); }
- // Returns the maximum normal value.
- static FloatProxy<T> max() {
- return FloatProxy<T>(FloatProxyTraits<T>::max());
- }
- // Returns the lowest normal value.
- static FloatProxy<T> lowest() {
- return FloatProxy<T>(FloatProxyTraits<T>::lowest());
- }
- private:
- uint_type data_;
- };
- template <typename T>
- bool operator==(const FloatProxy<T>& first, const FloatProxy<T>& second) {
- return first.data() == second.data();
- }
- // Reads a FloatProxy value as a normal float from a stream.
- template <typename T>
- std::istream& operator>>(std::istream& is, FloatProxy<T>& value) {
- T float_val;
- is >> float_val;
- value = FloatProxy<T>(float_val);
- return is;
- }
- // 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.
- using uint_type = void;
- // Signed integer type that can store this hex-float.
- using int_type = void;
- // The numerical type that this HexFloat represents.
- using underlying_type = void;
- // The type needed to construct the underlying type.
- using native_type = void;
- // 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<FloatProxy<float>> {
- using uint_type = uint32_t;
- using int_type = int32_t;
- using underlying_type = FloatProxy<float>;
- using native_type = float;
- 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<FloatProxy<double>> {
- using uint_type = uint64_t;
- using int_type = int64_t;
- using underlying_type = FloatProxy<double>;
- using native_type = double;
- 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;
- };
- // Traits for IEEE half.
- // 1 sign bit, 5 exponent bits, 10 fractional bits.
- template <>
- struct HexFloatTraits<FloatProxy<Float16>> {
- using uint_type = uint16_t;
- using int_type = int16_t;
- using underlying_type = uint16_t;
- using native_type = uint16_t;
- static const uint_type num_used_bits = 16;
- static const uint_type num_exponent_bits = 5;
- static const uint_type num_fraction_bits = 10;
- static const uint_type exponent_bias = 15;
- };
- enum class round_direction {
- kToZero,
- kToNearestEven,
- kToPositiveInfinity,
- kToNegativeInfinity,
- max = kToNegativeInfinity
- };
- // 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;
- using underlying_type = typename Traits::underlying_type;
- using native_type = typename Traits::native_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 =
- SetBits<uint_type, 0, num_fraction_bits + num_overflow_bits>::get;
- // The topmost bit in the nibble-aligned fraction.
- static const uint_type fraction_top_bit =
- uint_type(1) << (num_fraction_bits + num_overflow_bits - 1);
- // The least significant bit in the exponent, which is also the bit
- // immediately to the left of the significand.
- static const uint_type first_exponent_bit = uint_type(1)
- << (num_fraction_bits);
- // The mask for the encoded fraction. It does not include the
- // implicit bit.
- static const uint_type fraction_encode_mask =
- 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 =
- 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 =
- static_cast<uint32_t>(sizeof(uint_type) * 8) - num_fraction_bits;
- // The maximum representable unbiased exponent.
- static const int_type max_exponent =
- (exponent_mask >> num_fraction_bits) - exponent_bias;
- // The minimum representable exponent for normalized numbers.
- static const int_type min_exponent = -static_cast<int_type>(exponent_bias);
- // Returns the bits associated with the value.
- uint_type getBits() const { return value_.data(); }
- // Returns the bits associated with the value, without the leading sign bit.
- uint_type getUnsignedBits() const {
- return static_cast<uint_type>(value_.data() & ~sign_mask);
- }
- // Returns the bits associated with the exponent, shifted to start at the
- // lsb of the type.
- const uint_type getExponentBits() const {
- return static_cast<uint_type>((getBits() & exponent_mask) >>
- num_fraction_bits);
- }
- // Returns the exponent in unbiased form. This is the exponent in the
- // human-friendly form.
- const int_type getUnbiasedExponent() const {
- return static_cast<int_type>(getExponentBits() - exponent_bias);
- }
- // Returns just the significand bits from the value.
- const uint_type getSignificandBits() const {
- return getBits() & fraction_encode_mask;
- }
- // If the number was normalized, returns the unbiased exponent.
- // If the number was denormal, normalize the exponent first.
- const int_type getUnbiasedNormalizedExponent() const {
- if ((getBits() & ~sign_mask) == 0) { // special case if everything is 0
- return 0;
- }
- int_type exp = getUnbiasedExponent();
- if (exp == min_exponent) { // We are in denorm land.
- uint_type significand_bits = getSignificandBits();
- while ((significand_bits & (first_exponent_bit >> 1)) == 0) {
- significand_bits = static_cast<uint_type>(significand_bits << 1);
- exp = static_cast<int_type>(exp - 1);
- }
- significand_bits &= fraction_encode_mask;
- }
- return exp;
- }
- // Returns the signficand after it has been normalized.
- const uint_type getNormalizedSignificand() const {
- int_type unbiased_exponent = getUnbiasedNormalizedExponent();
- uint_type significand = getSignificandBits();
- for (int_type i = unbiased_exponent; i <= min_exponent; ++i) {
- significand = static_cast<uint_type>(significand << 1);
- }
- significand &= fraction_encode_mask;
- return significand;
- }
- // Returns true if this number represents a negative value.
- bool isNegative() const { return (getBits() & sign_mask) != 0; }
- // Sets this HexFloat from the individual components.
- // Note this assumes EVERY significand is normalized, and has an implicit
- // leading one. This means that the only way that this method will set 0,
- // is if you set a number so denormalized that it underflows.
- // Do not use this method with raw bits extracted from a subnormal number,
- // since subnormals do not have an implicit leading 1 in the significand.
- // The significand is also expected to be in the
- // lowest-most num_fraction_bits of the uint_type.
- // The exponent is expected to be unbiased, meaning an exponent of
- // 0 actually means 0.
- // If underflow_round_up is set, then on underflow, if a number is non-0
- // and would underflow, we round up to the smallest denorm.
- void setFromSignUnbiasedExponentAndNormalizedSignificand(
- bool negative, int_type exponent, uint_type significand,
- bool round_denorm_up) {
- bool significand_is_zero = significand == 0;
- if (exponent <= min_exponent) {
- // If this was denormalized, then we have to shift the bit on, meaning
- // the significand is not zero.
- significand_is_zero = false;
- significand |= first_exponent_bit;
- significand = static_cast<uint_type>(significand >> 1);
- }
- while (exponent < min_exponent) {
- significand = static_cast<uint_type>(significand >> 1);
- ++exponent;
- }
- if (exponent == min_exponent) {
- if (significand == 0 && !significand_is_zero && round_denorm_up) {
- significand = static_cast<uint_type>(0x1);
- }
- }
- uint_type new_value = 0;
- if (negative) {
- new_value = static_cast<uint_type>(new_value | sign_mask);
- }
- exponent = static_cast<int_type>(exponent + exponent_bias);
- assert(exponent >= 0);
- // put it all together
- exponent = static_cast<uint_type>((exponent << exponent_left_shift) &
- exponent_mask);
- significand = static_cast<uint_type>(significand & fraction_encode_mask);
- new_value = static_cast<uint_type>(new_value | (exponent | significand));
- value_ = T(new_value);
- }
- // Increments the significand of this number by the given amount.
- // If this would spill the significand into the implicit bit,
- // carry is set to true and the significand is shifted to fit into
- // the correct location, otherwise carry is set to false.
- // All significands and to_increment are assumed to be within the bounds
- // for a valid significand.
- static uint_type incrementSignificand(uint_type significand,
- uint_type to_increment, bool* carry) {
- significand = static_cast<uint_type>(significand + to_increment);
- *carry = false;
- if (significand & first_exponent_bit) {
- *carry = true;
- // The implicit 1-bit will have carried, so we should zero-out the
- // top bit and shift back.
- significand = static_cast<uint_type>(significand & ~first_exponent_bit);
- significand = static_cast<uint_type>(significand >> 1);
- }
- return significand;
- }
- #if GCC_VERSION == 40801
- // These exist because MSVC throws warnings on negative right-shifts
- // even if they are not going to be executed. Eg:
- // constant_number < 0? 0: constant_number
- // These convert the negative left-shifts into right shifts.
- template <int_type N>
- struct negatable_left_shift {
- static uint_type val(uint_type val) {
- if (N > 0) {
- return static_cast<uint_type>(val << N);
- } else {
- return static_cast<uint_type>(val >> N);
- }
- }
- };
- template <int_type N>
- struct negatable_right_shift {
- static uint_type val(uint_type val) {
- if (N > 0) {
- return static_cast<uint_type>(val >> N);
- } else {
- return static_cast<uint_type>(val << N);
- }
- }
- };
- #else
- // These exist because MSVC throws warnings on negative right-shifts
- // even if they are not going to be executed. Eg:
- // constant_number < 0? 0: constant_number
- // These convert the negative left-shifts into right shifts.
- template <int_type N, typename enable = void>
- struct negatable_left_shift {
- static uint_type val(uint_type val) {
- return static_cast<uint_type>(val >> -N);
- }
- };
- template <int_type N>
- struct negatable_left_shift<N, typename std::enable_if<N >= 0>::type> {
- static uint_type val(uint_type val) {
- return static_cast<uint_type>(val << N);
- }
- };
- template <int_type N, typename enable = void>
- struct negatable_right_shift {
- static uint_type val(uint_type val) {
- return static_cast<uint_type>(val << -N);
- }
- };
- template <int_type N>
- struct negatable_right_shift<N, typename std::enable_if<N >= 0>::type> {
- static uint_type val(uint_type val) {
- return static_cast<uint_type>(val >> N);
- }
- };
- #endif
- // Returns the significand, rounded to fit in a significand in
- // other_T. This is shifted so that the most significant
- // bit of the rounded number lines up with the most significant bit
- // of the returned significand.
- template <typename other_T>
- typename other_T::uint_type getRoundedNormalizedSignificand(
- round_direction dir, bool* carry_bit) {
- using other_uint_type = typename other_T::uint_type;
- static const int_type num_throwaway_bits =
- static_cast<int_type>(num_fraction_bits) -
- static_cast<int_type>(other_T::num_fraction_bits);
- static const uint_type last_significant_bit =
- (num_throwaway_bits < 0)
- ? 0
- : negatable_left_shift<num_throwaway_bits>::val(1u);
- static const uint_type first_rounded_bit =
- (num_throwaway_bits < 1)
- ? 0
- : negatable_left_shift<num_throwaway_bits - 1>::val(1u);
- static const uint_type throwaway_mask_bits =
- num_throwaway_bits > 0 ? num_throwaway_bits : 0;
- static const uint_type throwaway_mask =
- SetBits<uint_type, 0, throwaway_mask_bits>::get;
- *carry_bit = false;
- other_uint_type out_val = 0;
- uint_type significand = getNormalizedSignificand();
- // If we are up-casting, then we just have to shift to the right location.
- if (num_throwaway_bits <= 0) {
- out_val = static_cast<other_uint_type>(significand);
- uint_type shift_amount = static_cast<uint_type>(-num_throwaway_bits);
- out_val = static_cast<other_uint_type>(out_val << shift_amount);
- return out_val;
- }
- // If every non-representable bit is 0, then we don't have any casting to
- // do.
- if ((significand & throwaway_mask) == 0) {
- return static_cast<other_uint_type>(
- negatable_right_shift<num_throwaway_bits>::val(significand));
- }
- bool round_away_from_zero = false;
- // We actually have to narrow the significand here, so we have to follow the
- // rounding rules.
- switch (dir) {
- case round_direction::kToZero:
- break;
- case round_direction::kToPositiveInfinity:
- round_away_from_zero = !isNegative();
- break;
- case round_direction::kToNegativeInfinity:
- round_away_from_zero = isNegative();
- break;
- case round_direction::kToNearestEven:
- // Have to round down, round bit is 0
- if ((first_rounded_bit & significand) == 0) {
- break;
- }
- if (((significand & throwaway_mask) & ~first_rounded_bit) != 0) {
- // If any subsequent bit of the rounded portion is non-0 then we round
- // up.
- round_away_from_zero = true;
- break;
- }
- // We are exactly half-way between 2 numbers, pick even.
- if ((significand & last_significant_bit) != 0) {
- // 1 for our last bit, round up.
- round_away_from_zero = true;
- break;
- }
- break;
- }
- if (round_away_from_zero) {
- return static_cast<other_uint_type>(
- negatable_right_shift<num_throwaway_bits>::val(incrementSignificand(
- significand, last_significant_bit, carry_bit)));
- } else {
- return static_cast<other_uint_type>(
- negatable_right_shift<num_throwaway_bits>::val(significand));
- }
- }
- // Casts this value to another HexFloat. If the cast is widening,
- // then round_dir is ignored. If the cast is narrowing, then
- // the result is rounded in the direction specified.
- // This number will retain Nan and Inf values.
- // It will also saturate to Inf if the number overflows, and
- // underflow to (0 or min depending on rounding) if the number underflows.
- template <typename other_T>
- void castTo(other_T& other, round_direction round_dir) {
- other = other_T(static_cast<typename other_T::native_type>(0));
- bool negate = isNegative();
- if (getUnsignedBits() == 0) {
- if (negate) {
- other.set_value(-other.value());
- }
- return;
- }
- uint_type significand = getSignificandBits();
- bool carried = false;
- typename other_T::uint_type rounded_significand =
- getRoundedNormalizedSignificand<other_T>(round_dir, &carried);
- int_type exponent = getUnbiasedExponent();
- if (exponent == min_exponent) {
- // If we are denormal, normalize the exponent, so that we can encode
- // easily.
- exponent = static_cast<int_type>(exponent + 1);
- for (uint_type check_bit = first_exponent_bit >> 1; check_bit != 0;
- check_bit = static_cast<uint_type>(check_bit >> 1)) {
- exponent = static_cast<int_type>(exponent - 1);
- if (check_bit & significand) break;
- }
- }
- bool is_nan =
- (getBits() & exponent_mask) == exponent_mask && significand != 0;
- bool is_inf =
- !is_nan &&
- ((exponent + carried) > static_cast<int_type>(other_T::exponent_bias) ||
- (significand == 0 && (getBits() & exponent_mask) == exponent_mask));
- // If we are Nan or Inf we should pass that through.
- if (is_inf) {
- other.set_value(typename other_T::underlying_type(
- static_cast<typename other_T::uint_type>(
- (negate ? other_T::sign_mask : 0) | other_T::exponent_mask)));
- return;
- }
- if (is_nan) {
- typename other_T::uint_type shifted_significand;
- shifted_significand = static_cast<typename other_T::uint_type>(
- negatable_left_shift<
- static_cast<int_type>(other_T::num_fraction_bits) -
- static_cast<int_type>(num_fraction_bits)>::val(significand));
- // We are some sort of Nan. We try to keep the bit-pattern of the Nan
- // as close as possible. If we had to shift off bits so we are 0, then we
- // just set the last bit.
- other.set_value(typename other_T::underlying_type(
- static_cast<typename other_T::uint_type>(
- (negate ? other_T::sign_mask : 0) | other_T::exponent_mask |
- (shifted_significand == 0 ? 0x1 : shifted_significand))));
- return;
- }
- bool round_underflow_up =
- isNegative() ? round_dir == round_direction::kToNegativeInfinity
- : round_dir == round_direction::kToPositiveInfinity;
- using other_int_type = typename other_T::int_type;
- // setFromSignUnbiasedExponentAndNormalizedSignificand will
- // zero out any underflowing value (but retain the sign).
- other.setFromSignUnbiasedExponentAndNormalizedSignificand(
- negate, static_cast<other_int_type>(exponent), rounded_significand,
- round_underflow_up);
- return;
- }
- private:
- T value_;
- static_assert(num_used_bits ==
- Traits::num_exponent_bits + Traits::num_fraction_bits + 1,
- "The number of bits do not fit");
- static_assert(sizeof(T) == sizeof(uint_type), "The type sizes do not match");
- };
- // Returns 4 bits represented by the hex character.
- inline uint8_t get_nibble_from_character(int character) {
- const char* dec = "0123456789";
- const char* lower = "abcdef";
- const char* upper = "ABCDEF";
- const char* p = nullptr;
- if ((p = strchr(dec, character))) {
- return static_cast<uint8_t>(p - dec);
- } else if ((p = strchr(lower, character))) {
- return static_cast<uint8_t>(p - lower + 0xa);
- } else if ((p = strchr(upper, character))) {
- return static_cast<uint8_t>(p - upper + 0xa);
- }
- assert(false && "This was called with a non-hex character");
- return 0;
- }
- // 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");
- const uint_type bits = value.value().data();
- const char* const sign = (bits & HF::sign_mask) ? "-" : "";
- const uint_type exponent = static_cast<uint_type>(
- (bits & HF::exponent_mask) >> HF::num_fraction_bits);
- uint_type fraction = static_cast<uint_type>((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 = static_cast<uint_type>(fraction << 1);
- int_exponent = static_cast<int_type>(int_exponent - 1);
- }
- // Since this is denormalized, we have to consume the leading 1 since it
- // will end up being implicit.
- fraction = static_cast<uint_type>(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 = static_cast<uint_type>(fraction >> 4);
- --fraction_nibbles;
- }
- const auto saved_flags = os.flags();
- const auto saved_fill = os.fill();
- 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(static_cast<int>(fraction_nibbles))
- << std::setfill('0') << std::hex << fraction;
- }
- os << "p" << std::dec << (int_exponent >= 0 ? "+" : "") << int_exponent;
- os.flags(saved_flags);
- os.fill(saved_fill);
- return os;
- }
- // Returns true if negate_value is true and the next character on the
- // input stream is a plus or minus sign. In that case we also set the fail bit
- // on the stream and set the value to the zero value for its type.
- template <typename T, typename Traits>
- inline bool RejectParseDueToLeadingSign(std::istream& is, bool negate_value,
- HexFloat<T, Traits>& value) {
- if (negate_value) {
- auto next_char = is.peek();
- if (next_char == '-' || next_char == '+') {
- // Fail the parse. Emulate standard behaviour by setting the value to
- // the zero value, and set the fail bit on the stream.
- value = HexFloat<T, Traits>(typename HexFloat<T, Traits>::uint_type{0});
- is.setstate(std::ios_base::failbit);
- return true;
- }
- }
- return false;
- }
- // Parses a floating point number from the given stream and stores it into the
- // value parameter.
- // If negate_value is true then the number may not have a leading minus or
- // plus, and if it successfully parses, then the number is negated before
- // being stored into the value parameter.
- // If the value cannot be correctly parsed or overflows the target floating
- // point type, then set the fail bit on the stream.
- // TODO(dneto): Promise C++11 standard behavior in how the value is set in
- // the error case, but only after all target platforms implement it correctly.
- // In particular, the Microsoft C++ runtime appears to be out of spec.
- template <typename T, typename Traits>
- inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value,
- HexFloat<T, Traits>& value) {
- if (RejectParseDueToLeadingSign(is, negate_value, value)) {
- return is;
- }
- T val;
- is >> val;
- if (negate_value) {
- val = -val;
- }
- value.set_value(val);
- // In the failure case, map -0.0 to 0.0.
- if (is.fail() && value.getUnsignedBits() == 0u) {
- value = HexFloat<T, Traits>(typename HexFloat<T, Traits>::uint_type{0});
- }
- if (val.isInfinity()) {
- // Fail the parse. Emulate standard behaviour by setting the value to
- // the closest normal value, and set the fail bit on the stream.
- value.set_value((value.isNegative() | negate_value) ? T::lowest()
- : T::max());
- is.setstate(std::ios_base::failbit);
- }
- return is;
- }
- // Specialization of ParseNormalFloat for FloatProxy<Float16> values.
- // This will parse the float as it were a 32-bit floating point number,
- // and then round it down to fit into a Float16 value.
- // The number is rounded towards zero.
- // If negate_value is true then the number may not have a leading minus or
- // plus, and if it successfully parses, then the number is negated before
- // being stored into the value parameter.
- // If the value cannot be correctly parsed or overflows the target floating
- // point type, then set the fail bit on the stream.
- // TODO(dneto): Promise C++11 standard behavior in how the value is set in
- // the error case, but only after all target platforms implement it correctly.
- // In particular, the Microsoft C++ runtime appears to be out of spec.
- template <>
- inline std::istream&
- ParseNormalFloat<FloatProxy<Float16>, HexFloatTraits<FloatProxy<Float16>>>(
- std::istream& is, bool negate_value,
- HexFloat<FloatProxy<Float16>, HexFloatTraits<FloatProxy<Float16>>>& value) {
- // First parse as a 32-bit float.
- HexFloat<FloatProxy<float>> float_val(0.0f);
- ParseNormalFloat(is, negate_value, float_val);
- // Then convert to 16-bit float, saturating at infinities, and
- // rounding toward zero.
- float_val.castTo(value, round_direction::kToZero);
- // Overflow on 16-bit behaves the same as for 32- and 64-bit: set the
- // fail bit and set the lowest or highest value.
- if (Float16::isInfinity(value.value().getAsFloat())) {
- value.set_value(value.isNegative() ? Float16::lowest() : Float16::max());
- is.setstate(std::ios_base::failbit);
- }
- return is;
- }
- // Reads a HexFloat from the given stream.
- // If the float is not encoded as a hex-float then it will be parsed
- // as a regular float.
- // This may fail if your stream does not support at least one unget.
- // Nan values can be encoded with "0x1.<not zero>p+exponent_bias".
- // This would normally overflow a float and round to
- // infinity but this special pattern is the exact representation for a NaN,
- // and therefore is actually encoded as the correct NaN. To encode inf,
- // either 0x0p+exponent_bias can be specified or any exponent greater than
- // exponent_bias.
- // Examples using IEEE 32-bit float encoding.
- // 0x1.0p+128 (+inf)
- // -0x1.0p-128 (-inf)
- //
- // 0x1.1p+128 (+Nan)
- // -0x1.1p+128 (-Nan)
- //
- // 0x1p+129 (+inf)
- // -0x1p+129 (-inf)
- template <typename T, typename Traits>
- std::istream& operator>>(std::istream& is, HexFloat<T, Traits>& value) {
- using HF = HexFloat<T, Traits>;
- using uint_type = typename HF::uint_type;
- using int_type = typename HF::int_type;
- value.set_value(static_cast<typename HF::native_type>(0.f));
- if (is.flags() & std::ios::skipws) {
- // If the user wants to skip whitespace , then we should obey that.
- while (std::isspace(is.peek())) {
- is.get();
- }
- }
- auto next_char = is.peek();
- bool negate_value = false;
- if (next_char != '-' && next_char != '0') {
- return ParseNormalFloat(is, negate_value, value);
- }
- if (next_char == '-') {
- negate_value = true;
- is.get();
- next_char = is.peek();
- }
- if (next_char == '0') {
- is.get(); // We may have to unget this.
- auto maybe_hex_start = is.peek();
- if (maybe_hex_start != 'x' && maybe_hex_start != 'X') {
- is.unget();
- return ParseNormalFloat(is, negate_value, value);
- } else {
- is.get(); // Throw away the 'x';
- }
- } else {
- return ParseNormalFloat(is, negate_value, value);
- }
- // This "looks" like a hex-float so treat it as one.
- bool seen_p = false;
- bool seen_dot = false;
- uint_type fraction_index = 0;
- uint_type fraction = 0;
- int_type exponent = HF::exponent_bias;
- // Strip off leading zeros so we don't have to special-case them later.
- while ((next_char = is.peek()) == '0') {
- is.get();
- }
- bool is_denorm =
- true; // Assume denorm "representation" until we hear otherwise.
- // NB: This does not mean the value is actually denorm,
- // it just means that it was written 0.
- bool bits_written = false; // Stays false until we write a bit.
- while (!seen_p && !seen_dot) {
- // Handle characters that are left of the fractional part.
- if (next_char == '.') {
- seen_dot = true;
- } else if (next_char == 'p') {
- seen_p = true;
- } else if (::isxdigit(next_char)) {
- // We know this is not denormalized since we have stripped all leading
- // zeroes and we are not a ".".
- is_denorm = false;
- int number = get_nibble_from_character(next_char);
- for (int i = 0; i < 4; ++i, number <<= 1) {
- uint_type write_bit = (number & 0x8) ? 0x1 : 0x0;
- if (bits_written) {
- // If we are here the bits represented belong in the fractional
- // part of the float, and we have to adjust the exponent accordingly.
- fraction = static_cast<uint_type>(
- fraction |
- static_cast<uint_type>(
- write_bit << (HF::top_bit_left_shift - fraction_index++)));
- exponent = static_cast<int_type>(exponent + 1);
- }
- bits_written |= write_bit != 0;
- }
- } else {
- // We have not found our exponent yet, so we have to fail.
- is.setstate(std::ios::failbit);
- return is;
- }
- is.get();
- next_char = is.peek();
- }
- bits_written = false;
- while (seen_dot && !seen_p) {
- // Handle only fractional parts now.
- if (next_char == 'p') {
- seen_p = true;
- } else if (::isxdigit(next_char)) {
- int number = get_nibble_from_character(next_char);
- for (int i = 0; i < 4; ++i, number <<= 1) {
- uint_type write_bit = (number & 0x8) ? 0x01 : 0x00;
- bits_written |= write_bit != 0;
- if (is_denorm && !bits_written) {
- // Handle modifying the exponent here this way we can handle
- // an arbitrary number of hex values without overflowing our
- // integer.
- exponent = static_cast<int_type>(exponent - 1);
- } else {
- fraction = static_cast<uint_type>(
- fraction |
- static_cast<uint_type>(
- write_bit << (HF::top_bit_left_shift - fraction_index++)));
- }
- }
- } else {
- // We still have not found our 'p' exponent yet, so this is not a valid
- // hex-float.
- is.setstate(std::ios::failbit);
- return is;
- }
- is.get();
- next_char = is.peek();
- }
- bool seen_sign = false;
- int8_t exponent_sign = 1;
- int_type written_exponent = 0;
- while (true) {
- if ((next_char == '-' || next_char == '+')) {
- if (seen_sign) {
- is.setstate(std::ios::failbit);
- return is;
- }
- seen_sign = true;
- exponent_sign = (next_char == '-') ? -1 : 1;
- } else if (::isdigit(next_char)) {
- // Hex-floats express their exponent as decimal.
- written_exponent = static_cast<int_type>(written_exponent * 10);
- written_exponent =
- static_cast<int_type>(written_exponent + (next_char - '0'));
- } else {
- break;
- }
- is.get();
- next_char = is.peek();
- }
- written_exponent = static_cast<int_type>(written_exponent * exponent_sign);
- exponent = static_cast<int_type>(exponent + written_exponent);
- bool is_zero = is_denorm && (fraction == 0);
- if (is_denorm && !is_zero) {
- fraction = static_cast<uint_type>(fraction << 1);
- exponent = static_cast<int_type>(exponent - 1);
- } else if (is_zero) {
- exponent = 0;
- }
- if (exponent <= 0 && !is_zero) {
- fraction = static_cast<uint_type>(fraction >> 1);
- fraction |= static_cast<uint_type>(1) << HF::top_bit_left_shift;
- }
- fraction = (fraction >> HF::fraction_right_shift) & HF::fraction_encode_mask;
- const int_type max_exponent =
- SetBits<uint_type, 0, HF::num_exponent_bits>::get;
- // Handle actual denorm numbers
- while (exponent < 0 && !is_zero) {
- fraction = static_cast<uint_type>(fraction >> 1);
- exponent = static_cast<int_type>(exponent + 1);
- fraction &= HF::fraction_encode_mask;
- if (fraction == 0) {
- // We have underflowed our fraction. We should clamp to zero.
- is_zero = true;
- exponent = 0;
- }
- }
- // We have overflowed so we should be inf/-inf.
- if (exponent > max_exponent) {
- exponent = max_exponent;
- fraction = 0;
- }
- uint_type output_bits = static_cast<uint_type>(
- static_cast<uint_type>(negate_value ? 1 : 0) << HF::top_bit_left_shift);
- output_bits |= fraction;
- uint_type shifted_exponent = static_cast<uint_type>(
- static_cast<uint_type>(exponent << HF::exponent_left_shift) &
- HF::exponent_mask);
- output_bits |= shifted_exponent;
- T output_float(output_bits);
- value.set_value(output_float);
- return is;
- }
- // Writes a FloatProxy value to a stream.
- // Zero and normal numbers are printed in the usual notation, but with
- // enough digits to fully reproduce the value. Other values (subnormal,
- // NaN, and infinity) are printed as a hex float.
- template <typename T>
- std::ostream& operator<<(std::ostream& os, const FloatProxy<T>& value) {
- auto float_val = value.getAsFloat();
- switch (std::fpclassify(float_val)) {
- case FP_ZERO:
- case FP_NORMAL: {
- auto saved_precision = os.precision();
- os.precision(std::numeric_limits<T>::max_digits10);
- os << float_val;
- os.precision(saved_precision);
- } break;
- default:
- os << HexFloat<FloatProxy<T>>(value);
- break;
- }
- return os;
- }
- template <>
- inline std::ostream& operator<<<Float16>(std::ostream& os,
- const FloatProxy<Float16>& value) {
- os << HexFloat<FloatProxy<Float16>>(value);
- return os;
- }
- } // namespace utils
- } // namespace spvtools
- #endif // SOURCE_UTIL_HEX_FLOAT_H_
|