Compare commits
8 Commits
a365110054
...
f579ec6e48
Author | SHA1 | Date | |
---|---|---|---|
f579ec6e48 | |||
fd20e66f1f | |||
5d69b79232 | |||
2edd68d1bd | |||
7ffa7667b6 | |||
93d89e07ca | |||
17dcba4b90 | |||
39d2518fdd |
@ -100,7 +100,12 @@ protected:
|
||||
using compile_ret_t = virt_addr_t;
|
||||
using compile_func = compile_ret_t (this_class::*)(virt_addr_t &pc, code_word_t instr);
|
||||
|
||||
inline const char *name(size_t index){return index<traits::reg_aliases.size()?traits::reg_aliases[index]:"illegal";}
|
||||
inline const char *name(size_t index){return traits::reg_aliases.at(index);}
|
||||
<%
|
||||
def fcsr = registers.find {it.name=='FCSR'}
|
||||
if(fcsr != null) {%>
|
||||
inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}
|
||||
<%}%>
|
||||
|
||||
virt_addr_t execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t icount_limit) override;
|
||||
|
||||
|
2
softfloat/.gitignore
vendored
Normal file
2
softfloat/.gitignore
vendored
Normal file
@ -0,0 +1,2 @@
|
||||
build/*/*.o
|
||||
build/*/*.a
|
24
softfloat/README.md
Normal file
24
softfloat/README.md
Normal file
@ -0,0 +1,24 @@
|
||||
|
||||
Package Overview for Berkeley SoftFloat Release 3e
|
||||
==================================================
|
||||
|
||||
John R. Hauser<br>
|
||||
2018 January 20
|
||||
|
||||
|
||||
Berkeley SoftFloat is a software implementation of binary floating-point
|
||||
that conforms to the IEEE Standard for Floating-Point Arithmetic. SoftFloat
|
||||
is distributed in the form of C source code. Building the SoftFloat sources
|
||||
generates a library file (typically `softfloat.a` or `libsoftfloat.a`)
|
||||
containing the floating-point subroutines.
|
||||
|
||||
|
||||
The SoftFloat package is documented in the following files in the `doc`
|
||||
subdirectory:
|
||||
|
||||
* [SoftFloat.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat.html) Documentation for using the SoftFloat functions.
|
||||
* [SoftFloat-source.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat-source.html) Documentation for building SoftFloat.
|
||||
* [SoftFloat-history.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat-history.html) History of the major changes to SoftFloat.
|
||||
|
||||
Other files in the package comprise the source code for SoftFloat.
|
||||
|
@ -35,11 +35,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
@ -47,6 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -35,11 +35,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
@ -47,6 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -35,11 +35,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
@ -47,6 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
399
softfloat/build/Linux-RISCV64-GCC/Makefile
Normal file
399
softfloat/build/Linux-RISCV64-GCC/Makefile
Normal file
@ -0,0 +1,399 @@
|
||||
|
||||
#=============================================================================
|
||||
#
|
||||
# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
# Package, Release 3e, by John R. Hauser.
|
||||
#
|
||||
# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
# University of California. All rights reserved.
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the above copyright notice,
|
||||
# this list of conditions, and the following disclaimer.
|
||||
#
|
||||
# 2. Redistributions in binary form must reproduce the above copyright
|
||||
# notice, this list of conditions, and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
#
|
||||
# 3. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
# DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#
|
||||
#=============================================================================
|
||||
|
||||
SOURCE_DIR ?= ../../source
|
||||
SPECIALIZE_TYPE ?= RISCV
|
||||
MARCH ?= rv64gcv_zfh_zfhmin
|
||||
MABI ?= lp64d
|
||||
|
||||
SOFTFLOAT_OPTS ?= \
|
||||
-DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
|
||||
-DSOFTFLOAT_FAST_DIV64TO32
|
||||
|
||||
DELETE = rm -f
|
||||
C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
|
||||
COMPILE_C = \
|
||||
riscv64-unknown-linux-gnu-gcc -c -march=$(MARCH) -mabi=$(MABI) -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
|
||||
$(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
|
||||
MAKELIB = ar crs $@
|
||||
|
||||
OBJ = .o
|
||||
LIB = .a
|
||||
|
||||
OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
|
||||
|
||||
.PHONY: all
|
||||
all: softfloat$(LIB)
|
||||
|
||||
OBJS_PRIMITIVES = \
|
||||
s_eq128$(OBJ) \
|
||||
s_le128$(OBJ) \
|
||||
s_lt128$(OBJ) \
|
||||
s_shortShiftLeft128$(OBJ) \
|
||||
s_shortShiftRight128$(OBJ) \
|
||||
s_shortShiftRightJam64$(OBJ) \
|
||||
s_shortShiftRightJam64Extra$(OBJ) \
|
||||
s_shortShiftRightJam128$(OBJ) \
|
||||
s_shortShiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam32$(OBJ) \
|
||||
s_shiftRightJam64$(OBJ) \
|
||||
s_shiftRightJam64Extra$(OBJ) \
|
||||
s_shiftRightJam128$(OBJ) \
|
||||
s_shiftRightJam128Extra$(OBJ) \
|
||||
s_shiftRightJam256M$(OBJ) \
|
||||
s_countLeadingZeros8$(OBJ) \
|
||||
s_countLeadingZeros16$(OBJ) \
|
||||
s_countLeadingZeros32$(OBJ) \
|
||||
s_countLeadingZeros64$(OBJ) \
|
||||
s_add128$(OBJ) \
|
||||
s_add256M$(OBJ) \
|
||||
s_sub128$(OBJ) \
|
||||
s_sub256M$(OBJ) \
|
||||
s_mul64ByShifted32To128$(OBJ) \
|
||||
s_mul64To128$(OBJ) \
|
||||
s_mul128By32$(OBJ) \
|
||||
s_mul128To256M$(OBJ) \
|
||||
s_approxRecip_1Ks$(OBJ) \
|
||||
s_approxRecip32_1$(OBJ) \
|
||||
s_approxRecipSqrt_1Ks$(OBJ) \
|
||||
s_approxRecipSqrt32_1$(OBJ) \
|
||||
|
||||
OBJS_SPECIALIZE = \
|
||||
softfloat_raiseFlags$(OBJ) \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_bf16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToBF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
s_f64UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF64UI$(OBJ) \
|
||||
s_propagateNaNF64UI$(OBJ) \
|
||||
extF80M_isSignalingNaN$(OBJ) \
|
||||
s_extF80UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToExtF80UI$(OBJ) \
|
||||
s_propagateNaNExtF80UI$(OBJ) \
|
||||
f128M_isSignalingNaN$(OBJ) \
|
||||
s_f128UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF128UI$(OBJ) \
|
||||
s_propagateNaNF128UI$(OBJ) \
|
||||
|
||||
OBJS_OTHERS = \
|
||||
s_roundToUI32$(OBJ) \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalBF16Sig$(OBJ) \
|
||||
s_roundPackToBF16$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
s_addMagsF16$(OBJ) \
|
||||
s_subMagsF16$(OBJ) \
|
||||
s_mulAddF16$(OBJ) \
|
||||
s_normSubnormalF32Sig$(OBJ) \
|
||||
s_roundPackToF32$(OBJ) \
|
||||
s_normRoundPackToF32$(OBJ) \
|
||||
s_addMagsF32$(OBJ) \
|
||||
s_subMagsF32$(OBJ) \
|
||||
s_mulAddF32$(OBJ) \
|
||||
s_normSubnormalF64Sig$(OBJ) \
|
||||
s_roundPackToF64$(OBJ) \
|
||||
s_normRoundPackToF64$(OBJ) \
|
||||
s_addMagsF64$(OBJ) \
|
||||
s_subMagsF64$(OBJ) \
|
||||
s_mulAddF64$(OBJ) \
|
||||
s_normSubnormalExtF80Sig$(OBJ) \
|
||||
s_roundPackToExtF80$(OBJ) \
|
||||
s_normRoundPackToExtF80$(OBJ) \
|
||||
s_addMagsExtF80$(OBJ) \
|
||||
s_subMagsExtF80$(OBJ) \
|
||||
s_normSubnormalF128Sig$(OBJ) \
|
||||
s_roundPackToF128$(OBJ) \
|
||||
s_normRoundPackToF128$(OBJ) \
|
||||
s_addMagsF128$(OBJ) \
|
||||
s_subMagsF128$(OBJ) \
|
||||
s_mulAddF128$(OBJ) \
|
||||
softfloat_state$(OBJ) \
|
||||
ui32_to_f16$(OBJ) \
|
||||
ui32_to_f32$(OBJ) \
|
||||
ui32_to_f64$(OBJ) \
|
||||
ui32_to_extF80$(OBJ) \
|
||||
ui32_to_extF80M$(OBJ) \
|
||||
ui32_to_f128$(OBJ) \
|
||||
ui32_to_f128M$(OBJ) \
|
||||
ui64_to_f16$(OBJ) \
|
||||
ui64_to_f32$(OBJ) \
|
||||
ui64_to_f64$(OBJ) \
|
||||
ui64_to_extF80$(OBJ) \
|
||||
ui64_to_extF80M$(OBJ) \
|
||||
ui64_to_f128$(OBJ) \
|
||||
ui64_to_f128M$(OBJ) \
|
||||
i32_to_f16$(OBJ) \
|
||||
i32_to_f32$(OBJ) \
|
||||
i32_to_f64$(OBJ) \
|
||||
i32_to_extF80$(OBJ) \
|
||||
i32_to_extF80M$(OBJ) \
|
||||
i32_to_f128$(OBJ) \
|
||||
i32_to_f128M$(OBJ) \
|
||||
i64_to_f16$(OBJ) \
|
||||
i64_to_f32$(OBJ) \
|
||||
i64_to_f64$(OBJ) \
|
||||
i64_to_extF80$(OBJ) \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
bf16_isSignalingNaN$(OBJ) \
|
||||
bf16_to_f32$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
f16_to_i64$(OBJ) \
|
||||
f16_to_ui32_r_minMag$(OBJ) \
|
||||
f16_to_ui64_r_minMag$(OBJ) \
|
||||
f16_to_i32_r_minMag$(OBJ) \
|
||||
f16_to_i64_r_minMag$(OBJ) \
|
||||
f16_to_f32$(OBJ) \
|
||||
f16_to_f64$(OBJ) \
|
||||
f16_to_extF80$(OBJ) \
|
||||
f16_to_extF80M$(OBJ) \
|
||||
f16_to_f128$(OBJ) \
|
||||
f16_to_f128M$(OBJ) \
|
||||
f16_roundToInt$(OBJ) \
|
||||
f16_add$(OBJ) \
|
||||
f16_sub$(OBJ) \
|
||||
f16_mul$(OBJ) \
|
||||
f16_mulAdd$(OBJ) \
|
||||
f16_div$(OBJ) \
|
||||
f16_rem$(OBJ) \
|
||||
f16_sqrt$(OBJ) \
|
||||
f16_eq$(OBJ) \
|
||||
f16_le$(OBJ) \
|
||||
f16_lt$(OBJ) \
|
||||
f16_eq_signaling$(OBJ) \
|
||||
f16_le_quiet$(OBJ) \
|
||||
f16_lt_quiet$(OBJ) \
|
||||
f16_isSignalingNaN$(OBJ) \
|
||||
f32_to_ui32$(OBJ) \
|
||||
f32_to_ui64$(OBJ) \
|
||||
f32_to_i32$(OBJ) \
|
||||
f32_to_i64$(OBJ) \
|
||||
f32_to_ui32_r_minMag$(OBJ) \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_bf16$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
f32_to_extF80M$(OBJ) \
|
||||
f32_to_f128$(OBJ) \
|
||||
f32_to_f128M$(OBJ) \
|
||||
f32_roundToInt$(OBJ) \
|
||||
f32_add$(OBJ) \
|
||||
f32_sub$(OBJ) \
|
||||
f32_mul$(OBJ) \
|
||||
f32_mulAdd$(OBJ) \
|
||||
f32_div$(OBJ) \
|
||||
f32_rem$(OBJ) \
|
||||
f32_sqrt$(OBJ) \
|
||||
f32_eq$(OBJ) \
|
||||
f32_le$(OBJ) \
|
||||
f32_lt$(OBJ) \
|
||||
f32_eq_signaling$(OBJ) \
|
||||
f32_le_quiet$(OBJ) \
|
||||
f32_lt_quiet$(OBJ) \
|
||||
f32_isSignalingNaN$(OBJ) \
|
||||
f64_to_ui32$(OBJ) \
|
||||
f64_to_ui64$(OBJ) \
|
||||
f64_to_i32$(OBJ) \
|
||||
f64_to_i64$(OBJ) \
|
||||
f64_to_ui32_r_minMag$(OBJ) \
|
||||
f64_to_ui64_r_minMag$(OBJ) \
|
||||
f64_to_i32_r_minMag$(OBJ) \
|
||||
f64_to_i64_r_minMag$(OBJ) \
|
||||
f64_to_f16$(OBJ) \
|
||||
f64_to_f32$(OBJ) \
|
||||
f64_to_extF80$(OBJ) \
|
||||
f64_to_extF80M$(OBJ) \
|
||||
f64_to_f128$(OBJ) \
|
||||
f64_to_f128M$(OBJ) \
|
||||
f64_roundToInt$(OBJ) \
|
||||
f64_add$(OBJ) \
|
||||
f64_sub$(OBJ) \
|
||||
f64_mul$(OBJ) \
|
||||
f64_mulAdd$(OBJ) \
|
||||
f64_div$(OBJ) \
|
||||
f64_rem$(OBJ) \
|
||||
f64_sqrt$(OBJ) \
|
||||
f64_eq$(OBJ) \
|
||||
f64_le$(OBJ) \
|
||||
f64_lt$(OBJ) \
|
||||
f64_eq_signaling$(OBJ) \
|
||||
f64_le_quiet$(OBJ) \
|
||||
f64_lt_quiet$(OBJ) \
|
||||
f64_isSignalingNaN$(OBJ) \
|
||||
extF80_to_ui32$(OBJ) \
|
||||
extF80_to_ui64$(OBJ) \
|
||||
extF80_to_i32$(OBJ) \
|
||||
extF80_to_i64$(OBJ) \
|
||||
extF80_to_ui32_r_minMag$(OBJ) \
|
||||
extF80_to_ui64_r_minMag$(OBJ) \
|
||||
extF80_to_i32_r_minMag$(OBJ) \
|
||||
extF80_to_i64_r_minMag$(OBJ) \
|
||||
extF80_to_f16$(OBJ) \
|
||||
extF80_to_f32$(OBJ) \
|
||||
extF80_to_f64$(OBJ) \
|
||||
extF80_to_f128$(OBJ) \
|
||||
extF80_roundToInt$(OBJ) \
|
||||
extF80_add$(OBJ) \
|
||||
extF80_sub$(OBJ) \
|
||||
extF80_mul$(OBJ) \
|
||||
extF80_div$(OBJ) \
|
||||
extF80_rem$(OBJ) \
|
||||
extF80_sqrt$(OBJ) \
|
||||
extF80_eq$(OBJ) \
|
||||
extF80_le$(OBJ) \
|
||||
extF80_lt$(OBJ) \
|
||||
extF80_eq_signaling$(OBJ) \
|
||||
extF80_le_quiet$(OBJ) \
|
||||
extF80_lt_quiet$(OBJ) \
|
||||
extF80_isSignalingNaN$(OBJ) \
|
||||
extF80M_to_ui32$(OBJ) \
|
||||
extF80M_to_ui64$(OBJ) \
|
||||
extF80M_to_i32$(OBJ) \
|
||||
extF80M_to_i64$(OBJ) \
|
||||
extF80M_to_ui32_r_minMag$(OBJ) \
|
||||
extF80M_to_ui64_r_minMag$(OBJ) \
|
||||
extF80M_to_i32_r_minMag$(OBJ) \
|
||||
extF80M_to_i64_r_minMag$(OBJ) \
|
||||
extF80M_to_f16$(OBJ) \
|
||||
extF80M_to_f32$(OBJ) \
|
||||
extF80M_to_f64$(OBJ) \
|
||||
extF80M_to_f128M$(OBJ) \
|
||||
extF80M_roundToInt$(OBJ) \
|
||||
extF80M_add$(OBJ) \
|
||||
extF80M_sub$(OBJ) \
|
||||
extF80M_mul$(OBJ) \
|
||||
extF80M_div$(OBJ) \
|
||||
extF80M_rem$(OBJ) \
|
||||
extF80M_sqrt$(OBJ) \
|
||||
extF80M_eq$(OBJ) \
|
||||
extF80M_le$(OBJ) \
|
||||
extF80M_lt$(OBJ) \
|
||||
extF80M_eq_signaling$(OBJ) \
|
||||
extF80M_le_quiet$(OBJ) \
|
||||
extF80M_lt_quiet$(OBJ) \
|
||||
f128_to_ui32$(OBJ) \
|
||||
f128_to_ui64$(OBJ) \
|
||||
f128_to_i32$(OBJ) \
|
||||
f128_to_i64$(OBJ) \
|
||||
f128_to_ui32_r_minMag$(OBJ) \
|
||||
f128_to_ui64_r_minMag$(OBJ) \
|
||||
f128_to_i32_r_minMag$(OBJ) \
|
||||
f128_to_i64_r_minMag$(OBJ) \
|
||||
f128_to_f16$(OBJ) \
|
||||
f128_to_f32$(OBJ) \
|
||||
f128_to_extF80$(OBJ) \
|
||||
f128_to_f64$(OBJ) \
|
||||
f128_roundToInt$(OBJ) \
|
||||
f128_add$(OBJ) \
|
||||
f128_sub$(OBJ) \
|
||||
f128_mul$(OBJ) \
|
||||
f128_mulAdd$(OBJ) \
|
||||
f128_div$(OBJ) \
|
||||
f128_rem$(OBJ) \
|
||||
f128_sqrt$(OBJ) \
|
||||
f128_eq$(OBJ) \
|
||||
f128_le$(OBJ) \
|
||||
f128_lt$(OBJ) \
|
||||
f128_eq_signaling$(OBJ) \
|
||||
f128_le_quiet$(OBJ) \
|
||||
f128_lt_quiet$(OBJ) \
|
||||
f128_isSignalingNaN$(OBJ) \
|
||||
f128M_to_ui32$(OBJ) \
|
||||
f128M_to_ui64$(OBJ) \
|
||||
f128M_to_i32$(OBJ) \
|
||||
f128M_to_i64$(OBJ) \
|
||||
f128M_to_ui32_r_minMag$(OBJ) \
|
||||
f128M_to_ui64_r_minMag$(OBJ) \
|
||||
f128M_to_i32_r_minMag$(OBJ) \
|
||||
f128M_to_i64_r_minMag$(OBJ) \
|
||||
f128M_to_f16$(OBJ) \
|
||||
f128M_to_f32$(OBJ) \
|
||||
f128M_to_extF80M$(OBJ) \
|
||||
f128M_to_f64$(OBJ) \
|
||||
f128M_roundToInt$(OBJ) \
|
||||
f128M_add$(OBJ) \
|
||||
f128M_sub$(OBJ) \
|
||||
f128M_mul$(OBJ) \
|
||||
f128M_mulAdd$(OBJ) \
|
||||
f128M_div$(OBJ) \
|
||||
f128M_rem$(OBJ) \
|
||||
f128M_sqrt$(OBJ) \
|
||||
f128M_eq$(OBJ) \
|
||||
f128M_le$(OBJ) \
|
||||
f128M_lt$(OBJ) \
|
||||
f128M_eq_signaling$(OBJ) \
|
||||
f128M_le_quiet$(OBJ) \
|
||||
f128M_lt_quiet$(OBJ) \
|
||||
|
||||
OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
|
||||
|
||||
$(OBJS_ALL): \
|
||||
$(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
|
||||
$(SOURCE_DIR)/include/primitives.h
|
||||
$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
|
||||
$(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
|
||||
$(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
|
||||
$(SOURCE_DIR)/include/softfloat.h
|
||||
|
||||
$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$*.c
|
||||
|
||||
$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
|
||||
$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
|
||||
|
||||
softfloat$(LIB): $(OBJS_ALL)
|
||||
$(DELETE) $@
|
||||
$(MAKELIB) $^
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
$(DELETE) $(OBJS_ALL) softfloat$(LIB)
|
||||
|
54
softfloat/build/Linux-RISCV64-GCC/platform.h
Normal file
54
softfloat/build/Linux-RISCV64-GCC/platform.h
Normal file
@ -0,0 +1,54 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
|
||||
University of California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
#define INLINE extern inline
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#define SOFTFLOAT_INTRINSIC_INT128 1
|
||||
#include "opts-GCC.h"
|
||||
|
@ -94,6 +94,8 @@ OBJS_SPECIALIZE = \
|
||||
s_f16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF16UI$(OBJ) \
|
||||
s_propagateNaNF16UI$(OBJ) \
|
||||
s_bf16UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToBF16UI$(OBJ) \
|
||||
s_f32UIToCommonNaN$(OBJ) \
|
||||
s_commonNaNToF32UI$(OBJ) \
|
||||
s_propagateNaNF32UI$(OBJ) \
|
||||
@ -114,6 +116,8 @@ OBJS_OTHERS = \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalBF16Sig$(OBJ) \
|
||||
s_roundPackToBF16$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
@ -172,6 +176,8 @@ OBJS_OTHERS = \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
bf16_isSignalingNaN$(OBJ) \
|
||||
bf16_to_f32$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
@ -209,6 +215,7 @@ OBJS_OTHERS = \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_bf16$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
|
@ -35,11 +35,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
@ -47,6 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -35,11 +35,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
@ -47,6 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -35,11 +35,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
=============================================================================*/
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef __GNUC_STDC_INLINE__
|
||||
#define INLINE inline
|
||||
#else
|
||||
@ -47,7 +47,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define SOFTFLOAT_BUILTIN_CLZ 1
|
||||
#define SOFTFLOAT_INTRINSIC_INT128 1
|
||||
#include "opts-GCC.h"
|
||||
|
||||
|
@ -115,6 +115,8 @@ OBJS_OTHERS = \
|
||||
s_roundToUI64$(OBJ) \
|
||||
s_roundToI32$(OBJ) \
|
||||
s_roundToI64$(OBJ) \
|
||||
s_normSubnormalBF16Sig$(OBJ) \
|
||||
s_roundPackToBF16$(OBJ) \
|
||||
s_normSubnormalF16Sig$(OBJ) \
|
||||
s_roundPackToF16$(OBJ) \
|
||||
s_normRoundPackToF16$(OBJ) \
|
||||
@ -173,6 +175,8 @@ OBJS_OTHERS = \
|
||||
i64_to_extF80M$(OBJ) \
|
||||
i64_to_f128$(OBJ) \
|
||||
i64_to_f128M$(OBJ) \
|
||||
bf16_isSignalingNaN$(OBJ) \
|
||||
bf16_to_f32$(OBJ) \
|
||||
f16_to_ui32$(OBJ) \
|
||||
f16_to_ui64$(OBJ) \
|
||||
f16_to_i32$(OBJ) \
|
||||
@ -210,6 +214,7 @@ OBJS_OTHERS = \
|
||||
f32_to_ui64_r_minMag$(OBJ) \
|
||||
f32_to_i32_r_minMag$(OBJ) \
|
||||
f32_to_i64_r_minMag$(OBJ) \
|
||||
f32_to_bf16$(OBJ) \
|
||||
f32_to_f16$(OBJ) \
|
||||
f32_to_f64$(OBJ) \
|
||||
f32_to_extF80$(OBJ) \
|
||||
|
@ -37,13 +37,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
// Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define LITTLEENDIAN 1
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define INLINE inline
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define INLINE inline
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define THREAD_LOCAL _Thread_local
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define THREAD_LOCAL _Thread_local
|
||||
|
@ -37,13 +37,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
// Edit lines marked with `==>'. See "SoftFloat-source.html".
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define LITTLEENDIAN 1
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define LITTLEENDIAN 1
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define INLINE inline
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define INLINE inline
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
==> #define THREAD_LOCAL _Thread_local
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
== > #define THREAD_LOCAL _Thread_local
|
||||
|
@ -508,7 +508,7 @@ significant extra cost.
|
||||
On computers where the word size is <NOBR>64 bits</NOBR> or larger, both
|
||||
function versions (<CODE>f128M_add</CODE> and <CODE>f128_add</CODE>) are
|
||||
provided, because the cost of passing by value is then more reasonable.
|
||||
Applications that must be portable accross both classes of computers must use
|
||||
Applications that must be portable across both classes of computers must use
|
||||
the pointer-based functions, as these are always implemented.
|
||||
However, if it is known that SoftFloat includes the by-value functions for all
|
||||
platforms of interest, programmers can use whichever version they prefer.
|
||||
|
59
softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c
Normal file
59
softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c
Normal file
@ -0,0 +1,59 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a BF16 NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_bf16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNBF16UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>15;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<56;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
51
softfloat/source/8086-SSE/s_commonNaNToBF16UI.c
Normal file
51
softfloat/source/8086-SSE/s_commonNaNToBF16UI.c
Normal file
@ -0,0 +1,51 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a BF16 NaN, and
|
||||
| returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast16_t) aPtr->sign<<15 | 0x7FC0 | aPtr->v64>>56;
|
||||
|
||||
}
|
||||
|
@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
@ -53,21 +53,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define i64_fromPosOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
#define i64_fromNaN (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
@ -92,7 +92,7 @@ struct commonNaN {
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
@ -100,13 +100,13 @@ struct commonNaN {
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
@ -114,7 +114,29 @@ uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit brain floating-point (BF16) signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNBF16UI( uiA ) ((((uiA) & 0x7FC0) == 0x7F80) && ((uiA) & 0x003F))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit BF16 floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_bf16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
@ -126,7 +148,7 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
@ -134,13 +156,13 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
@ -148,20 +170,20 @@ uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
|
||||
#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
@ -169,13 +191,13 @@ uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
@ -183,13 +205,14 @@ uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0xFFFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
@ -197,8 +220,7 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
@ -214,14 +236,16 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -232,13 +256,19 @@ struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
|
||||
#define defaultNaNF128UI0 UINT64_C( 0 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
@ -246,8 +276,7 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
@ -256,13 +285,15 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -273,7 +304,13 @@ struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
#else
|
||||
|
||||
@ -288,14 +325,18 @@ struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t u
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
@ -303,7 +344,12 @@ void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat8
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
@ -311,7 +357,7 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
#define defaultNaNF128UI96 0xFFFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
@ -321,7 +367,8 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
@ -329,7 +376,8 @@ void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
@ -339,8 +387,11 @@ void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
@ -53,21 +53,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN (-0x7FFFFFFF - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define i64_fromPosOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
#define i64_fromNaN (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
@ -92,7 +92,7 @@ struct commonNaN {
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
@ -100,13 +100,13 @@ struct commonNaN {
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
@ -114,7 +114,8 @@ uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
@ -126,7 +127,7 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
@ -134,13 +135,13 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
@ -148,20 +149,20 @@ uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
|
||||
#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
@ -169,13 +170,13 @@ uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
@ -183,13 +184,14 @@ uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0xFFFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
@ -197,8 +199,7 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
@ -214,14 +215,16 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -232,13 +235,19 @@ struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
|
||||
#define defaultNaNF128UI0 UINT64_C( 0 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
@ -246,8 +255,7 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
@ -256,13 +264,15 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -273,7 +283,13 @@ struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
#else
|
||||
|
||||
@ -288,14 +304,18 @@ struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t u
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
@ -303,7 +323,12 @@ void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat8
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
@ -311,7 +336,7 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
#define defaultNaNF128UI96 0xFFFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
@ -321,7 +346,8 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
@ -329,7 +355,8 @@ void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
@ -339,8 +366,11 @@ void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
@ -53,29 +53,27 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0
|
||||
#define ui32_fromNaN 0
|
||||
#define i32_fromPosOverflow 0x7FFFFFFF
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN 0
|
||||
#define ui32_fromNaN 0
|
||||
#define i32_fromPosOverflow 0x7FFFFFFF
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define ui64_fromNegOverflow 0
|
||||
#define ui64_fromNaN 0
|
||||
#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN 0
|
||||
#define ui64_fromNaN 0
|
||||
#define i64_fromPosOverflow INT64_C( 0x7FFFFFFFFFFFFFFF )
|
||||
#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
#define i64_fromNaN 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
| to another.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct commonNaN {
|
||||
char _unused;
|
||||
};
|
||||
struct commonNaN { char _unused; };
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 16-bit floating-point NaN.
|
||||
@ -87,7 +85,7 @@ struct commonNaN {
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
@ -95,15 +93,13 @@ struct commonNaN {
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_f16UIToCommonNaN(uiA, zPtr) \
|
||||
if(!((uiA)&0x0200)) \
|
||||
softfloat_raiseFlags(softfloat_flag_invalid)
|
||||
#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_commonNaNToF16UI(aPtr) ((uint_fast16_t)defaultNaNF16UI)
|
||||
#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
@ -111,7 +107,8 @@ struct commonNaN {
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
@ -123,7 +120,7 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
@ -131,15 +128,13 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_f32UIToCommonNaN(uiA, zPtr) \
|
||||
if(!((uiA)&0x00400000)) \
|
||||
softfloat_raiseFlags(softfloat_flag_invalid)
|
||||
#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_commonNaNToF32UI(aPtr) ((uint_fast32_t)defaultNaNF32UI)
|
||||
#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
@ -147,20 +142,20 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
|
||||
#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
@ -168,15 +163,13 @@ uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_f64UIToCommonNaN(uiA, zPtr) \
|
||||
if(!((uiA)&UINT64_C(0x0008000000000000))) \
|
||||
softfloat_raiseFlags(softfloat_flag_invalid)
|
||||
#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_commonNaNToF64UI(aPtr) ((uint_fast64_t)defaultNaNF64UI)
|
||||
#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
@ -184,13 +177,14 @@ uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0x7FFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
@ -198,8 +192,7 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
@ -215,25 +208,24 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_extF80UIToCommonNaN(uiA64, uiA0, zPtr) \
|
||||
if(!((uiA0)&UINT64_C(0x4000000000000000))) \
|
||||
softfloat_raiseFlags(softfloat_flag_invalid)
|
||||
#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE && !defined softfloat_commonNaNToExtF80UI
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI
|
||||
INLINE
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr) {
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
uiZ.v64 = defaultNaNExtF80UI64;
|
||||
uiZ.v0 = defaultNaNExtF80UI0;
|
||||
uiZ.v0 = defaultNaNExtF80UI0;
|
||||
return uiZ;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -245,13 +237,19 @@ struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0x7FFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
|
||||
#define defaultNaNF128UI0 UINT64_C( 0 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
@ -259,8 +257,7 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
@ -269,24 +266,23 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_f128UIToCommonNaN(uiA64, uiA0, zPtr) \
|
||||
if(!((uiA64)&UINT64_C(0x0000800000000000))) \
|
||||
softfloat_raiseFlags(softfloat_flag_invalid)
|
||||
#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE && !defined softfloat_commonNaNToF128UI
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToF128UI
|
||||
INLINE
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN* aPtr) {
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
uiZ.v64 = defaultNaNF128UI64;
|
||||
uiZ.v0 = defaultNaNF128UI0;
|
||||
uiZ.v0 = defaultNaNF128UI0;
|
||||
return uiZ;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -298,7 +294,13 @@ struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
#else
|
||||
|
||||
@ -313,23 +315,26 @@ struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t u
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_extF80MToCommonNaN(aSPtr, zPtr) \
|
||||
if(!((aSPtr)->signif & UINT64_C(0x4000000000000000))) \
|
||||
softfloat_raiseFlags(softfloat_flag_invalid)
|
||||
#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE && !defined softfloat_commonNaNToExtF80M
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToExtF80M
|
||||
INLINE
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr) {
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
zSPtr->signExp = defaultNaNExtF80UI64;
|
||||
zSPtr->signif = defaultNaNExtF80UI0;
|
||||
zSPtr->signif = defaultNaNExtF80UI0;
|
||||
}
|
||||
#else
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -338,7 +343,12 @@ void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat8
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
@ -346,7 +356,7 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
#define defaultNaNF128UI96 0x7FFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
@ -356,9 +366,7 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_f128MToCommonNaN(aWPtr, zPtr) \
|
||||
if(!((aWPtr)[indexWordHi(4)] & UINT64_C(0x0000800000000000))) \
|
||||
softfloat_raiseFlags(softfloat_flag_invalid)
|
||||
#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
@ -366,16 +374,19 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE && !defined softfloat_commonNaNToF128M
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToF128M
|
||||
INLINE
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr) {
|
||||
zWPtr[indexWord(4, 3)] = defaultNaNF128UI96;
|
||||
zWPtr[indexWord(4, 2)] = defaultNaNF128UI64;
|
||||
zWPtr[indexWord(4, 1)] = defaultNaNF128UI32;
|
||||
zWPtr[indexWord(4, 0)] = defaultNaNF128UI0;
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
|
||||
zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
|
||||
zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
|
||||
zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
|
||||
}
|
||||
#else
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -386,8 +397,11 @@ void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
@ -53,21 +53,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0
|
||||
#define ui32_fromNaN 0
|
||||
#define i32_fromPosOverflow 0x7FFFFFFF
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN 0
|
||||
#define ui32_fromNaN 0
|
||||
#define i32_fromPosOverflow 0x7FFFFFFF
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define ui64_fromNegOverflow 0
|
||||
#define ui64_fromNaN 0
|
||||
#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN 0
|
||||
#define ui64_fromNaN 0
|
||||
#define i64_fromPosOverflow INT64_C( 0x7FFFFFFFFFFFFFFF )
|
||||
#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
#define i64_fromNaN 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
@ -92,7 +92,7 @@ struct commonNaN {
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
@ -100,13 +100,13 @@ struct commonNaN {
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
@ -114,7 +114,8 @@ uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
@ -126,7 +127,7 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
@ -134,13 +135,13 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
@ -148,20 +149,20 @@ uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
|
||||
#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
@ -169,13 +170,13 @@ uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
@ -183,13 +184,14 @@ uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0x7FFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
@ -197,8 +199,7 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
@ -214,14 +215,16 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -232,13 +235,19 @@ struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0x7FFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
|
||||
#define defaultNaNF128UI0 UINT64_C( 0 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
@ -246,8 +255,7 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
@ -256,13 +264,15 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -273,7 +283,13 @@ struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
#else
|
||||
|
||||
@ -288,14 +304,18 @@ struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t u
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
@ -303,7 +323,12 @@ void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat8
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
@ -311,7 +336,7 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
#define defaultNaNF128UI96 0x7FFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
@ -321,7 +346,8 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
@ -329,7 +355,8 @@ void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
@ -339,8 +366,11 @@ void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
5
softfloat/source/RISCV/s_bf16UIToCommonNaN.c
Normal file
5
softfloat/source/RISCV/s_bf16UIToCommonNaN.c
Normal file
@ -0,0 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
5
softfloat/source/RISCV/s_commonNaNToBF16UI.c
Normal file
5
softfloat/source/RISCV/s_commonNaNToBF16UI.c
Normal file
@ -0,0 +1,5 @@
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,9 +34,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "softfloat_types.h"
|
||||
|
||||
#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -49,8 +50,8 @@ void
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
|
||||
zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
|
||||
zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
zSPtr->signExp = defaultNaNExtF80UI64;
|
||||
zSPtr->signif = defaultNaNExtF80UI0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,9 +34,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -48,8 +49,8 @@ struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
|
||||
uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
|
||||
uiZ.v64 = defaultNaNExtF80UI64;
|
||||
uiZ.v0 = defaultNaNExtF80UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -36,7 +36,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -49,8 +51,10 @@ void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
|
||||
softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
|
||||
zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
|
||||
zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
|
||||
zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
|
||||
zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
|
||||
zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,9 +34,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -47,8 +48,8 @@ struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
|
||||
uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
|
||||
uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
|
||||
uiZ.v64 = defaultNaNF128UI64;
|
||||
uiZ.v0 = defaultNaNF128UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
@ -1,51 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,51 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,53 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
|
||||
return
|
||||
(uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
|
||||
| aPtr->v64>>12;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
|
||||
| a NaN, converts this NaN to the common NaN form, and stores the resulting
|
||||
| common NaN at the location pointed to by `zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80MToCommonNaN(
|
||||
const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = signExtF80UI64( aSPtr->signExp );
|
||||
zPtr->v64 = aSPtr->signif<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of an 80-bit extended floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_extF80UIToCommonNaN(
|
||||
uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA64>>15;
|
||||
zPtr->v64 = uiA0<<1;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,62 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
|
||||
| converts this NaN to the common NaN form, and stores the resulting common
|
||||
| NaN at the location pointed to by `zPtr'. If the NaN is a signaling NaN,
|
||||
| the invalid exception is raised. Argument `aWPtr' points to an array of
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
|
||||
softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,65 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "primitives.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
|
||||
| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
|
||||
| the common NaN form, and stores the resulting common NaN at the location
|
||||
| pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_f128UIToCommonNaN(
|
||||
uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
|
||||
{
|
||||
struct uint128 NaNSig;
|
||||
|
||||
if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
|
||||
zPtr->sign = uiA64>>63;
|
||||
zPtr->v64 = NaNSig.v64;
|
||||
zPtr->v0 = NaNSig.v0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF16UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>15;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<54;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF32UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>31;
|
||||
zPtr->v64 = (uint_fast64_t) uiA<<41;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -1,59 +1,5 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by `zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
| This file intentionally contains no code.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
|
||||
{
|
||||
|
||||
if ( softfloat_isSigNaNF64UI( uiA ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
}
|
||||
zPtr->sign = uiA>>63;
|
||||
zPtr->v64 = uiA<<12;
|
||||
zPtr->v0 = 0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,10 +34,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "primitiveTypes.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
@ -54,54 +53,22 @@ void
|
||||
struct extFloat80M *zSPtr
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const struct extFloat80M *sPtr;
|
||||
bool isSigNaNB;
|
||||
uint_fast16_t uiB64;
|
||||
uint64_t uiB0;
|
||||
uint_fast16_t uiA64;
|
||||
uint64_t uiA0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
uint_fast16_t ui64;
|
||||
uint_fast64_t ui0;
|
||||
|
||||
isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
|
||||
sPtr = aSPtr;
|
||||
if ( ! bSPtr ) {
|
||||
if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
goto copy;
|
||||
}
|
||||
isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
ui64 = aSPtr->signExp;
|
||||
ui0 = aSPtr->signif;
|
||||
if (
|
||||
softfloat_isSigNaNExtF80UI( ui64, ui0 )
|
||||
|| (bSPtr
|
||||
&& (ui64 = bSPtr->signExp,
|
||||
ui0 = bSPtr->signif,
|
||||
softfloat_isSigNaNExtF80UI( ui64, ui0 )))
|
||||
) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
uiB64 = bSPtr->signExp;
|
||||
if ( isSigNaNB ) goto returnLargerUIMag;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
|
||||
goto copy;
|
||||
} else {
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiA0 = aSPtr->signif;
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
|
||||
goto copyB;
|
||||
}
|
||||
}
|
||||
uiB64 = bSPtr->signExp;
|
||||
returnLargerUIMag:
|
||||
uiA64 = aSPtr->signExp;
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto copyB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto copy;
|
||||
uiA0 = aSPtr->signif;
|
||||
uiB0 = bSPtr->signif;
|
||||
if ( uiA0 < uiB0 ) goto copyB;
|
||||
if ( uiB0 < uiA0 ) goto copy;
|
||||
if ( uiA64 < uiB64 ) goto copy;
|
||||
copyB:
|
||||
sPtr = bSPtr;
|
||||
copy:
|
||||
zSPtr->signExp = sPtr->signExp;
|
||||
zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
|
||||
zSPtr->signExp = defaultNaNExtF80UI64;
|
||||
zSPtr->signif = defaultNaNExtF80UI0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -4,7 +4,7 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -34,17 +34,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "primitiveTypes.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
|
||||
| Interpreting the unsigned integer formed from concatenating `uiA64' and
|
||||
| `uiA0' as an 80-bit extended floating-point value, and likewise interpreting
|
||||
| the unsigned integer formed from concatenating `uiB64' and `uiB0' as another
|
||||
| 80-bit extended floating-point value, and assuming at least on of these
|
||||
| floating-point values is a NaN, returns the bit pattern of the combined NaN
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
@ -58,48 +57,16 @@ struct uint128
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA, isSigNaNB;
|
||||
uint_fast64_t uiNonsigA0, uiNonsigB0;
|
||||
uint_fast16_t uiMagA64, uiMagB64;
|
||||
struct uint128 uiZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
|
||||
isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
|
||||
/*------------------------------------------------------------------------
|
||||
| Make NaNs non-signaling.
|
||||
*------------------------------------------------------------------------*/
|
||||
uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
|
||||
uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( isSigNaNA | isSigNaNB ) {
|
||||
if (
|
||||
softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
|
||||
|| softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
|
||||
) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) {
|
||||
if ( isSigNaNB ) goto returnLargerMag;
|
||||
if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
|
||||
goto returnA;
|
||||
} else {
|
||||
if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
|
||||
goto returnB;
|
||||
}
|
||||
}
|
||||
returnLargerMag:
|
||||
uiMagA64 = uiA64 & 0x7FFF;
|
||||
uiMagB64 = uiB64 & 0x7FFF;
|
||||
if ( uiMagA64 < uiMagB64 ) goto returnB;
|
||||
if ( uiMagB64 < uiMagA64 ) goto returnA;
|
||||
if ( uiA0 < uiB0 ) goto returnB;
|
||||
if ( uiB0 < uiA0 ) goto returnA;
|
||||
if ( uiA64 < uiB64 ) goto returnA;
|
||||
returnB:
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiNonsigB0;
|
||||
return uiZ;
|
||||
returnA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiNonsigA0;
|
||||
uiZ.v64 = defaultNaNExtF80UI64;
|
||||
uiZ.v0 = defaultNaNExtF80UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2018 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,43 +34,35 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "primitiveTypes.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by `zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of `aWPtr', `bWPtr',
|
||||
| and `zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
|
||||
| pointed to by 'zWPtr'. If either original floating-point value is a
|
||||
| signaling NaN, the invalid exception is raised. Each of 'aWPtr', 'bWPtr',
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
const uint32_t *ptr;
|
||||
|
||||
ptr = aWPtr;
|
||||
isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
|
||||
if (
|
||||
isSigNaNA
|
||||
f128M_isSignalingNaN( (const float128_t *) aWPtr )
|
||||
|| (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
|
||||
) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) goto copy;
|
||||
}
|
||||
if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
|
||||
copy:
|
||||
zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
|
||||
zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
|
||||
zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
|
||||
zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
|
||||
zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
|
||||
zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
|
||||
zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
|
||||
zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
|
||||
|
||||
}
|
||||
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,10 +34,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "primitiveTypes.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
@ -58,23 +57,16 @@ struct uint128
|
||||
uint_fast64_t uiB0
|
||||
)
|
||||
{
|
||||
bool isSigNaNA;
|
||||
struct uint128 uiZ;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
|
||||
if (
|
||||
softfloat_isSigNaNF128UI( uiA64, uiA0 )
|
||||
|| softfloat_isSigNaNF128UI( uiB64, uiB0 )
|
||||
) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) goto returnNonsigA;
|
||||
}
|
||||
if ( isNaNF128UI( uiA64, uiA0 ) ) {
|
||||
returnNonsigA:
|
||||
uiZ.v64 = uiA64;
|
||||
uiZ.v0 = uiA0;
|
||||
} else {
|
||||
uiZ.v64 = uiB64;
|
||||
uiZ.v0 = uiB0;
|
||||
}
|
||||
uiZ.v64 |= UINT64_C( 0x0000800000000000 );
|
||||
uiZ.v64 = defaultNaNF128UI64;
|
||||
uiZ.v0 = defaultNaNF128UI0;
|
||||
return uiZ;
|
||||
|
||||
}
|
||||
|
@ -4,7 +4,7 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
@ -34,10 +34,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
@ -50,14 +48,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF16UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
|
||||
if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | 0x0200;
|
||||
}
|
||||
return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
|
||||
return defaultNaNF16UI;
|
||||
|
||||
}
|
||||
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,10 +34,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
@ -50,14 +48,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF32UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
|
||||
if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | 0x00400000;
|
||||
}
|
||||
return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
|
||||
return defaultNaNF32UI;
|
||||
|
||||
}
|
||||
|
||||
|
@ -4,8 +4,8 @@
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
|
||||
All rights reserved.
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
@ -34,10 +34,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
@ -50,14 +48,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
|
||||
{
|
||||
bool isSigNaNA;
|
||||
|
||||
isSigNaNA = softfloat_isSigNaNF64UI( uiA );
|
||||
if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
|
||||
if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
|
||||
softfloat_raiseFlags( softfloat_flag_invalid );
|
||||
if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
|
||||
}
|
||||
return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
|
||||
return defaultNaNF64UI;
|
||||
|
||||
}
|
||||
|
||||
|
@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifndef specialize_h
|
||||
#define specialize_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "primitiveTypes.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Default value for 'softfloat_detectTininess'.
|
||||
@ -51,48 +51,48 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
| The values to return on conversions to 32-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui32_fromPosOverflow UINT32_C(0xFFFFFFFF)
|
||||
#define ui32_fromNegOverflow UINT32_C(0x0)
|
||||
#define ui32_fromNaN UINT32_C(0xFFFFFFFF)
|
||||
#define i32_fromPosOverflow INT64_C(0x7FFFFFFF)
|
||||
#define i32_fromNegOverflow (-INT64_C(0x7FFFFFFF) - 1)
|
||||
#define i32_fromNaN INT64_C(0x7FFFFFFF)
|
||||
#define ui32_fromPosOverflow 0xFFFFFFFF
|
||||
#define ui32_fromNegOverflow 0
|
||||
#define ui32_fromNaN 0xFFFFFFFF
|
||||
#define i32_fromPosOverflow 0x7FFFFFFF
|
||||
#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
|
||||
#define i32_fromNaN 0x7FFFFFFF
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The values to return on conversions to 64-bit integer formats that raise an
|
||||
| invalid exception.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define ui64_fromNegOverflow UINT64_C(0x0)
|
||||
#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
|
||||
#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
|
||||
#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
|
||||
#define i64_fromNaN INT64_C(0x7FFFFFFFFFFFFFFF)
|
||||
#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define ui64_fromNegOverflow 0
|
||||
#define ui64_fromNaN UINT64_C( 0xFFFFFFFFFFFFFFFF )
|
||||
#define i64_fromPosOverflow INT64_C( 0x7FFFFFFFFFFFFFFF )
|
||||
#define i64_fromNegOverflow (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
|
||||
#define i64_fromNaN INT64_C( 0x7FFFFFFFFFFFFFFF )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| "Common NaN" structure, used to transfer NaN representations from one format
|
||||
| to another.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct commonNaN {
|
||||
bool sign;
|
||||
#ifdef LITTLEENDIAN
|
||||
uint64_t v0, v64;
|
||||
#else
|
||||
uint64_t v64, v0;
|
||||
#endif
|
||||
};
|
||||
struct commonNaN { char _unused; };
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 16-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF16UI 0xFE00
|
||||
#define defaultNaNF16UI 0x7E00
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
|
||||
#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 16-bit brain floating-point (BF16) signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNBF16UI( uiA ) ((((uiA) & 0x7FC0) == 0x7F80) && ((uiA) & 0x003F))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
|
||||
@ -100,13 +100,21 @@ struct commonNaN {
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
|
||||
#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 16-bit BF16 floating-point NaN, converts
|
||||
| this NaN to the common NaN form, and stores the resulting common NaN at the
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_bf16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0040) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
|
||||
@ -114,7 +122,19 @@ uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
uint_fast16_t
|
||||
softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 16-bit BF16 floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNBF16UI 0x7FC0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_commonNaNToBF16UI( aPtr ) ((uint_fast16_t) defaultNaNBF16UI)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 32-bit floating-point NaN.
|
||||
@ -126,7 +146,7 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| 32-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
|
||||
#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
|
||||
@ -134,13 +154,13 @@ uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
|
||||
#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
|
||||
@ -148,20 +168,20 @@ uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
uint_fast32_t
|
||||
softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 64-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
|
||||
#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
|
||||
| 64-bit floating-point signaling NaN.
|
||||
| Note: This macro evaluates its argument more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF64UI(uiA) \
|
||||
((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
|
||||
@ -169,13 +189,13 @@ uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
|
||||
#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI)
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
|
||||
@ -183,13 +203,14 @@ uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
|
||||
| the combined NaN result. If either 'uiA' or 'uiB' has the pattern of a
|
||||
| signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
uint_fast64_t
|
||||
softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 80-bit extended floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNExtF80UI64 0xFFFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
|
||||
#define defaultNaNExtF80UI64 0x7FFF
|
||||
#define defaultNaNExtF80UI0 UINT64_C( 0xC000000000000000 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 80-bit unsigned integer formed from concatenating
|
||||
@ -197,8 +218,7 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| floating-point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNExtF80UI(uiA64, uiA0) \
|
||||
((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
|
||||
#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
@ -214,14 +234,25 @@ uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
|
||||
| location pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and returns the bit pattern of this value as an unsigned
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI
|
||||
INLINE
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
uiZ.v64 = defaultNaNExtF80UI64;
|
||||
uiZ.v0 = defaultNaNExtF80UI0;
|
||||
return uiZ;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -232,13 +263,19 @@ struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
|
||||
| result. If either original floating-point value is a signaling NaN, the
|
||||
| invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNExtF80UI(
|
||||
uint_fast16_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast16_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
|
||||
#define defaultNaNF128UI0 UINT64_C(0)
|
||||
#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
|
||||
#define defaultNaNF128UI0 UINT64_C( 0 )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns true when the 128-bit unsigned integer formed from concatenating
|
||||
@ -246,8 +283,7 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| point signaling NaN.
|
||||
| Note: This macro evaluates its arguments more than once.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_isSigNaNF128UI(uiA64, uiA0) \
|
||||
((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
|
||||
#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
|
||||
@ -256,13 +292,24 @@ struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t
|
||||
| pointed to by 'zPtr'. If the NaN is a signaling NaN, the invalid exception
|
||||
| is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
|
||||
#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
| NaN, and returns the bit pattern of this value as an unsigned integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToF128UI
|
||||
INLINE
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
|
||||
{
|
||||
struct uint128 uiZ;
|
||||
uiZ.v64 = defaultNaNF128UI64;
|
||||
uiZ.v0 = defaultNaNF128UI0;
|
||||
return uiZ;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Interpreting the unsigned integer formed from concatenating 'uiA64' and
|
||||
@ -273,7 +320,13 @@ struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
|
||||
| If either original floating-point value is a signaling NaN, the invalid
|
||||
| exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
|
||||
struct uint128
|
||||
softfloat_propagateNaNF128UI(
|
||||
uint_fast64_t uiA64,
|
||||
uint_fast64_t uiA0,
|
||||
uint_fast64_t uiB64,
|
||||
uint_fast64_t uiB0
|
||||
);
|
||||
|
||||
#else
|
||||
|
||||
@ -288,14 +341,27 @@ struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t u
|
||||
| common NaN at the location pointed to by 'zPtr'. If the NaN is a signaling
|
||||
| NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
|
||||
#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
|
||||
| floating-point NaN, and stores this NaN at the location pointed to by
|
||||
| 'zSPtr'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToExtF80M
|
||||
INLINE
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
|
||||
{
|
||||
zSPtr->signExp = defaultNaNExtF80UI64;
|
||||
zSPtr->signif = defaultNaNExtF80UI0;
|
||||
}
|
||||
#else
|
||||
void
|
||||
softfloat_commonNaNToExtF80M(
|
||||
const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 80-bit extended floating-point values
|
||||
@ -303,15 +369,20 @@ void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat8
|
||||
| at the location pointed to by 'zSPtr'. If either original floating-point
|
||||
| value is a signaling NaN, the invalid exception is raised.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
|
||||
void
|
||||
softfloat_propagateNaNExtF80M(
|
||||
const struct extFloat80M *aSPtr,
|
||||
const struct extFloat80M *bSPtr,
|
||||
struct extFloat80M *zSPtr
|
||||
);
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The bit pattern for a default generated 128-bit floating-point NaN.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define defaultNaNF128UI96 0xFFFF8000
|
||||
#define defaultNaNF128UI96 0x7FFF8000
|
||||
#define defaultNaNF128UI64 0
|
||||
#define defaultNaNF128UI32 0
|
||||
#define defaultNaNF128UI0 0
|
||||
#define defaultNaNF128UI0 0
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
|
||||
@ -321,7 +392,7 @@ void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct
|
||||
| four 32-bit elements that concatenate in the platform's normal endian order
|
||||
| to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
|
||||
@ -329,7 +400,20 @@ void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
|
||||
| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
#if defined INLINE && ! defined softfloat_commonNaNToF128M
|
||||
INLINE
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
|
||||
{
|
||||
zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
|
||||
zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
|
||||
zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
|
||||
zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
|
||||
}
|
||||
#else
|
||||
void
|
||||
softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Assuming at least one of the two 128-bit floating-point values pointed to by
|
||||
@ -339,8 +423,11 @@ void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
|
||||
| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form a 128-bit floating-point value.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
|
||||
void
|
||||
softfloat_propagateNaNF128M(
|
||||
const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
51
softfloat/source/bf16_isSignalingNaN.c
Normal file
51
softfloat/source/bf16_isSignalingNaN.c
Normal file
@ -0,0 +1,51 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
bool bf16_isSignalingNaN( bfloat16_t a )
|
||||
{
|
||||
union ui16_bf16 uA;
|
||||
|
||||
uA.f = a;
|
||||
return softfloat_isSigNaNBF16UI( uA.ui );
|
||||
|
||||
}
|
||||
|
90
softfloat/source/bf16_to_f32.c
Normal file
90
softfloat/source/bf16_to_f32.c
Normal file
@ -0,0 +1,90 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
float32_t bf16_to_f32( bfloat16_t a )
|
||||
{
|
||||
union ui16_bf16 uA;
|
||||
uint_fast16_t uiA;
|
||||
bool sign;
|
||||
int_fast16_t exp;
|
||||
uint_fast16_t frac;
|
||||
struct commonNaN commonNaN;
|
||||
uint_fast32_t uiZ;
|
||||
struct exp8_sig16 normExpSig;
|
||||
union ui32_f32 uZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
uA.f = a;
|
||||
uiA = uA.ui;
|
||||
sign = signBF16UI( uiA );
|
||||
exp = expBF16UI( uiA );
|
||||
frac = fracBF16UI( uiA );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
// NaN or Inf
|
||||
if ( exp == 0xFF ) {
|
||||
if ( frac ) {
|
||||
softfloat_bf16UIToCommonNaN( uiA, &commonNaN );
|
||||
uiZ = softfloat_commonNaNToF32UI( &commonNaN );
|
||||
} else {
|
||||
uiZ = packToF32UI( sign, 0xFF, 0 );
|
||||
}
|
||||
goto uiZ;
|
||||
}
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
// packToF32UI simply packs bitfields without any numerical change
|
||||
// which means it can be used directly for any BF16 to f32 conversions which
|
||||
// does not require bits manipulation
|
||||
// (that is everything where the 16-bit are just padded right with 16 zeros, including
|
||||
// subnormal numbers)
|
||||
uiZ = packToF32UI( sign, exp, ((uint_fast32_t) frac) <<16 );
|
||||
uiZ:
|
||||
uZ.ui = uiZ;
|
||||
return uZ.f;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
105
softfloat/source/f32_to_bf16.c
Normal file
105
softfloat/source/f32_to_bf16.c
Normal file
@ -0,0 +1,105 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "specialize.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdio.h>
|
||||
|
||||
bfloat16_t f32_to_bf16( float32_t a )
|
||||
{
|
||||
union ui32_f32 uA;
|
||||
uint_fast32_t uiA;
|
||||
bool sign;
|
||||
int_fast16_t exp;
|
||||
uint_fast32_t frac;
|
||||
struct commonNaN commonNaN;
|
||||
uint_fast16_t uiZ, frac16;
|
||||
union ui16_bf16 uZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
uA.f = a;
|
||||
uiA = uA.ui;
|
||||
sign = signF32UI( uiA );
|
||||
exp = expF32UI( uiA );
|
||||
frac = fracF32UI( uiA );
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
// infinity or NaN cases
|
||||
if ( exp == 0xFF ) {
|
||||
if ( frac ) {
|
||||
// NaN case
|
||||
softfloat_f32UIToCommonNaN( uiA, &commonNaN );
|
||||
uiZ = softfloat_commonNaNToBF16UI( &commonNaN );
|
||||
} else {
|
||||
// infinity case
|
||||
uiZ = packToBF16UI( sign, 0xFF, 0 );
|
||||
}
|
||||
goto uiZ;
|
||||
}
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
// frac is a 24-bit mantissa, right shifted by 9
|
||||
// In the normal case, (24-9) = 15 are set
|
||||
frac16 = frac>>9 | ((frac & 0x1FF) != 0);
|
||||
if ( ! (exp | frac16) ) {
|
||||
uiZ = packToBF16UI( sign, 0, 0 );
|
||||
goto uiZ;
|
||||
}
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
// softfloat_roundPackToBF16 exponent argument (2nd argument)
|
||||
// must correspond to the exponent of fracIn[13] bits
|
||||
// (fracIn is the 3rd and last argument)
|
||||
uint_fast32_t mask = exp ? 0x4000 : 0x0; // implicit one mask added if input is a normal number
|
||||
// exponent for the lowest normal and largest subnormal should be equal
|
||||
// but is not in IEEE encoding so mantissa must be partially normalized
|
||||
// (by one bit) for subnormal numbers. Such that (exp - 1) corresponds
|
||||
// to the exponent of frac16[13]
|
||||
frac16 = frac16 << (exp ? 0 : 1);
|
||||
return softfloat_roundPackToBF16( sign, exp - 1, frac16 | mask );
|
||||
uiZ:
|
||||
uZ.ui = uiZ;
|
||||
return uZ.f;
|
||||
|
||||
}
|
||||
|
@ -72,6 +72,9 @@ float16_t f32_to_f16( float32_t a )
|
||||
}
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
// frac is a 24-bit significand, the bottom 9 bits LSB are extracted and OR-red
|
||||
// into a sticky flag, the top 15 MSBs are extracted, the LSB of this top slice
|
||||
// is OR-red with the sticky
|
||||
frac16 = frac>>9 | ((frac & 0x1FF) != 0);
|
||||
if ( ! (exp | frac16) ) {
|
||||
uiZ = packToF16UI( sign, 0, 0 );
|
||||
|
@ -37,205 +37,255 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifndef internals_h
|
||||
#define internals_h 1
|
||||
|
||||
#include "primitives.h"
|
||||
#include "softfloat_types.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "primitives.h"
|
||||
#include "softfloat_types.h"
|
||||
|
||||
union ui16_f16 {
|
||||
uint16_t ui;
|
||||
float16_t f;
|
||||
};
|
||||
union ui32_f32 {
|
||||
uint32_t ui;
|
||||
float32_t f;
|
||||
};
|
||||
union ui64_f64 {
|
||||
uint64_t ui;
|
||||
float64_t f;
|
||||
};
|
||||
union ui16_f16 { uint16_t ui; float16_t f; };
|
||||
union ui16_bf16 { uint16_t ui; bfloat16_t f; };
|
||||
union ui32_f32 { uint32_t ui; float32_t f; };
|
||||
union ui64_f64 { uint64_t ui; float64_t f; };
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
union extF80M_extF80 {
|
||||
struct extFloat80M fM;
|
||||
extFloat80_t f;
|
||||
};
|
||||
union ui128_f128 {
|
||||
struct uint128 ui;
|
||||
float128_t f;
|
||||
};
|
||||
union extF80M_extF80 { struct extFloat80M fM; extFloat80_t f; };
|
||||
union ui128_f128 { struct uint128 ui; float128_t f; };
|
||||
#endif
|
||||
|
||||
enum { softfloat_mulAdd_subC = 1, softfloat_mulAdd_subProd = 2 };
|
||||
enum {
|
||||
softfloat_mulAdd_subC = 1,
|
||||
softfloat_mulAdd_subProd = 2
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_roundToUI32(bool, uint_fast64_t, uint_fast8_t, bool);
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool );
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
uint_fast64_t softfloat_roundToUI64(bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool);
|
||||
uint_fast64_t
|
||||
softfloat_roundToUI64(
|
||||
bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
|
||||
#else
|
||||
uint_fast64_t softfloat_roundMToUI64(bool, uint32_t*, uint_fast8_t, bool);
|
||||
uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool );
|
||||
#endif
|
||||
|
||||
int_fast32_t softfloat_roundToI32(bool, uint_fast64_t, uint_fast8_t, bool);
|
||||
int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
int_fast64_t softfloat_roundToI64(bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool);
|
||||
int_fast64_t
|
||||
softfloat_roundToI64(
|
||||
bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
|
||||
#else
|
||||
int_fast64_t softfloat_roundMToI64(bool, uint32_t*, uint_fast8_t, bool);
|
||||
int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF16UI(a) ((bool)((uint16_t)(a) >> 15))
|
||||
#define expF16UI(a) ((int_fast8_t)((a) >> 10) & 0x1F)
|
||||
#define fracF16UI(a) ((a)&0x03FF)
|
||||
#define packToF16UI(sign, exp, sig) (((uint16_t)(sign) << 15) + ((uint16_t)(exp) << 10) + (sig))
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF16UI( a ) ((bool) ((uint16_t) (a)>>15))
|
||||
#define expF16UI( a ) ((int_fast8_t) ((a)>>10) & 0x1F)
|
||||
#define fracF16UI( a ) ((a) & 0x03FF)
|
||||
#define packToF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<10) + (sig))
|
||||
|
||||
#define isNaNF16UI(a) (((~(a)&0x7C00) == 0) && ((a)&0x03FF))
|
||||
#define isNaNF16UI( a ) (((~(a) & 0x7C00) == 0) && ((a) & 0x03FF))
|
||||
|
||||
struct exp8_sig16 {
|
||||
int_fast8_t exp;
|
||||
uint_fast16_t sig;
|
||||
};
|
||||
struct exp8_sig16 softfloat_normSubnormalF16Sig(uint_fast16_t);
|
||||
struct exp8_sig16 { int_fast8_t exp; uint_fast16_t sig; };
|
||||
struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t );
|
||||
|
||||
float16_t softfloat_roundPackToF16(bool, int_fast16_t, uint_fast16_t);
|
||||
float16_t softfloat_normRoundPackToF16(bool, int_fast16_t, uint_fast16_t);
|
||||
float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t );
|
||||
float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t );
|
||||
|
||||
float16_t softfloat_addMagsF16(uint_fast16_t, uint_fast16_t);
|
||||
float16_t softfloat_subMagsF16(uint_fast16_t, uint_fast16_t);
|
||||
float16_t softfloat_mulAddF16(uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t);
|
||||
float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t );
|
||||
float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t );
|
||||
float16_t
|
||||
softfloat_mulAddF16(
|
||||
uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF32UI(a) ((bool)((uint32_t)(a) >> 31))
|
||||
#define expF32UI(a) ((int_fast16_t)((a) >> 23) & 0xFF)
|
||||
#define fracF32UI(a) ((a)&0x007FFFFF)
|
||||
#define packToF32UI(sign, exp, sig) (((uint32_t)(sign) << 31) + ((uint32_t)(exp) << 23) + (sig))
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signBF16UI( a ) ((bool) ((uint16_t) (a)>>15))
|
||||
#define expBF16UI( a ) ((int_fast16_t) ((a)>>7) & 0xFF)
|
||||
#define fracBF16UI( a ) ((a) & 0x07F)
|
||||
#define packToBF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<7) + (sig))
|
||||
|
||||
#define isNaNF32UI(a) (((~(a)&0x7F800000) == 0) && ((a)&0x007FFFFF))
|
||||
#define isNaNBF16UI( a ) (((~(a) & 0x7FC0) == 0) && ((a) & 0x07F))
|
||||
|
||||
struct exp16_sig32 {
|
||||
int_fast16_t exp;
|
||||
uint_fast32_t sig;
|
||||
};
|
||||
struct exp16_sig32 softfloat_normSubnormalF32Sig(uint_fast32_t);
|
||||
|
||||
float32_t softfloat_roundPackToF32(bool, int_fast16_t, uint_fast32_t);
|
||||
float32_t softfloat_normRoundPackToF32(bool, int_fast16_t, uint_fast32_t);
|
||||
|
||||
float32_t softfloat_addMagsF32(uint_fast32_t, uint_fast32_t);
|
||||
float32_t softfloat_subMagsF32(uint_fast32_t, uint_fast32_t);
|
||||
float32_t softfloat_mulAddF32(uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t);
|
||||
bfloat16_t softfloat_roundPackToBF16( bool, int_fast16_t, uint_fast16_t );
|
||||
struct exp8_sig16 softfloat_normSubnormalBF16Sig( uint_fast16_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF64UI(a) ((bool)((uint64_t)(a) >> 63))
|
||||
#define expF64UI(a) ((int_fast16_t)((a) >> 52) & 0x7FF)
|
||||
#define fracF64UI(a) ((a)&UINT64_C(0x000FFFFFFFFFFFFF))
|
||||
#define packToF64UI(sign, exp, sig) ((uint64_t)(((uint_fast64_t)(sign) << 63) + ((uint_fast64_t)(exp) << 52) + (sig)))
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF32UI( a ) ((bool) ((uint32_t) (a)>>31))
|
||||
#define expF32UI( a ) ((int_fast16_t) ((a)>>23) & 0xFF)
|
||||
#define fracF32UI( a ) ((a) & 0x007FFFFF)
|
||||
#define packToF32UI( sign, exp, sig ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig))
|
||||
|
||||
#define isNaNF64UI(a) (((~(a)&UINT64_C(0x7FF0000000000000)) == 0) && ((a)&UINT64_C(0x000FFFFFFFFFFFFF)))
|
||||
#define isNaNF32UI( a ) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF))
|
||||
|
||||
struct exp16_sig64 {
|
||||
int_fast16_t exp;
|
||||
uint_fast64_t sig;
|
||||
};
|
||||
struct exp16_sig64 softfloat_normSubnormalF64Sig(uint_fast64_t);
|
||||
struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; };
|
||||
struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );
|
||||
|
||||
float64_t softfloat_roundPackToF64(bool, int_fast16_t, uint_fast64_t);
|
||||
float64_t softfloat_normRoundPackToF64(bool, int_fast16_t, uint_fast64_t);
|
||||
float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );
|
||||
float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );
|
||||
|
||||
float64_t softfloat_addMagsF64(uint_fast64_t, uint_fast64_t, bool);
|
||||
float64_t softfloat_subMagsF64(uint_fast64_t, uint_fast64_t, bool);
|
||||
float64_t softfloat_mulAddF64(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
|
||||
float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );
|
||||
float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );
|
||||
float32_t
|
||||
softfloat_mulAddF32(
|
||||
uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signExtF80UI64(a64) ((bool)((uint16_t)(a64) >> 15))
|
||||
#define expExtF80UI64(a64) ((a64)&0x7FFF)
|
||||
#define packToExtF80UI64(sign, exp) ((uint_fast16_t)(sign) << 15 | (exp))
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF64UI( a ) ((bool) ((uint64_t) (a)>>63))
|
||||
#define expF64UI( a ) ((int_fast16_t) ((a)>>52) & 0x7FF)
|
||||
#define fracF64UI( a ) ((a) & UINT64_C( 0x000FFFFFFFFFFFFF ))
|
||||
#define packToF64UI( sign, exp, sig ) ((uint64_t) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<52) + (sig)))
|
||||
|
||||
#define isNaNExtF80UI(a64, a0) ((((a64)&0x7FFF) == 0x7FFF) && ((a0)&UINT64_C(0x7FFFFFFFFFFFFFFF)))
|
||||
#define isNaNF64UI( a ) (((~(a) & UINT64_C( 0x7FF0000000000000 )) == 0) && ((a) & UINT64_C( 0x000FFFFFFFFFFFFF )))
|
||||
|
||||
struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; };
|
||||
struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );
|
||||
|
||||
float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );
|
||||
float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );
|
||||
|
||||
float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );
|
||||
float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );
|
||||
float64_t
|
||||
softfloat_mulAddF64(
|
||||
uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signExtF80UI64( a64 ) ((bool) ((uint16_t) (a64)>>15))
|
||||
#define expExtF80UI64( a64 ) ((a64) & 0x7FFF)
|
||||
#define packToExtF80UI64( sign, exp ) ((uint_fast16_t) (sign)<<15 | (exp))
|
||||
|
||||
#define isNaNExtF80UI( a64, a0 ) ((((a64) & 0x7FFF) == 0x7FFF) && ((a0) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
struct exp32_sig64 {
|
||||
int_fast32_t exp;
|
||||
uint64_t sig;
|
||||
};
|
||||
struct exp32_sig64 softfloat_normSubnormalExtF80Sig(uint_fast64_t);
|
||||
struct exp32_sig64 { int_fast32_t exp; uint64_t sig; };
|
||||
struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t );
|
||||
|
||||
extFloat80_t softfloat_roundPackToExtF80(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
|
||||
extFloat80_t softfloat_normRoundPackToExtF80(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
|
||||
extFloat80_t
|
||||
softfloat_roundPackToExtF80(
|
||||
bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
|
||||
extFloat80_t
|
||||
softfloat_normRoundPackToExtF80(
|
||||
bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
|
||||
|
||||
extFloat80_t softfloat_addMagsExtF80(uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool);
|
||||
extFloat80_t softfloat_subMagsExtF80(uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool);
|
||||
extFloat80_t
|
||||
softfloat_addMagsExtF80(
|
||||
uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
|
||||
extFloat80_t
|
||||
softfloat_subMagsExtF80(
|
||||
uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF128UI64(a64) ((bool)((uint64_t)(a64) >> 63))
|
||||
#define expF128UI64(a64) ((int_fast32_t)((a64) >> 48) & 0x7FFF)
|
||||
#define fracF128UI64(a64) ((a64)&UINT64_C(0x0000FFFFFFFFFFFF))
|
||||
#define packToF128UI64(sign, exp, sig64) (((uint_fast64_t)(sign) << 63) + ((uint_fast64_t)(exp) << 48) + (sig64))
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF128UI64( a64 ) ((bool) ((uint64_t) (a64)>>63))
|
||||
#define expF128UI64( a64 ) ((int_fast32_t) ((a64)>>48) & 0x7FFF)
|
||||
#define fracF128UI64( a64 ) ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))
|
||||
#define packToF128UI64( sign, exp, sig64 ) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<48) + (sig64))
|
||||
|
||||
#define isNaNF128UI(a64, a0) (((~(a64)&UINT64_C(0x7FFF000000000000)) == 0) && (a0 || ((a64)&UINT64_C(0x0000FFFFFFFFFFFF))))
|
||||
#define isNaNF128UI( a64, a0 ) (((~(a64) & UINT64_C( 0x7FFF000000000000 )) == 0) && (a0 || ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))))
|
||||
|
||||
struct exp32_sig128 {
|
||||
int_fast32_t exp;
|
||||
struct uint128 sig;
|
||||
};
|
||||
struct exp32_sig128 softfloat_normSubnormalF128Sig(uint_fast64_t, uint_fast64_t);
|
||||
struct exp32_sig128 { int_fast32_t exp; struct uint128 sig; };
|
||||
struct exp32_sig128
|
||||
softfloat_normSubnormalF128Sig( uint_fast64_t, uint_fast64_t );
|
||||
|
||||
float128_t softfloat_roundPackToF128(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t);
|
||||
float128_t softfloat_normRoundPackToF128(bool, int_fast32_t, uint_fast64_t, uint_fast64_t);
|
||||
float128_t
|
||||
softfloat_roundPackToF128(
|
||||
bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t );
|
||||
float128_t
|
||||
softfloat_normRoundPackToF128(
|
||||
bool, int_fast32_t, uint_fast64_t, uint_fast64_t );
|
||||
|
||||
float128_t softfloat_addMagsF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool);
|
||||
float128_t softfloat_subMagsF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool);
|
||||
float128_t softfloat_mulAddF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
|
||||
float128_t
|
||||
softfloat_addMagsF128(
|
||||
uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
|
||||
float128_t
|
||||
softfloat_subMagsF128(
|
||||
uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
|
||||
float128_t
|
||||
softfloat_mulAddF128(
|
||||
uint_fast64_t,
|
||||
uint_fast64_t,
|
||||
uint_fast64_t,
|
||||
uint_fast64_t,
|
||||
uint_fast64_t,
|
||||
uint_fast64_t,
|
||||
uint_fast8_t
|
||||
);
|
||||
|
||||
#else
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
*----------------------------------------------------------------------------*/
|
||||
|
||||
bool softfloat_tryPropagateNaNExtF80M(const struct extFloat80M*, const struct extFloat80M*, struct extFloat80M*);
|
||||
void softfloat_invalidExtF80M(struct extFloat80M*);
|
||||
bool
|
||||
softfloat_tryPropagateNaNExtF80M(
|
||||
const struct extFloat80M *,
|
||||
const struct extFloat80M *,
|
||||
struct extFloat80M *
|
||||
);
|
||||
void softfloat_invalidExtF80M( struct extFloat80M * );
|
||||
|
||||
int softfloat_normExtF80SigM(uint64_t*);
|
||||
int softfloat_normExtF80SigM( uint64_t * );
|
||||
|
||||
void softfloat_roundPackMToExtF80M(bool, int32_t, uint32_t*, uint_fast8_t, struct extFloat80M*);
|
||||
void softfloat_normRoundPackMToExtF80M(bool, int32_t, uint32_t*, uint_fast8_t, struct extFloat80M*);
|
||||
void
|
||||
softfloat_roundPackMToExtF80M(
|
||||
bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
|
||||
void
|
||||
softfloat_normRoundPackMToExtF80M(
|
||||
bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
|
||||
|
||||
void softfloat_addExtF80M(const struct extFloat80M*, const struct extFloat80M*, struct extFloat80M*, bool);
|
||||
void
|
||||
softfloat_addExtF80M(
|
||||
const struct extFloat80M *,
|
||||
const struct extFloat80M *,
|
||||
struct extFloat80M *,
|
||||
bool
|
||||
);
|
||||
|
||||
int softfloat_compareNonnormExtF80M(const struct extFloat80M*, const struct extFloat80M*);
|
||||
int
|
||||
softfloat_compareNonnormExtF80M(
|
||||
const struct extFloat80M *, const struct extFloat80M * );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF128UI96(a96) ((bool)((uint32_t)(a96) >> 31))
|
||||
#define expF128UI96(a96) ((int32_t)((a96) >> 16) & 0x7FFF)
|
||||
#define fracF128UI96(a96) ((a96)&0x0000FFFF)
|
||||
#define packToF128UI96(sign, exp, sig96) (((uint32_t)(sign) << 31) + ((uint32_t)(exp) << 16) + (sig96))
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define signF128UI96( a96 ) ((bool) ((uint32_t) (a96)>>31))
|
||||
#define expF128UI96( a96 ) ((int32_t) ((a96)>>16) & 0x7FFF)
|
||||
#define fracF128UI96( a96 ) ((a96) & 0x0000FFFF)
|
||||
#define packToF128UI96( sign, exp, sig96 ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<16) + (sig96))
|
||||
|
||||
bool softfloat_isNaNF128M(const uint32_t*);
|
||||
bool softfloat_isNaNF128M( const uint32_t * );
|
||||
|
||||
bool softfloat_tryPropagateNaNF128M(const uint32_t*, const uint32_t*, uint32_t*);
|
||||
void softfloat_invalidF128M(uint32_t*);
|
||||
bool
|
||||
softfloat_tryPropagateNaNF128M(
|
||||
const uint32_t *, const uint32_t *, uint32_t * );
|
||||
void softfloat_invalidF128M( uint32_t * );
|
||||
|
||||
int softfloat_shiftNormSigF128M(const uint32_t*, uint_fast8_t, uint32_t*);
|
||||
int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * );
|
||||
|
||||
void softfloat_roundPackMToF128M(bool, int32_t, uint32_t*, uint32_t*);
|
||||
void softfloat_normRoundPackMToF128M(bool, int32_t, uint32_t*, uint32_t*);
|
||||
void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
|
||||
void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
|
||||
|
||||
void softfloat_addF128M(const uint32_t*, const uint32_t*, uint32_t*, bool);
|
||||
void softfloat_mulAddF128M(const uint32_t*, const uint32_t*, const uint32_t*, uint32_t*, uint_fast8_t);
|
||||
void
|
||||
softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool );
|
||||
void
|
||||
softfloat_mulAddF128M(
|
||||
const uint32_t *,
|
||||
const uint32_t *,
|
||||
const uint32_t *,
|
||||
uint32_t *,
|
||||
uint_fast8_t
|
||||
);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -42,27 +42,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
|
||||
#ifdef LITTLEENDIAN
|
||||
struct uint128 {
|
||||
uint64_t v0, v64;
|
||||
};
|
||||
struct uint64_extra {
|
||||
uint64_t extra, v;
|
||||
};
|
||||
struct uint128_extra {
|
||||
uint64_t extra;
|
||||
struct uint128 v;
|
||||
};
|
||||
struct uint128 { uint64_t v0, v64; };
|
||||
struct uint64_extra { uint64_t extra, v; };
|
||||
struct uint128_extra { uint64_t extra; struct uint128 v; };
|
||||
#else
|
||||
struct uint128 {
|
||||
uint64_t v64, v0;
|
||||
};
|
||||
struct uint64_extra {
|
||||
uint64_t v, extra;
|
||||
};
|
||||
struct uint128_extra {
|
||||
struct uint128 v;
|
||||
uint64_t extra;
|
||||
};
|
||||
struct uint128 { uint64_t v64, v0; };
|
||||
struct uint64_extra { uint64_t v, extra; };
|
||||
struct uint128_extra { struct uint128 v; uint64_t extra; };
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -73,28 +59,27 @@ struct uint128_extra {
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef LITTLEENDIAN
|
||||
#define wordIncr 1
|
||||
#define indexWord(total, n) (n)
|
||||
#define indexWordHi(total) ((total)-1)
|
||||
#define indexWordLo(total) 0
|
||||
#define indexMultiword(total, m, n) (n)
|
||||
#define indexMultiwordHi(total, n) ((total) - (n))
|
||||
#define indexMultiwordLo(total, n) 0
|
||||
#define indexMultiwordHiBut(total, n) (n)
|
||||
#define indexMultiwordLoBut(total, n) 0
|
||||
#define INIT_UINTM4(v3, v2, v1, v0) \
|
||||
{ v0, v1, v2, v3 }
|
||||
#define indexWord( total, n ) (n)
|
||||
#define indexWordHi( total ) ((total) - 1)
|
||||
#define indexWordLo( total ) 0
|
||||
#define indexMultiword( total, m, n ) (n)
|
||||
#define indexMultiwordHi( total, n ) ((total) - (n))
|
||||
#define indexMultiwordLo( total, n ) 0
|
||||
#define indexMultiwordHiBut( total, n ) (n)
|
||||
#define indexMultiwordLoBut( total, n ) 0
|
||||
#define INIT_UINTM4( v3, v2, v1, v0 ) { v0, v1, v2, v3 }
|
||||
#else
|
||||
#define wordIncr -1
|
||||
#define indexWord(total, n) ((total)-1 - (n))
|
||||
#define indexWordHi(total) 0
|
||||
#define indexWordLo(total) ((total)-1)
|
||||
#define indexMultiword(total, m, n) ((total)-1 - (m))
|
||||
#define indexMultiwordHi(total, n) 0
|
||||
#define indexMultiwordLo(total, n) ((total) - (n))
|
||||
#define indexMultiwordHiBut(total, n) 0
|
||||
#define indexMultiwordLoBut(total, n) (n)
|
||||
#define INIT_UINTM4(v3, v2, v1, v0) \
|
||||
{ v3, v2, v1, v0 }
|
||||
#define indexWord( total, n ) ((total) - 1 - (n))
|
||||
#define indexWordHi( total ) 0
|
||||
#define indexWordLo( total ) ((total) - 1)
|
||||
#define indexMultiword( total, m, n ) ((total) - 1 - (m))
|
||||
#define indexMultiwordHi( total, n ) 0
|
||||
#define indexMultiwordLo( total, n ) ((total) - (n))
|
||||
#define indexMultiwordHiBut( total, n ) 0
|
||||
#define indexMultiwordLoBut( total, n ) (n)
|
||||
#define INIT_UINTM4( v3, v2, v1, v0 ) { v3, v2, v1, v0 }
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -37,9 +37,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#ifndef primitives_h
|
||||
#define primitives_h 1
|
||||
|
||||
#include "primitiveTypes.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "primitiveTypes.h"
|
||||
|
||||
#ifndef softfloat_shortShiftRightJam64
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -50,9 +50,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist) { return a >> dist | ((a & (((uint_fast64_t)1 << dist) - 1)) != 0); }
|
||||
uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )
|
||||
{ return a>>dist | ((a & (((uint_fast64_t) 1<<dist) - 1)) != 0); }
|
||||
#else
|
||||
uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist);
|
||||
uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -67,11 +68,13 @@ uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist);
|
||||
| is zero or nonzero.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE uint32_t softfloat_shiftRightJam32(uint32_t a, uint_fast16_t dist) {
|
||||
return (dist < 31) ? a >> dist | ((uint32_t)(a << (-dist & 31)) != 0) : (a != 0);
|
||||
INLINE uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist )
|
||||
{
|
||||
return
|
||||
(dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);
|
||||
}
|
||||
#else
|
||||
uint32_t softfloat_shiftRightJam32(uint32_t a, uint_fast16_t dist);
|
||||
uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -86,11 +89,13 @@ uint32_t softfloat_shiftRightJam32(uint32_t a, uint_fast16_t dist);
|
||||
| is zero or nonzero.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
|
||||
INLINE uint64_t softfloat_shiftRightJam64(uint64_t a, uint_fast32_t dist) {
|
||||
return (dist < 63) ? a >> dist | ((uint64_t)(a << (-dist & 63)) != 0) : (a != 0);
|
||||
INLINE uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )
|
||||
{
|
||||
return
|
||||
(dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);
|
||||
}
|
||||
#else
|
||||
uint64_t softfloat_shiftRightJam64(uint64_t a, uint_fast32_t dist);
|
||||
uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -107,9 +112,10 @@ extern const uint_least8_t softfloat_countLeadingZeros8[256];
|
||||
| 'a'. If 'a' is zero, 16 is returned.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE uint_fast8_t softfloat_countLeadingZeros16(uint16_t a) {
|
||||
INLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )
|
||||
{
|
||||
uint_fast8_t count = 8;
|
||||
if(0x100 <= a) {
|
||||
if ( 0x100 <= a ) {
|
||||
count = 0;
|
||||
a >>= 8;
|
||||
}
|
||||
@ -117,7 +123,7 @@ INLINE uint_fast8_t softfloat_countLeadingZeros16(uint16_t a) {
|
||||
return count;
|
||||
}
|
||||
#else
|
||||
uint_fast8_t softfloat_countLeadingZeros16(uint16_t a);
|
||||
uint_fast8_t softfloat_countLeadingZeros16( uint16_t a );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -127,21 +133,22 @@ uint_fast8_t softfloat_countLeadingZeros16(uint16_t a);
|
||||
| 'a'. If 'a' is zero, 32 is returned.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
|
||||
INLINE uint_fast8_t softfloat_countLeadingZeros32(uint32_t a) {
|
||||
INLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )
|
||||
{
|
||||
uint_fast8_t count = 0;
|
||||
if(a < 0x10000) {
|
||||
if ( a < 0x10000 ) {
|
||||
count = 16;
|
||||
a <<= 16;
|
||||
}
|
||||
if(a < 0x1000000) {
|
||||
if ( a < 0x1000000 ) {
|
||||
count += 8;
|
||||
a <<= 8;
|
||||
}
|
||||
count += softfloat_countLeadingZeros8[a >> 24];
|
||||
count += softfloat_countLeadingZeros8[a>>24];
|
||||
return count;
|
||||
}
|
||||
#else
|
||||
uint_fast8_t softfloat_countLeadingZeros32(uint32_t a);
|
||||
uint_fast8_t softfloat_countLeadingZeros32( uint32_t a );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -150,7 +157,7 @@ uint_fast8_t softfloat_countLeadingZeros32(uint32_t a);
|
||||
| Returns the number of leading 0 bits before the most-significant 1 bit of
|
||||
| 'a'. If 'a' is zero, 64 is returned.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast8_t softfloat_countLeadingZeros64(uint64_t a);
|
||||
uint_fast8_t softfloat_countLeadingZeros64( uint64_t a );
|
||||
#endif
|
||||
|
||||
extern const uint16_t softfloat_approxRecip_1k0s[16];
|
||||
@ -169,9 +176,9 @@ extern const uint16_t softfloat_approxRecip_1k1s[16];
|
||||
| (units in the last place).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef SOFTFLOAT_FAST_DIV64TO32
|
||||
#define softfloat_approxRecip32_1(a) ((uint32_t)(UINT64_C(0x7FFFFFFFFFFFFFFF) / (uint32_t)(a)))
|
||||
#define softfloat_approxRecip32_1( a ) ((uint32_t) (UINT64_C( 0x7FFFFFFFFFFFFFFF ) / (uint32_t) (a)))
|
||||
#else
|
||||
uint32_t softfloat_approxRecip32_1(uint32_t a);
|
||||
uint32_t softfloat_approxRecip32_1( uint32_t a );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -197,7 +204,7 @@ extern const uint16_t softfloat_approxRecipSqrt_1k1s[16];
|
||||
| returned is also always within the range 0.5 to 1; thus, the most-
|
||||
| significant bit of the result is always set.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint32_t softfloat_approxRecipSqrt32_1(unsigned int oddExpA, uint32_t a);
|
||||
uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a );
|
||||
#endif
|
||||
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
@ -215,9 +222,10 @@ uint32_t softfloat_approxRecipSqrt32_1(unsigned int oddExpA, uint32_t a);
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
bool softfloat_eq128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 == b64) && (a0 == b0); }
|
||||
bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
|
||||
{ return (a64 == b64) && (a0 == b0); }
|
||||
#else
|
||||
bool softfloat_eq128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -229,9 +237,10 @@ bool softfloat_eq128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
bool softfloat_le128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); }
|
||||
bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
|
||||
{ return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); }
|
||||
#else
|
||||
bool softfloat_le128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -243,9 +252,10 @@ bool softfloat_le128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
bool softfloat_lt128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 < b64) || ((a64 == b64) && (a0 < b0)); }
|
||||
bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
|
||||
{ return (a64 < b64) || ((a64 == b64) && (a0 < b0)); }
|
||||
#else
|
||||
bool softfloat_lt128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -256,14 +266,17 @@ bool softfloat_lt128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint128 softfloat_shortShiftLeft128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
|
||||
struct uint128
|
||||
softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
|
||||
{
|
||||
struct uint128 z;
|
||||
z.v64 = a64 << dist | a0 >> (-dist & 63);
|
||||
z.v0 = a0 << dist;
|
||||
z.v64 = a64<<dist | a0>>(-dist & 63);
|
||||
z.v0 = a0<<dist;
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_shortShiftLeft128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
|
||||
struct uint128
|
||||
softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -274,14 +287,17 @@ struct uint128 softfloat_shortShiftLeft128(uint64_t a64, uint64_t a0, uint_fast8
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint128 softfloat_shortShiftRight128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
|
||||
struct uint128
|
||||
softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
|
||||
{
|
||||
struct uint128 z;
|
||||
z.v64 = a64 >> dist;
|
||||
z.v0 = a64 << (-dist & 63) | a0 >> dist;
|
||||
z.v64 = a64>>dist;
|
||||
z.v0 = a64<<(-dist & 63) | a0>>dist;
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_shortShiftRight128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
|
||||
struct uint128
|
||||
softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -292,14 +308,19 @@ struct uint128 softfloat_shortShiftRight128(uint64_t a64, uint64_t a0, uint_fast
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint64_extra softfloat_shortShiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast8_t dist) {
|
||||
struct uint64_extra
|
||||
softfloat_shortShiftRightJam64Extra(
|
||||
uint64_t a, uint64_t extra, uint_fast8_t dist )
|
||||
{
|
||||
struct uint64_extra z;
|
||||
z.v = a >> dist;
|
||||
z.extra = a << (-dist & 63) | (extra != 0);
|
||||
z.v = a>>dist;
|
||||
z.extra = a<<(-dist & 63) | (extra != 0);
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint64_extra softfloat_shortShiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast8_t dist);
|
||||
struct uint64_extra
|
||||
softfloat_shortShiftRightJam64Extra(
|
||||
uint64_t a, uint64_t extra, uint_fast8_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -313,15 +334,22 @@ struct uint64_extra softfloat_shortShiftRightJam64Extra(uint64_t a, uint64_t ext
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
|
||||
struct uint128
|
||||
softfloat_shortShiftRightJam128(
|
||||
uint64_t a64, uint64_t a0, uint_fast8_t dist )
|
||||
{
|
||||
uint_fast8_t negDist = -dist;
|
||||
struct uint128 z;
|
||||
z.v64 = a64 >> dist;
|
||||
z.v0 = a64 << (negDist & 63) | a0 >> dist | ((uint64_t)(a0 << (negDist & 63)) != 0);
|
||||
z.v64 = a64>>dist;
|
||||
z.v0 =
|
||||
a64<<(negDist & 63) | a0>>dist
|
||||
| ((uint64_t) (a0<<(negDist & 63)) != 0);
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
|
||||
struct uint128
|
||||
softfloat_shortShiftRightJam128(
|
||||
uint64_t a64, uint64_t a0, uint_fast8_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -332,16 +360,21 @@ struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_f
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint128_extra softfloat_shortShiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist) {
|
||||
struct uint128_extra
|
||||
softfloat_shortShiftRightJam128Extra(
|
||||
uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist )
|
||||
{
|
||||
uint_fast8_t negDist = -dist;
|
||||
struct uint128_extra z;
|
||||
z.v.v64 = a64 >> dist;
|
||||
z.v.v0 = a64 << (negDist & 63) | a0 >> dist;
|
||||
z.extra = a0 << (negDist & 63) | (extra != 0);
|
||||
z.v.v64 = a64>>dist;
|
||||
z.v.v0 = a64<<(negDist & 63) | a0>>dist;
|
||||
z.extra = a0<<(negDist & 63) | (extra != 0);
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128_extra softfloat_shortShiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist);
|
||||
struct uint128_extra
|
||||
softfloat_shortShiftRightJam128Extra(
|
||||
uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -364,11 +397,14 @@ struct uint128_extra softfloat_shortShiftRightJam128Extra(uint64_t a64, uint64_t
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast32_t dist) {
|
||||
struct uint64_extra
|
||||
softfloat_shiftRightJam64Extra(
|
||||
uint64_t a, uint64_t extra, uint_fast32_t dist )
|
||||
{
|
||||
struct uint64_extra z;
|
||||
if(dist < 64) {
|
||||
z.v = a >> dist;
|
||||
z.extra = a << (-dist & 63);
|
||||
if ( dist < 64 ) {
|
||||
z.v = a>>dist;
|
||||
z.extra = a<<(-dist & 63);
|
||||
} else {
|
||||
z.v = 0;
|
||||
z.extra = (dist == 64) ? a : (a != 0);
|
||||
@ -377,7 +413,9 @@ struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, u
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast32_t dist);
|
||||
struct uint64_extra
|
||||
softfloat_shiftRightJam64Extra(
|
||||
uint64_t a, uint64_t extra, uint_fast32_t dist );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -392,7 +430,8 @@ struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, u
|
||||
| greater than 128, the result will be either 0 or 1, depending on whether the
|
||||
| original 128 bits are all zeros.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_shiftRightJam128(uint64_t a64, uint64_t a0, uint_fast32_t dist);
|
||||
struct uint128
|
||||
softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRightJam128Extra
|
||||
@ -413,7 +452,9 @@ struct uint128 softfloat_shiftRightJam128(uint64_t a64, uint64_t a0, uint_fast32
|
||||
| is modified as described above and returned in the 'extra' field of the
|
||||
| result.)
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128_extra softfloat_shiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist);
|
||||
struct uint128_extra
|
||||
softfloat_shiftRightJam128Extra(
|
||||
uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRightJam256M
|
||||
@ -429,7 +470,9 @@ struct uint128_extra softfloat_shiftRightJam128Extra(uint64_t a64, uint64_t a0,
|
||||
| is greater than 256, the stored result will be either 0 or 1, depending on
|
||||
| whether the original 256 bits are all zeros.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_shiftRightJam256M(const uint64_t* aPtr, uint_fast32_t dist, uint64_t* zPtr);
|
||||
void
|
||||
softfloat_shiftRightJam256M(
|
||||
const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_add128
|
||||
@ -440,14 +483,17 @@ void softfloat_shiftRightJam256M(const uint64_t* aPtr, uint_fast32_t dist, uint6
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint128 softfloat_add128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) {
|
||||
struct uint128
|
||||
softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
|
||||
{
|
||||
struct uint128 z;
|
||||
z.v0 = a0 + b0;
|
||||
z.v64 = a64 + b64 + (z.v0 < a0);
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_add128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
struct uint128
|
||||
softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -459,7 +505,9 @@ struct uint128 softfloat_add128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_
|
||||
| an array of four 64-bit elements that concatenate in the platform's normal
|
||||
| endian order to form a 256-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_add256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPtr);
|
||||
void
|
||||
softfloat_add256M(
|
||||
const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_sub128
|
||||
@ -470,7 +518,9 @@ void softfloat_add256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPt
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) {
|
||||
struct uint128
|
||||
softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
|
||||
{
|
||||
struct uint128 z;
|
||||
z.v0 = a0 - b0;
|
||||
z.v64 = a64 - b64;
|
||||
@ -478,7 +528,8 @@ struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
|
||||
struct uint128
|
||||
softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -491,7 +542,9 @@ struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_
|
||||
| 64-bit elements that concatenate in the platform's normal endian order to
|
||||
| form a 256-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_sub256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPtr);
|
||||
void
|
||||
softfloat_sub256M(
|
||||
const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_mul64ByShifted32To128
|
||||
@ -499,16 +552,17 @@ void softfloat_sub256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPt
|
||||
| Returns the 128-bit product of 'a', 'b', and 2^32.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
|
||||
INLINE struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b) {
|
||||
INLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )
|
||||
{
|
||||
uint_fast64_t mid;
|
||||
struct uint128 z;
|
||||
mid = (uint_fast64_t)(uint32_t)a * b;
|
||||
z.v0 = mid << 32;
|
||||
z.v64 = (uint_fast64_t)(uint32_t)(a >> 32) * b + (mid >> 32);
|
||||
mid = (uint_fast64_t) (uint32_t) a * b;
|
||||
z.v0 = mid<<32;
|
||||
z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32);
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b);
|
||||
struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -516,7 +570,7 @@ struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b);
|
||||
/*----------------------------------------------------------------------------
|
||||
| Returns the 128-bit product of 'a' and 'b'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
struct uint128 softfloat_mul64To128(uint64_t a, uint64_t b);
|
||||
struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_mul128By32
|
||||
@ -527,18 +581,19 @@ struct uint128 softfloat_mul64To128(uint64_t a, uint64_t b);
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b) {
|
||||
struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )
|
||||
{
|
||||
struct uint128 z;
|
||||
uint_fast64_t mid;
|
||||
uint_fast32_t carry;
|
||||
z.v0 = a0 * b;
|
||||
mid = (uint_fast64_t)(uint32_t)(a0 >> 32) * b;
|
||||
carry = (uint32_t)((uint_fast32_t)(z.v0 >> 32) - (uint_fast32_t)mid);
|
||||
z.v64 = a64 * b + (uint_fast32_t)((mid + carry) >> 32);
|
||||
mid = (uint_fast64_t) (uint32_t) (a0>>32) * b;
|
||||
carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid);
|
||||
z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32);
|
||||
return z;
|
||||
}
|
||||
#else
|
||||
struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b);
|
||||
struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -550,7 +605,9 @@ struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b);
|
||||
| Argument 'zPtr' points to an array of four 64-bit elements that concatenate
|
||||
| in the platform's normal endian order to form a 256-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_mul128To256M(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t* zPtr);
|
||||
void
|
||||
softfloat_mul128To256M(
|
||||
uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr );
|
||||
#endif
|
||||
|
||||
#else
|
||||
@ -569,7 +626,7 @@ void softfloat_mul128To256M(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0
|
||||
| Each of 'aPtr' and 'bPtr' points to an array of three 32-bit elements that
|
||||
| concatenate in the platform's normal endian order to form a 96-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
int_fast8_t softfloat_compare96M(const uint32_t* aPtr, const uint32_t* bPtr);
|
||||
int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_compare128M
|
||||
@ -581,7 +638,8 @@ int_fast8_t softfloat_compare96M(const uint32_t* aPtr, const uint32_t* bPtr);
|
||||
| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that
|
||||
| concatenate in the platform's normal endian order to form a 128-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
int_fast8_t softfloat_compare128M(const uint32_t* aPtr, const uint32_t* bPtr);
|
||||
int_fast8_t
|
||||
softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftLeft64To96M
|
||||
@ -594,14 +652,19 @@ int_fast8_t softfloat_compare128M(const uint32_t* aPtr, const uint32_t* bPtr);
|
||||
*----------------------------------------------------------------------------*/
|
||||
#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
|
||||
INLINE
|
||||
void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t* zPtr) {
|
||||
zPtr[indexWord(3, 0)] = (uint32_t)a << dist;
|
||||
void
|
||||
softfloat_shortShiftLeft64To96M(
|
||||
uint64_t a, uint_fast8_t dist, uint32_t *zPtr )
|
||||
{
|
||||
zPtr[indexWord( 3, 0 )] = (uint32_t) a<<dist;
|
||||
a >>= 32 - dist;
|
||||
zPtr[indexWord(3, 2)] = a >> 32;
|
||||
zPtr[indexWord(3, 1)] = a;
|
||||
zPtr[indexWord( 3, 2 )] = a>>32;
|
||||
zPtr[indexWord( 3, 1 )] = a;
|
||||
}
|
||||
#else
|
||||
void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_shortShiftLeft64To96M(
|
||||
uint64_t a, uint_fast8_t dist, uint32_t *zPtr );
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -615,7 +678,13 @@ void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t* zP
|
||||
| that concatenate in the platform's normal endian order to form an N-bit
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_shortShiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint_fast8_t dist, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_shortShiftLeftM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
uint_fast8_t dist,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftLeft96M
|
||||
@ -623,7 +692,7 @@ void softfloat_shortShiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, ui
|
||||
| This function or macro is the same as 'softfloat_shortShiftLeftM' with
|
||||
| 'size_words' = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shortShiftLeft96M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(3, aPtr, dist, zPtr)
|
||||
#define softfloat_shortShiftLeft96M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 3, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftLeft128M
|
||||
@ -631,7 +700,7 @@ void softfloat_shortShiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, ui
|
||||
| This function or macro is the same as 'softfloat_shortShiftLeftM' with
|
||||
| 'size_words' = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shortShiftLeft128M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(4, aPtr, dist, zPtr)
|
||||
#define softfloat_shortShiftLeft128M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 4, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftLeft160M
|
||||
@ -639,7 +708,7 @@ void softfloat_shortShiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, ui
|
||||
| This function or macro is the same as 'softfloat_shortShiftLeftM' with
|
||||
| 'size_words' = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shortShiftLeft160M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(5, aPtr, dist, zPtr)
|
||||
#define softfloat_shortShiftLeft160M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 5, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftLeftM
|
||||
@ -653,7 +722,13 @@ void softfloat_shortShiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, ui
|
||||
| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is
|
||||
| greater than N, the stored result will be 0.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_shiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_shiftLeftM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
uint32_t dist,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftLeft96M
|
||||
@ -661,7 +736,7 @@ void softfloat_shiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_
|
||||
| This function or macro is the same as 'softfloat_shiftLeftM' with
|
||||
| 'size_words' = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shiftLeft96M(aPtr, dist, zPtr) softfloat_shiftLeftM(3, aPtr, dist, zPtr)
|
||||
#define softfloat_shiftLeft96M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 3, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftLeft128M
|
||||
@ -669,7 +744,7 @@ void softfloat_shiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_
|
||||
| This function or macro is the same as 'softfloat_shiftLeftM' with
|
||||
| 'size_words' = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shiftLeft128M(aPtr, dist, zPtr) softfloat_shiftLeftM(4, aPtr, dist, zPtr)
|
||||
#define softfloat_shiftLeft128M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 4, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftLeft160M
|
||||
@ -677,7 +752,7 @@ void softfloat_shiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_
|
||||
| This function or macro is the same as 'softfloat_shiftLeftM' with
|
||||
| 'size_words' = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shiftLeft160M(aPtr, dist, zPtr) softfloat_shiftLeftM(5, aPtr, dist, zPtr)
|
||||
#define softfloat_shiftLeft160M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 5, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftRightM
|
||||
@ -690,7 +765,13 @@ void softfloat_shiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_
|
||||
| that concatenate in the platform's normal endian order to form an N-bit
|
||||
| integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_shortShiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint_fast8_t dist, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_shortShiftRightM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
uint_fast8_t dist,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftRight128M
|
||||
@ -698,7 +779,7 @@ void softfloat_shortShiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, u
|
||||
| This function or macro is the same as 'softfloat_shortShiftRightM' with
|
||||
| 'size_words' = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shortShiftRight128M(aPtr, dist, zPtr) softfloat_shortShiftRightM(4, aPtr, dist, zPtr)
|
||||
#define softfloat_shortShiftRight128M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 4, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftRight160M
|
||||
@ -706,7 +787,7 @@ void softfloat_shortShiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, u
|
||||
| This function or macro is the same as 'softfloat_shortShiftRightM' with
|
||||
| 'size_words' = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shortShiftRight160M(aPtr, dist, zPtr) softfloat_shortShiftRightM(5, aPtr, dist, zPtr)
|
||||
#define softfloat_shortShiftRight160M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 5, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftRightJamM
|
||||
@ -720,7 +801,9 @@ void softfloat_shortShiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, u
|
||||
| to a 'size_words'-long array of 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form an N-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_shortShiftRightJamM(uint_fast8_t, const uint32_t*, uint_fast8_t, uint32_t*);
|
||||
void
|
||||
softfloat_shortShiftRightJamM(
|
||||
uint_fast8_t, const uint32_t *, uint_fast8_t, uint32_t * );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shortShiftRightJam160M
|
||||
@ -728,7 +811,7 @@ void softfloat_shortShiftRightJamM(uint_fast8_t, const uint32_t*, uint_fast8_t,
|
||||
| This function or macro is the same as 'softfloat_shortShiftRightJamM' with
|
||||
| 'size_words' = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shortShiftRightJam160M(aPtr, dist, zPtr) softfloat_shortShiftRightJamM(5, aPtr, dist, zPtr)
|
||||
#define softfloat_shortShiftRightJam160M( aPtr, dist, zPtr ) softfloat_shortShiftRightJamM( 5, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRightM
|
||||
@ -742,7 +825,13 @@ void softfloat_shortShiftRightJamM(uint_fast8_t, const uint32_t*, uint_fast8_t,
|
||||
| The value of 'dist' can be arbitrarily large. In particular, if 'dist' is
|
||||
| greater than N, the stored result will be 0.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_shiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_shiftRightM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
uint32_t dist,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRight96M
|
||||
@ -750,7 +839,7 @@ void softfloat_shiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint32
|
||||
| This function or macro is the same as 'softfloat_shiftRightM' with
|
||||
| 'size_words' = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shiftRight96M(aPtr, dist, zPtr) softfloat_shiftRightM(3, aPtr, dist, zPtr)
|
||||
#define softfloat_shiftRight96M( aPtr, dist, zPtr ) softfloat_shiftRightM( 3, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRightJamM
|
||||
@ -767,7 +856,13 @@ void softfloat_shiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint32
|
||||
| is greater than N, the stored result will be either 0 or 1, depending on
|
||||
| whether the original N bits are all zeros.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_shiftRightJamM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_shiftRightJamM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
uint32_t dist,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRightJam96M
|
||||
@ -775,7 +870,7 @@ void softfloat_shiftRightJamM(uint_fast8_t size_words, const uint32_t* aPtr, uin
|
||||
| This function or macro is the same as 'softfloat_shiftRightJamM' with
|
||||
| 'size_words' = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shiftRightJam96M(aPtr, dist, zPtr) softfloat_shiftRightJamM(3, aPtr, dist, zPtr)
|
||||
#define softfloat_shiftRightJam96M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 3, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRightJam128M
|
||||
@ -783,7 +878,7 @@ void softfloat_shiftRightJamM(uint_fast8_t size_words, const uint32_t* aPtr, uin
|
||||
| This function or macro is the same as 'softfloat_shiftRightJamM' with
|
||||
| 'size_words' = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shiftRightJam128M(aPtr, dist, zPtr) softfloat_shiftRightJamM(4, aPtr, dist, zPtr)
|
||||
#define softfloat_shiftRightJam128M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 4, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_shiftRightJam160M
|
||||
@ -791,7 +886,7 @@ void softfloat_shiftRightJamM(uint_fast8_t size_words, const uint32_t* aPtr, uin
|
||||
| This function or macro is the same as 'softfloat_shiftRightJamM' with
|
||||
| 'size_words' = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_shiftRightJam160M(aPtr, dist, zPtr) softfloat_shiftRightJamM(5, aPtr, dist, zPtr)
|
||||
#define softfloat_shiftRightJam160M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 5, aPtr, dist, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_addM
|
||||
@ -803,7 +898,13 @@ void softfloat_shiftRightJamM(uint_fast8_t size_words, const uint32_t* aPtr, uin
|
||||
| elements that concatenate in the platform's normal endian order to form an
|
||||
| N-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_addM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_addM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
const uint32_t *bPtr,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_add96M
|
||||
@ -811,7 +912,7 @@ void softfloat_addM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| This function or macro is the same as 'softfloat_addM' with 'size_words'
|
||||
| = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_add96M(aPtr, bPtr, zPtr) softfloat_addM(3, aPtr, bPtr, zPtr)
|
||||
#define softfloat_add96M( aPtr, bPtr, zPtr ) softfloat_addM( 3, aPtr, bPtr, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_add128M
|
||||
@ -819,7 +920,7 @@ void softfloat_addM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| This function or macro is the same as 'softfloat_addM' with 'size_words'
|
||||
| = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_add128M(aPtr, bPtr, zPtr) softfloat_addM(4, aPtr, bPtr, zPtr)
|
||||
#define softfloat_add128M( aPtr, bPtr, zPtr ) softfloat_addM( 4, aPtr, bPtr, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_add160M
|
||||
@ -827,7 +928,7 @@ void softfloat_addM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| This function or macro is the same as 'softfloat_addM' with 'size_words'
|
||||
| = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_add160M(aPtr, bPtr, zPtr) softfloat_addM(5, aPtr, bPtr, zPtr)
|
||||
#define softfloat_add160M( aPtr, bPtr, zPtr ) softfloat_addM( 5, aPtr, bPtr, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_addCarryM
|
||||
@ -839,7 +940,14 @@ void softfloat_addM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| points to a 'size_words'-long array of 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form an N-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast8_t softfloat_addCarryM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint_fast8_t carry, uint32_t* zPtr);
|
||||
uint_fast8_t
|
||||
softfloat_addCarryM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
const uint32_t *bPtr,
|
||||
uint_fast8_t carry,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_addComplCarryM
|
||||
@ -848,8 +956,14 @@ uint_fast8_t softfloat_addCarryM(uint_fast8_t size_words, const uint32_t* aPtr,
|
||||
| the value of the unsigned integer pointed to by 'bPtr' is bit-wise completed
|
||||
| before the addition.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast8_t softfloat_addComplCarryM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint_fast8_t carry,
|
||||
uint32_t* zPtr);
|
||||
uint_fast8_t
|
||||
softfloat_addComplCarryM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
const uint32_t *bPtr,
|
||||
uint_fast8_t carry,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_addComplCarry96M
|
||||
@ -857,7 +971,7 @@ uint_fast8_t softfloat_addComplCarryM(uint_fast8_t size_words, const uint32_t* a
|
||||
| This function or macro is the same as 'softfloat_addComplCarryM' with
|
||||
| 'size_words' = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_addComplCarry96M(aPtr, bPtr, carry, zPtr) softfloat_addComplCarryM(3, aPtr, bPtr, carry, zPtr)
|
||||
#define softfloat_addComplCarry96M( aPtr, bPtr, carry, zPtr ) softfloat_addComplCarryM( 3, aPtr, bPtr, carry, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_negXM
|
||||
@ -867,7 +981,7 @@ uint_fast8_t softfloat_addComplCarryM(uint_fast8_t size_words, const uint32_t* a
|
||||
| points to a 'size_words'-long array of 32-bit elements that concatenate in
|
||||
| the platform's normal endian order to form an N-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_negX96M
|
||||
@ -875,7 +989,7 @@ void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| This function or macro is the same as 'softfloat_negXM' with 'size_words'
|
||||
| = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_negX96M(zPtr) softfloat_negXM(3, zPtr)
|
||||
#define softfloat_negX96M( zPtr ) softfloat_negXM( 3, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_negX128M
|
||||
@ -883,7 +997,7 @@ void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| This function or macro is the same as 'softfloat_negXM' with 'size_words'
|
||||
| = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_negX128M(zPtr) softfloat_negXM(4, zPtr)
|
||||
#define softfloat_negX128M( zPtr ) softfloat_negXM( 4, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_negX160M
|
||||
@ -891,7 +1005,7 @@ void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| This function or macro is the same as 'softfloat_negXM' with 'size_words'
|
||||
| = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_negX160M(zPtr) softfloat_negXM(5, zPtr)
|
||||
#define softfloat_negX160M( zPtr ) softfloat_negXM( 5, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_negX256M
|
||||
@ -899,7 +1013,7 @@ void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| This function or macro is the same as 'softfloat_negXM' with 'size_words'
|
||||
| = 8 (N = 256).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_negX256M(zPtr) softfloat_negXM(8, zPtr)
|
||||
#define softfloat_negX256M( zPtr ) softfloat_negXM( 8, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_sub1XM
|
||||
@ -910,7 +1024,7 @@ void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| elements that concatenate in the platform's normal endian order to form an
|
||||
| N-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_sub1XM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_sub1X96M
|
||||
@ -918,7 +1032,7 @@ void softfloat_sub1XM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
|
||||
| = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_sub1X96M(zPtr) softfloat_sub1XM(3, zPtr)
|
||||
#define softfloat_sub1X96M( zPtr ) softfloat_sub1XM( 3, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_sub1X160M
|
||||
@ -926,7 +1040,7 @@ void softfloat_sub1XM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
|
||||
| = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_sub1X160M(zPtr) softfloat_sub1XM(5, zPtr)
|
||||
#define softfloat_sub1X160M( zPtr ) softfloat_sub1XM( 5, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_subM
|
||||
@ -938,7 +1052,13 @@ void softfloat_sub1XM(uint_fast8_t size_words, uint32_t* zPtr);
|
||||
| array of 32-bit elements that concatenate in the platform's normal endian
|
||||
| order to form an N-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_subM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_subM(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *aPtr,
|
||||
const uint32_t *bPtr,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_sub96M
|
||||
@ -946,7 +1066,7 @@ void softfloat_subM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| This function or macro is the same as 'softfloat_subM' with 'size_words'
|
||||
| = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_sub96M(aPtr, bPtr, zPtr) softfloat_subM(3, aPtr, bPtr, zPtr)
|
||||
#define softfloat_sub96M( aPtr, bPtr, zPtr ) softfloat_subM( 3, aPtr, bPtr, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_sub128M
|
||||
@ -954,7 +1074,7 @@ void softfloat_subM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| This function or macro is the same as 'softfloat_subM' with 'size_words'
|
||||
| = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_sub128M(aPtr, bPtr, zPtr) softfloat_subM(4, aPtr, bPtr, zPtr)
|
||||
#define softfloat_sub128M( aPtr, bPtr, zPtr ) softfloat_subM( 4, aPtr, bPtr, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_sub160M
|
||||
@ -962,7 +1082,7 @@ void softfloat_subM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| This function or macro is the same as 'softfloat_subM' with 'size_words'
|
||||
| = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_sub160M(aPtr, bPtr, zPtr) softfloat_subM(5, aPtr, bPtr, zPtr)
|
||||
#define softfloat_sub160M( aPtr, bPtr, zPtr ) softfloat_subM( 5, aPtr, bPtr, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_mul64To128M
|
||||
@ -972,7 +1092,7 @@ void softfloat_subM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_
|
||||
| elements that concatenate in the platform's normal endian order to form a
|
||||
| 128-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_mul64To128M(uint64_t a, uint64_t b, uint32_t* zPtr);
|
||||
void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_mul128MTo256M
|
||||
@ -984,7 +1104,9 @@ void softfloat_mul64To128M(uint64_t a, uint64_t b, uint32_t* zPtr);
|
||||
| Argument 'zPtr' points to an array of eight 32-bit elements that concatenate
|
||||
| to form a 256-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_mul128MTo256M(const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
|
||||
void
|
||||
softfloat_mul128MTo256M(
|
||||
const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr );
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_remStepMBy32
|
||||
@ -997,8 +1119,15 @@ void softfloat_mul128MTo256M(const uint32_t* aPtr, const uint32_t* bPtr, uint32_
|
||||
| to a 'size_words'-long array of 32-bit elements that concatenate in the
|
||||
| platform's normal endian order to form an N-bit integer.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_remStepMBy32(uint_fast8_t size_words, const uint32_t* remPtr, uint_fast8_t dist, const uint32_t* bPtr, uint32_t q,
|
||||
uint32_t* zPtr);
|
||||
void
|
||||
softfloat_remStepMBy32(
|
||||
uint_fast8_t size_words,
|
||||
const uint32_t *remPtr,
|
||||
uint_fast8_t dist,
|
||||
const uint32_t *bPtr,
|
||||
uint32_t q,
|
||||
uint32_t *zPtr
|
||||
);
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_remStep96MBy32
|
||||
@ -1006,7 +1135,7 @@ void softfloat_remStepMBy32(uint_fast8_t size_words, const uint32_t* remPtr, uin
|
||||
| This function or macro is the same as 'softfloat_remStepMBy32' with
|
||||
| 'size_words' = 3 (N = 96).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_remStep96MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(3, remPtr, dist, bPtr, q, zPtr)
|
||||
#define softfloat_remStep96MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 3, remPtr, dist, bPtr, q, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_remStep128MBy32
|
||||
@ -1014,7 +1143,7 @@ void softfloat_remStepMBy32(uint_fast8_t size_words, const uint32_t* remPtr, uin
|
||||
| This function or macro is the same as 'softfloat_remStepMBy32' with
|
||||
| 'size_words' = 4 (N = 128).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_remStep128MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(4, remPtr, dist, bPtr, q, zPtr)
|
||||
#define softfloat_remStep128MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 4, remPtr, dist, bPtr, q, zPtr )
|
||||
#endif
|
||||
|
||||
#ifndef softfloat_remStep160MBy32
|
||||
@ -1022,9 +1151,10 @@ void softfloat_remStepMBy32(uint_fast8_t size_words, const uint32_t* remPtr, uin
|
||||
| This function or macro is the same as 'softfloat_remStepMBy32' with
|
||||
| 'size_words' = 5 (N = 160).
|
||||
*----------------------------------------------------------------------------*/
|
||||
#define softfloat_remStep160MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(5, remPtr, dist, bPtr, q, zPtr)
|
||||
#define softfloat_remStep160MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 5, remPtr, dist, bPtr, q, zPtr )
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -34,6 +34,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
|
||||
/*============================================================================
|
||||
| Note: If SoftFloat is made available as a general library for programs to
|
||||
| use, it is strongly recommended that a platform-specific version of this
|
||||
@ -41,12 +42,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
| eliminates all dependencies on compile-time macros.
|
||||
*============================================================================*/
|
||||
|
||||
|
||||
#ifndef softfloat_h
|
||||
#define softfloat_h 1
|
||||
|
||||
#include "softfloat_types.h"
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "softfloat_types.h"
|
||||
|
||||
#ifndef THREAD_LOCAL
|
||||
#define THREAD_LOCAL
|
||||
@ -56,7 +58,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
| Software floating-point underflow tininess-detection mode.
|
||||
*----------------------------------------------------------------------------*/
|
||||
extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;
|
||||
enum { softfloat_tininess_beforeRounding = 0, softfloat_tininess_afterRounding = 1 };
|
||||
enum {
|
||||
softfloat_tininess_beforeRounding = 0,
|
||||
softfloat_tininess_afterRounding = 1
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Software floating-point rounding mode. (Mode "odd" is supported only if
|
||||
@ -64,175 +69,182 @@ enum { softfloat_tininess_beforeRounding = 0, softfloat_tininess_afterRounding =
|
||||
*----------------------------------------------------------------------------*/
|
||||
extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;
|
||||
enum {
|
||||
softfloat_round_near_even = 0,
|
||||
softfloat_round_minMag = 1,
|
||||
softfloat_round_min = 2,
|
||||
softfloat_round_max = 3,
|
||||
softfloat_round_near_even = 0,
|
||||
softfloat_round_minMag = 1,
|
||||
softfloat_round_min = 2,
|
||||
softfloat_round_max = 3,
|
||||
softfloat_round_near_maxMag = 4,
|
||||
softfloat_round_odd = 6
|
||||
softfloat_round_odd = 6
|
||||
};
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Software floating-point exception flags.
|
||||
*----------------------------------------------------------------------------*/
|
||||
extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;
|
||||
enum {
|
||||
softfloat_flag_inexact = 1,
|
||||
softfloat_flag_underflow = 2,
|
||||
softfloat_flag_overflow = 4,
|
||||
softfloat_flag_infinite = 8,
|
||||
softfloat_flag_invalid = 16
|
||||
};
|
||||
typedef enum {
|
||||
softfloat_flag_inexact = 1,
|
||||
softfloat_flag_underflow = 2,
|
||||
softfloat_flag_overflow = 4,
|
||||
softfloat_flag_infinite = 8,
|
||||
softfloat_flag_invalid = 16
|
||||
} exceptionFlag_t;
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Routine to raise any or all of the software floating-point exception flags.
|
||||
*----------------------------------------------------------------------------*/
|
||||
void softfloat_raiseFlags(uint_fast8_t);
|
||||
void softfloat_raiseFlags( uint_fast8_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Integer-to-floating-point conversion routines.
|
||||
*----------------------------------------------------------------------------*/
|
||||
float16_t ui32_to_f16(uint32_t);
|
||||
float32_t ui32_to_f32(uint32_t);
|
||||
float64_t ui32_to_f64(uint32_t);
|
||||
float16_t ui32_to_f16( uint32_t );
|
||||
float32_t ui32_to_f32( uint32_t );
|
||||
float64_t ui32_to_f64( uint32_t );
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
extFloat80_t ui32_to_extF80(uint32_t);
|
||||
float128_t ui32_to_f128(uint32_t);
|
||||
extFloat80_t ui32_to_extF80( uint32_t );
|
||||
float128_t ui32_to_f128( uint32_t );
|
||||
#endif
|
||||
void ui32_to_extF80M(uint32_t, extFloat80_t*);
|
||||
void ui32_to_f128M(uint32_t, float128_t*);
|
||||
float16_t ui64_to_f16(uint64_t);
|
||||
float32_t ui64_to_f32(uint64_t);
|
||||
float64_t ui64_to_f64(uint64_t);
|
||||
void ui32_to_extF80M( uint32_t, extFloat80_t * );
|
||||
void ui32_to_f128M( uint32_t, float128_t * );
|
||||
float16_t ui64_to_f16( uint64_t );
|
||||
float32_t ui64_to_f32( uint64_t );
|
||||
float64_t ui64_to_f64( uint64_t );
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
extFloat80_t ui64_to_extF80(uint64_t);
|
||||
float128_t ui64_to_f128(uint64_t);
|
||||
extFloat80_t ui64_to_extF80( uint64_t );
|
||||
float128_t ui64_to_f128( uint64_t );
|
||||
#endif
|
||||
void ui64_to_extF80M(uint64_t, extFloat80_t*);
|
||||
void ui64_to_f128M(uint64_t, float128_t*);
|
||||
float16_t i32_to_f16(int32_t);
|
||||
float32_t i32_to_f32(int32_t);
|
||||
float64_t i32_to_f64(int32_t);
|
||||
void ui64_to_extF80M( uint64_t, extFloat80_t * );
|
||||
void ui64_to_f128M( uint64_t, float128_t * );
|
||||
float16_t i32_to_f16( int32_t );
|
||||
float32_t i32_to_f32( int32_t );
|
||||
float64_t i32_to_f64( int32_t );
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
extFloat80_t i32_to_extF80(int32_t);
|
||||
float128_t i32_to_f128(int32_t);
|
||||
extFloat80_t i32_to_extF80( int32_t );
|
||||
float128_t i32_to_f128( int32_t );
|
||||
#endif
|
||||
void i32_to_extF80M(int32_t, extFloat80_t*);
|
||||
void i32_to_f128M(int32_t, float128_t*);
|
||||
float16_t i64_to_f16(int64_t);
|
||||
float32_t i64_to_f32(int64_t);
|
||||
float64_t i64_to_f64(int64_t);
|
||||
void i32_to_extF80M( int32_t, extFloat80_t * );
|
||||
void i32_to_f128M( int32_t, float128_t * );
|
||||
float16_t i64_to_f16( int64_t );
|
||||
float32_t i64_to_f32( int64_t );
|
||||
float64_t i64_to_f64( int64_t );
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
extFloat80_t i64_to_extF80(int64_t);
|
||||
float128_t i64_to_f128(int64_t);
|
||||
extFloat80_t i64_to_extF80( int64_t );
|
||||
float128_t i64_to_f128( int64_t );
|
||||
#endif
|
||||
void i64_to_extF80M(int64_t, extFloat80_t*);
|
||||
void i64_to_f128M(int64_t, float128_t*);
|
||||
void i64_to_extF80M( int64_t, extFloat80_t * );
|
||||
void i64_to_f128M( int64_t, float128_t * );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| 16-bit (half-precision) floating-point operations.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t f16_to_ui32(float16_t, uint_fast8_t, bool);
|
||||
uint_fast64_t f16_to_ui64(float16_t, uint_fast8_t, bool);
|
||||
int_fast32_t f16_to_i32(float16_t, uint_fast8_t, bool);
|
||||
int_fast64_t f16_to_i64(float16_t, uint_fast8_t, bool);
|
||||
uint_fast32_t f16_to_ui32_r_minMag(float16_t, bool);
|
||||
uint_fast64_t f16_to_ui64_r_minMag(float16_t, bool);
|
||||
int_fast32_t f16_to_i32_r_minMag(float16_t, bool);
|
||||
int_fast64_t f16_to_i64_r_minMag(float16_t, bool);
|
||||
float32_t f16_to_f32(float16_t);
|
||||
float64_t f16_to_f64(float16_t);
|
||||
uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool );
|
||||
uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool );
|
||||
int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool );
|
||||
int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool );
|
||||
uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool );
|
||||
uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool );
|
||||
int_fast32_t f16_to_i32_r_minMag( float16_t, bool );
|
||||
int_fast64_t f16_to_i64_r_minMag( float16_t, bool );
|
||||
float32_t f16_to_f32( float16_t );
|
||||
float64_t f16_to_f64( float16_t );
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
extFloat80_t f16_to_extF80(float16_t);
|
||||
float128_t f16_to_f128(float16_t);
|
||||
extFloat80_t f16_to_extF80( float16_t );
|
||||
float128_t f16_to_f128( float16_t );
|
||||
#endif
|
||||
void f16_to_extF80M(float16_t, extFloat80_t*);
|
||||
void f16_to_f128M(float16_t, float128_t*);
|
||||
float16_t f16_roundToInt(float16_t, uint_fast8_t, bool);
|
||||
float16_t f16_add(float16_t, float16_t);
|
||||
float16_t f16_sub(float16_t, float16_t);
|
||||
float16_t f16_mul(float16_t, float16_t);
|
||||
float16_t f16_mulAdd(float16_t, float16_t, float16_t);
|
||||
float16_t f16_div(float16_t, float16_t);
|
||||
float16_t f16_rem(float16_t, float16_t);
|
||||
float16_t f16_sqrt(float16_t);
|
||||
bool f16_eq(float16_t, float16_t);
|
||||
bool f16_le(float16_t, float16_t);
|
||||
bool f16_lt(float16_t, float16_t);
|
||||
bool f16_eq_signaling(float16_t, float16_t);
|
||||
bool f16_le_quiet(float16_t, float16_t);
|
||||
bool f16_lt_quiet(float16_t, float16_t);
|
||||
bool f16_isSignalingNaN(float16_t);
|
||||
void f16_to_extF80M( float16_t, extFloat80_t * );
|
||||
void f16_to_f128M( float16_t, float128_t * );
|
||||
float16_t f16_roundToInt( float16_t, uint_fast8_t, bool );
|
||||
float16_t f16_add( float16_t, float16_t );
|
||||
float16_t f16_sub( float16_t, float16_t );
|
||||
float16_t f16_mul( float16_t, float16_t );
|
||||
float16_t f16_mulAdd( float16_t, float16_t, float16_t );
|
||||
float16_t f16_div( float16_t, float16_t );
|
||||
float16_t f16_rem( float16_t, float16_t );
|
||||
float16_t f16_sqrt( float16_t );
|
||||
bool f16_eq( float16_t, float16_t );
|
||||
bool f16_le( float16_t, float16_t );
|
||||
bool f16_lt( float16_t, float16_t );
|
||||
bool f16_eq_signaling( float16_t, float16_t );
|
||||
bool f16_le_quiet( float16_t, float16_t );
|
||||
bool f16_lt_quiet( float16_t, float16_t );
|
||||
bool f16_isSignalingNaN( float16_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| 16-bit (brain float 16) floating-point operations.
|
||||
*----------------------------------------------------------------------------*/
|
||||
float32_t bf16_to_f32( bfloat16_t );
|
||||
bfloat16_t f32_to_bf16( float32_t );
|
||||
bool bf16_isSignalingNaN( bfloat16_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| 32-bit (single-precision) floating-point operations.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t f32_to_ui32(float32_t, uint_fast8_t, bool);
|
||||
uint_fast64_t f32_to_ui64(float32_t, uint_fast8_t, bool);
|
||||
int_fast32_t f32_to_i32(float32_t, uint_fast8_t, bool);
|
||||
int_fast64_t f32_to_i64(float32_t, uint_fast8_t, bool);
|
||||
uint_fast32_t f32_to_ui32_r_minMag(float32_t, bool);
|
||||
uint_fast64_t f32_to_ui64_r_minMag(float32_t, bool);
|
||||
int_fast32_t f32_to_i32_r_minMag(float32_t, bool);
|
||||
int_fast64_t f32_to_i64_r_minMag(float32_t, bool);
|
||||
float16_t f32_to_f16(float32_t);
|
||||
float64_t f32_to_f64(float32_t);
|
||||
uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool );
|
||||
uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool );
|
||||
int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );
|
||||
int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool );
|
||||
uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool );
|
||||
uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool );
|
||||
int_fast32_t f32_to_i32_r_minMag( float32_t, bool );
|
||||
int_fast64_t f32_to_i64_r_minMag( float32_t, bool );
|
||||
float16_t f32_to_f16( float32_t );
|
||||
float64_t f32_to_f64( float32_t );
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
extFloat80_t f32_to_extF80(float32_t);
|
||||
float128_t f32_to_f128(float32_t);
|
||||
extFloat80_t f32_to_extF80( float32_t );
|
||||
float128_t f32_to_f128( float32_t );
|
||||
#endif
|
||||
void f32_to_extF80M(float32_t, extFloat80_t*);
|
||||
void f32_to_f128M(float32_t, float128_t*);
|
||||
float32_t f32_roundToInt(float32_t, uint_fast8_t, bool);
|
||||
float32_t f32_add(float32_t, float32_t);
|
||||
float32_t f32_sub(float32_t, float32_t);
|
||||
float32_t f32_mul(float32_t, float32_t);
|
||||
float32_t f32_mulAdd(float32_t, float32_t, float32_t);
|
||||
float32_t f32_div(float32_t, float32_t);
|
||||
float32_t f32_rem(float32_t, float32_t);
|
||||
float32_t f32_sqrt(float32_t);
|
||||
bool f32_eq(float32_t, float32_t);
|
||||
bool f32_le(float32_t, float32_t);
|
||||
bool f32_lt(float32_t, float32_t);
|
||||
bool f32_eq_signaling(float32_t, float32_t);
|
||||
bool f32_le_quiet(float32_t, float32_t);
|
||||
bool f32_lt_quiet(float32_t, float32_t);
|
||||
bool f32_isSignalingNaN(float32_t);
|
||||
void f32_to_extF80M( float32_t, extFloat80_t * );
|
||||
void f32_to_f128M( float32_t, float128_t * );
|
||||
float32_t f32_roundToInt( float32_t, uint_fast8_t, bool );
|
||||
float32_t f32_add( float32_t, float32_t );
|
||||
float32_t f32_sub( float32_t, float32_t );
|
||||
float32_t f32_mul( float32_t, float32_t );
|
||||
float32_t f32_mulAdd( float32_t, float32_t, float32_t );
|
||||
float32_t f32_div( float32_t, float32_t );
|
||||
float32_t f32_rem( float32_t, float32_t );
|
||||
float32_t f32_sqrt( float32_t );
|
||||
bool f32_eq( float32_t, float32_t );
|
||||
bool f32_le( float32_t, float32_t );
|
||||
bool f32_lt( float32_t, float32_t );
|
||||
bool f32_eq_signaling( float32_t, float32_t );
|
||||
bool f32_le_quiet( float32_t, float32_t );
|
||||
bool f32_lt_quiet( float32_t, float32_t );
|
||||
bool f32_isSignalingNaN( float32_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| 64-bit (double-precision) floating-point operations.
|
||||
*----------------------------------------------------------------------------*/
|
||||
uint_fast32_t f64_to_ui32(float64_t, uint_fast8_t, bool);
|
||||
uint_fast64_t f64_to_ui64(float64_t, uint_fast8_t, bool);
|
||||
int_fast32_t f64_to_i32(float64_t, uint_fast8_t, bool);
|
||||
int_fast64_t f64_to_i64(float64_t, uint_fast8_t, bool);
|
||||
uint_fast32_t f64_to_ui32_r_minMag(float64_t, bool);
|
||||
uint_fast64_t f64_to_ui64_r_minMag(float64_t, bool);
|
||||
int_fast32_t f64_to_i32_r_minMag(float64_t, bool);
|
||||
int_fast64_t f64_to_i64_r_minMag(float64_t, bool);
|
||||
float16_t f64_to_f16(float64_t);
|
||||
float32_t f64_to_f32(float64_t);
|
||||
uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );
|
||||
uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );
|
||||
int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );
|
||||
int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );
|
||||
uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );
|
||||
uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );
|
||||
int_fast32_t f64_to_i32_r_minMag( float64_t, bool );
|
||||
int_fast64_t f64_to_i64_r_minMag( float64_t, bool );
|
||||
float16_t f64_to_f16( float64_t );
|
||||
float32_t f64_to_f32( float64_t );
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
extFloat80_t f64_to_extF80(float64_t);
|
||||
float128_t f64_to_f128(float64_t);
|
||||
extFloat80_t f64_to_extF80( float64_t );
|
||||
float128_t f64_to_f128( float64_t );
|
||||
#endif
|
||||
void f64_to_extF80M(float64_t, extFloat80_t*);
|
||||
void f64_to_f128M(float64_t, float128_t*);
|
||||
float64_t f64_roundToInt(float64_t, uint_fast8_t, bool);
|
||||
float64_t f64_add(float64_t, float64_t);
|
||||
float64_t f64_sub(float64_t, float64_t);
|
||||
float64_t f64_mul(float64_t, float64_t);
|
||||
float64_t f64_mulAdd(float64_t, float64_t, float64_t);
|
||||
float64_t f64_div(float64_t, float64_t);
|
||||
float64_t f64_rem(float64_t, float64_t);
|
||||
float64_t f64_sqrt(float64_t);
|
||||
bool f64_eq(float64_t, float64_t);
|
||||
bool f64_le(float64_t, float64_t);
|
||||
bool f64_lt(float64_t, float64_t);
|
||||
bool f64_eq_signaling(float64_t, float64_t);
|
||||
bool f64_le_quiet(float64_t, float64_t);
|
||||
bool f64_lt_quiet(float64_t, float64_t);
|
||||
bool f64_isSignalingNaN(float64_t);
|
||||
void f64_to_extF80M( float64_t, extFloat80_t * );
|
||||
void f64_to_f128M( float64_t, float128_t * );
|
||||
float64_t f64_roundToInt( float64_t, uint_fast8_t, bool );
|
||||
float64_t f64_add( float64_t, float64_t );
|
||||
float64_t f64_sub( float64_t, float64_t );
|
||||
float64_t f64_mul( float64_t, float64_t );
|
||||
float64_t f64_mulAdd( float64_t, float64_t, float64_t );
|
||||
float64_t f64_div( float64_t, float64_t );
|
||||
float64_t f64_rem( float64_t, float64_t );
|
||||
float64_t f64_sqrt( float64_t );
|
||||
bool f64_eq( float64_t, float64_t );
|
||||
bool f64_le( float64_t, float64_t );
|
||||
bool f64_lt( float64_t, float64_t );
|
||||
bool f64_eq_signaling( float64_t, float64_t );
|
||||
bool f64_le_quiet( float64_t, float64_t );
|
||||
bool f64_lt_quiet( float64_t, float64_t );
|
||||
bool f64_isSignalingNaN( float64_t );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| Rounding precision for 80-bit extended double-precision floating-point.
|
||||
@ -244,118 +256,124 @@ extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
|
||||
| 80-bit extended double-precision floating-point operations.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
uint_fast32_t extF80_to_ui32(extFloat80_t, uint_fast8_t, bool);
|
||||
uint_fast64_t extF80_to_ui64(extFloat80_t, uint_fast8_t, bool);
|
||||
int_fast32_t extF80_to_i32(extFloat80_t, uint_fast8_t, bool);
|
||||
int_fast64_t extF80_to_i64(extFloat80_t, uint_fast8_t, bool);
|
||||
uint_fast32_t extF80_to_ui32_r_minMag(extFloat80_t, bool);
|
||||
uint_fast64_t extF80_to_ui64_r_minMag(extFloat80_t, bool);
|
||||
int_fast32_t extF80_to_i32_r_minMag(extFloat80_t, bool);
|
||||
int_fast64_t extF80_to_i64_r_minMag(extFloat80_t, bool);
|
||||
float16_t extF80_to_f16(extFloat80_t);
|
||||
float32_t extF80_to_f32(extFloat80_t);
|
||||
float64_t extF80_to_f64(extFloat80_t);
|
||||
float128_t extF80_to_f128(extFloat80_t);
|
||||
extFloat80_t extF80_roundToInt(extFloat80_t, uint_fast8_t, bool);
|
||||
extFloat80_t extF80_add(extFloat80_t, extFloat80_t);
|
||||
extFloat80_t extF80_sub(extFloat80_t, extFloat80_t);
|
||||
extFloat80_t extF80_mul(extFloat80_t, extFloat80_t);
|
||||
extFloat80_t extF80_div(extFloat80_t, extFloat80_t);
|
||||
extFloat80_t extF80_rem(extFloat80_t, extFloat80_t);
|
||||
extFloat80_t extF80_sqrt(extFloat80_t);
|
||||
bool extF80_eq(extFloat80_t, extFloat80_t);
|
||||
bool extF80_le(extFloat80_t, extFloat80_t);
|
||||
bool extF80_lt(extFloat80_t, extFloat80_t);
|
||||
bool extF80_eq_signaling(extFloat80_t, extFloat80_t);
|
||||
bool extF80_le_quiet(extFloat80_t, extFloat80_t);
|
||||
bool extF80_lt_quiet(extFloat80_t, extFloat80_t);
|
||||
bool extF80_isSignalingNaN(extFloat80_t);
|
||||
uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );
|
||||
uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );
|
||||
int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );
|
||||
int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );
|
||||
uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );
|
||||
uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );
|
||||
int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );
|
||||
int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );
|
||||
float16_t extF80_to_f16( extFloat80_t );
|
||||
float32_t extF80_to_f32( extFloat80_t );
|
||||
float64_t extF80_to_f64( extFloat80_t );
|
||||
float128_t extF80_to_f128( extFloat80_t );
|
||||
extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );
|
||||
extFloat80_t extF80_add( extFloat80_t, extFloat80_t );
|
||||
extFloat80_t extF80_sub( extFloat80_t, extFloat80_t );
|
||||
extFloat80_t extF80_mul( extFloat80_t, extFloat80_t );
|
||||
extFloat80_t extF80_div( extFloat80_t, extFloat80_t );
|
||||
extFloat80_t extF80_rem( extFloat80_t, extFloat80_t );
|
||||
extFloat80_t extF80_sqrt( extFloat80_t );
|
||||
bool extF80_eq( extFloat80_t, extFloat80_t );
|
||||
bool extF80_le( extFloat80_t, extFloat80_t );
|
||||
bool extF80_lt( extFloat80_t, extFloat80_t );
|
||||
bool extF80_eq_signaling( extFloat80_t, extFloat80_t );
|
||||
bool extF80_le_quiet( extFloat80_t, extFloat80_t );
|
||||
bool extF80_lt_quiet( extFloat80_t, extFloat80_t );
|
||||
bool extF80_isSignalingNaN( extFloat80_t );
|
||||
#endif
|
||||
uint_fast32_t extF80M_to_ui32(const extFloat80_t*, uint_fast8_t, bool);
|
||||
uint_fast64_t extF80M_to_ui64(const extFloat80_t*, uint_fast8_t, bool);
|
||||
int_fast32_t extF80M_to_i32(const extFloat80_t*, uint_fast8_t, bool);
|
||||
int_fast64_t extF80M_to_i64(const extFloat80_t*, uint_fast8_t, bool);
|
||||
uint_fast32_t extF80M_to_ui32_r_minMag(const extFloat80_t*, bool);
|
||||
uint_fast64_t extF80M_to_ui64_r_minMag(const extFloat80_t*, bool);
|
||||
int_fast32_t extF80M_to_i32_r_minMag(const extFloat80_t*, bool);
|
||||
int_fast64_t extF80M_to_i64_r_minMag(const extFloat80_t*, bool);
|
||||
float16_t extF80M_to_f16(const extFloat80_t*);
|
||||
float32_t extF80M_to_f32(const extFloat80_t*);
|
||||
float64_t extF80M_to_f64(const extFloat80_t*);
|
||||
void extF80M_to_f128M(const extFloat80_t*, float128_t*);
|
||||
void extF80M_roundToInt(const extFloat80_t*, uint_fast8_t, bool, extFloat80_t*);
|
||||
void extF80M_add(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
|
||||
void extF80M_sub(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
|
||||
void extF80M_mul(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
|
||||
void extF80M_div(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
|
||||
void extF80M_rem(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
|
||||
void extF80M_sqrt(const extFloat80_t*, extFloat80_t*);
|
||||
bool extF80M_eq(const extFloat80_t*, const extFloat80_t*);
|
||||
bool extF80M_le(const extFloat80_t*, const extFloat80_t*);
|
||||
bool extF80M_lt(const extFloat80_t*, const extFloat80_t*);
|
||||
bool extF80M_eq_signaling(const extFloat80_t*, const extFloat80_t*);
|
||||
bool extF80M_le_quiet(const extFloat80_t*, const extFloat80_t*);
|
||||
bool extF80M_lt_quiet(const extFloat80_t*, const extFloat80_t*);
|
||||
bool extF80M_isSignalingNaN(const extFloat80_t*);
|
||||
uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );
|
||||
uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );
|
||||
int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );
|
||||
int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );
|
||||
uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );
|
||||
uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );
|
||||
int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );
|
||||
int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );
|
||||
float16_t extF80M_to_f16( const extFloat80_t * );
|
||||
float32_t extF80M_to_f32( const extFloat80_t * );
|
||||
float64_t extF80M_to_f64( const extFloat80_t * );
|
||||
void extF80M_to_f128M( const extFloat80_t *, float128_t * );
|
||||
void
|
||||
extF80M_roundToInt(
|
||||
const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );
|
||||
void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
|
||||
void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
|
||||
void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
|
||||
void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
|
||||
void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
|
||||
void extF80M_sqrt( const extFloat80_t *, extFloat80_t * );
|
||||
bool extF80M_eq( const extFloat80_t *, const extFloat80_t * );
|
||||
bool extF80M_le( const extFloat80_t *, const extFloat80_t * );
|
||||
bool extF80M_lt( const extFloat80_t *, const extFloat80_t * );
|
||||
bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );
|
||||
bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );
|
||||
bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );
|
||||
bool extF80M_isSignalingNaN( const extFloat80_t * );
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| 128-bit (quadruple-precision) floating-point operations.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef SOFTFLOAT_FAST_INT64
|
||||
uint_fast32_t f128_to_ui32(float128_t, uint_fast8_t, bool);
|
||||
uint_fast64_t f128_to_ui64(float128_t, uint_fast8_t, bool);
|
||||
int_fast32_t f128_to_i32(float128_t, uint_fast8_t, bool);
|
||||
int_fast64_t f128_to_i64(float128_t, uint_fast8_t, bool);
|
||||
uint_fast32_t f128_to_ui32_r_minMag(float128_t, bool);
|
||||
uint_fast64_t f128_to_ui64_r_minMag(float128_t, bool);
|
||||
int_fast32_t f128_to_i32_r_minMag(float128_t, bool);
|
||||
int_fast64_t f128_to_i64_r_minMag(float128_t, bool);
|
||||
float16_t f128_to_f16(float128_t);
|
||||
float32_t f128_to_f32(float128_t);
|
||||
float64_t f128_to_f64(float128_t);
|
||||
extFloat80_t f128_to_extF80(float128_t);
|
||||
float128_t f128_roundToInt(float128_t, uint_fast8_t, bool);
|
||||
float128_t f128_add(float128_t, float128_t);
|
||||
float128_t f128_sub(float128_t, float128_t);
|
||||
float128_t f128_mul(float128_t, float128_t);
|
||||
float128_t f128_mulAdd(float128_t, float128_t, float128_t);
|
||||
float128_t f128_div(float128_t, float128_t);
|
||||
float128_t f128_rem(float128_t, float128_t);
|
||||
float128_t f128_sqrt(float128_t);
|
||||
bool f128_eq(float128_t, float128_t);
|
||||
bool f128_le(float128_t, float128_t);
|
||||
bool f128_lt(float128_t, float128_t);
|
||||
bool f128_eq_signaling(float128_t, float128_t);
|
||||
bool f128_le_quiet(float128_t, float128_t);
|
||||
bool f128_lt_quiet(float128_t, float128_t);
|
||||
bool f128_isSignalingNaN(float128_t);
|
||||
uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );
|
||||
uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );
|
||||
int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );
|
||||
int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool );
|
||||
uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );
|
||||
uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );
|
||||
int_fast32_t f128_to_i32_r_minMag( float128_t, bool );
|
||||
int_fast64_t f128_to_i64_r_minMag( float128_t, bool );
|
||||
float16_t f128_to_f16( float128_t );
|
||||
float32_t f128_to_f32( float128_t );
|
||||
float64_t f128_to_f64( float128_t );
|
||||
extFloat80_t f128_to_extF80( float128_t );
|
||||
float128_t f128_roundToInt( float128_t, uint_fast8_t, bool );
|
||||
float128_t f128_add( float128_t, float128_t );
|
||||
float128_t f128_sub( float128_t, float128_t );
|
||||
float128_t f128_mul( float128_t, float128_t );
|
||||
float128_t f128_mulAdd( float128_t, float128_t, float128_t );
|
||||
float128_t f128_div( float128_t, float128_t );
|
||||
float128_t f128_rem( float128_t, float128_t );
|
||||
float128_t f128_sqrt( float128_t );
|
||||
bool f128_eq( float128_t, float128_t );
|
||||
bool f128_le( float128_t, float128_t );
|
||||
bool f128_lt( float128_t, float128_t );
|
||||
bool f128_eq_signaling( float128_t, float128_t );
|
||||
bool f128_le_quiet( float128_t, float128_t );
|
||||
bool f128_lt_quiet( float128_t, float128_t );
|
||||
bool f128_isSignalingNaN( float128_t );
|
||||
#endif
|
||||
uint_fast32_t f128M_to_ui32(const float128_t*, uint_fast8_t, bool);
|
||||
uint_fast64_t f128M_to_ui64(const float128_t*, uint_fast8_t, bool);
|
||||
int_fast32_t f128M_to_i32(const float128_t*, uint_fast8_t, bool);
|
||||
int_fast64_t f128M_to_i64(const float128_t*, uint_fast8_t, bool);
|
||||
uint_fast32_t f128M_to_ui32_r_minMag(const float128_t*, bool);
|
||||
uint_fast64_t f128M_to_ui64_r_minMag(const float128_t*, bool);
|
||||
int_fast32_t f128M_to_i32_r_minMag(const float128_t*, bool);
|
||||
int_fast64_t f128M_to_i64_r_minMag(const float128_t*, bool);
|
||||
float16_t f128M_to_f16(const float128_t*);
|
||||
float32_t f128M_to_f32(const float128_t*);
|
||||
float64_t f128M_to_f64(const float128_t*);
|
||||
void f128M_to_extF80M(const float128_t*, extFloat80_t*);
|
||||
void f128M_roundToInt(const float128_t*, uint_fast8_t, bool, float128_t*);
|
||||
void f128M_add(const float128_t*, const float128_t*, float128_t*);
|
||||
void f128M_sub(const float128_t*, const float128_t*, float128_t*);
|
||||
void f128M_mul(const float128_t*, const float128_t*, float128_t*);
|
||||
void f128M_mulAdd(const float128_t*, const float128_t*, const float128_t*, float128_t*);
|
||||
void f128M_div(const float128_t*, const float128_t*, float128_t*);
|
||||
void f128M_rem(const float128_t*, const float128_t*, float128_t*);
|
||||
void f128M_sqrt(const float128_t*, float128_t*);
|
||||
bool f128M_eq(const float128_t*, const float128_t*);
|
||||
bool f128M_le(const float128_t*, const float128_t*);
|
||||
bool f128M_lt(const float128_t*, const float128_t*);
|
||||
bool f128M_eq_signaling(const float128_t*, const float128_t*);
|
||||
bool f128M_le_quiet(const float128_t*, const float128_t*);
|
||||
bool f128M_lt_quiet(const float128_t*, const float128_t*);
|
||||
bool f128M_isSignalingNaN(const float128_t*);
|
||||
uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );
|
||||
uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );
|
||||
int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );
|
||||
int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );
|
||||
uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );
|
||||
uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );
|
||||
int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );
|
||||
int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );
|
||||
float16_t f128M_to_f16( const float128_t * );
|
||||
float32_t f128M_to_f32( const float128_t * );
|
||||
float64_t f128M_to_f64( const float128_t * );
|
||||
void f128M_to_extF80M( const float128_t *, extFloat80_t * );
|
||||
void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );
|
||||
void f128M_add( const float128_t *, const float128_t *, float128_t * );
|
||||
void f128M_sub( const float128_t *, const float128_t *, float128_t * );
|
||||
void f128M_mul( const float128_t *, const float128_t *, float128_t * );
|
||||
void
|
||||
f128M_mulAdd(
|
||||
const float128_t *, const float128_t *, const float128_t *, float128_t *
|
||||
);
|
||||
void f128M_div( const float128_t *, const float128_t *, float128_t * );
|
||||
void f128M_rem( const float128_t *, const float128_t *, float128_t * );
|
||||
void f128M_sqrt( const float128_t *, float128_t * );
|
||||
bool f128M_eq( const float128_t *, const float128_t * );
|
||||
bool f128M_le( const float128_t *, const float128_t * );
|
||||
bool f128M_lt( const float128_t *, const float128_t * );
|
||||
bool f128M_eq_signaling( const float128_t *, const float128_t * );
|
||||
bool f128M_le_quiet( const float128_t *, const float128_t * );
|
||||
bool f128M_lt_quiet( const float128_t *, const float128_t * );
|
||||
bool f128M_isSignalingNaN( const float128_t * );
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -47,18 +47,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
| the types below may, if desired, be defined as aliases for the native types
|
||||
| (typically 'float' and 'double', and possibly 'long double').
|
||||
*----------------------------------------------------------------------------*/
|
||||
typedef struct {
|
||||
uint16_t v;
|
||||
} float16_t;
|
||||
typedef struct {
|
||||
uint32_t v;
|
||||
} float32_t;
|
||||
typedef struct {
|
||||
uint64_t v;
|
||||
} float64_t;
|
||||
typedef struct {
|
||||
uint64_t v[2];
|
||||
} float128_t;
|
||||
typedef struct { uint16_t v; } float16_t;
|
||||
typedef struct { uint16_t v; } bfloat16_t;
|
||||
typedef struct { uint32_t v; } float32_t;
|
||||
typedef struct { uint64_t v; } float64_t;
|
||||
typedef struct { uint64_t v[2]; } float128_t;
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
| The format of an 80-bit extended floating-point number in memory. This
|
||||
@ -66,15 +59,9 @@ typedef struct {
|
||||
| named 'signif'.
|
||||
*----------------------------------------------------------------------------*/
|
||||
#ifdef LITTLEENDIAN
|
||||
struct extFloat80M {
|
||||
uint64_t signif;
|
||||
uint16_t signExp;
|
||||
};
|
||||
struct extFloat80M { uint64_t signif; uint16_t signExp; };
|
||||
#else
|
||||
struct extFloat80M {
|
||||
uint16_t signExp;
|
||||
uint64_t signif;
|
||||
};
|
||||
struct extFloat80M { uint16_t signExp; uint64_t signif; };
|
||||
#endif
|
||||
|
||||
/*----------------------------------------------------------------------------
|
||||
@ -92,3 +79,4 @@ struct extFloat80M {
|
||||
typedef struct extFloat80M extFloat80_t;
|
||||
|
||||
#endif
|
||||
|
||||
|
@ -221,4 +221,3 @@ float32_t
|
||||
return uZ.f;
|
||||
|
||||
}
|
||||
|
||||
|
52
softfloat/source/s_normSubnormalBF16Sig.c
Normal file
52
softfloat/source/s_normSubnormalBF16Sig.c
Normal file
@ -0,0 +1,52 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
|
||||
struct exp8_sig16 softfloat_normSubnormalBF16Sig( uint_fast16_t sig )
|
||||
{
|
||||
int_fast8_t shiftDist;
|
||||
struct exp8_sig16 z;
|
||||
|
||||
shiftDist = softfloat_countLeadingZeros16( sig ) - 8;
|
||||
z.exp = 1 - shiftDist;
|
||||
z.sig = sig<<shiftDist;
|
||||
return z;
|
||||
|
||||
}
|
||||
|
114
softfloat/source/s_roundPackToBF16.c
Normal file
114
softfloat/source/s_roundPackToBF16.c
Normal file
@ -0,0 +1,114 @@
|
||||
|
||||
/*============================================================================
|
||||
|
||||
This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
|
||||
Package, Release 3e, by John R. Hauser.
|
||||
|
||||
Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
|
||||
California. All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions, and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions, and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
3. Neither the name of the University nor the names of its contributors may
|
||||
be used to endorse or promote products derived from this software without
|
||||
specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||||
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
=============================================================================*/
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include "platform.h"
|
||||
#include "internals.h"
|
||||
#include "softfloat.h"
|
||||
|
||||
/** sig last significant bit is sig[7], the 7 LSBs will be used for rounding */
|
||||
bfloat16_t
|
||||
softfloat_roundPackToBF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
|
||||
{
|
||||
uint_fast8_t roundingMode;
|
||||
bool roundNearEven;
|
||||
uint_fast8_t roundIncrement, roundBits;
|
||||
bool isTiny;
|
||||
uint_fast16_t uiZ;
|
||||
union ui16_bf16 uZ;
|
||||
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
roundingMode = softfloat_roundingMode;
|
||||
roundNearEven = (roundingMode == softfloat_round_near_even);
|
||||
roundIncrement = 0x40;
|
||||
if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
|
||||
roundIncrement =
|
||||
(roundingMode
|
||||
== (sign ? softfloat_round_min : softfloat_round_max))
|
||||
? 0x7F
|
||||
: 0;
|
||||
}
|
||||
roundBits = sig & 0x7F;
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
if ( 0xFD <= (unsigned int) exp ) {
|
||||
if ( exp < 0 ) {
|
||||
/*----------------------------------------------------------------
|
||||
*----------------------------------------------------------------*/
|
||||
isTiny =
|
||||
(softfloat_detectTininess == softfloat_tininess_beforeRounding)
|
||||
|| (exp < -1) || (sig + roundIncrement < 0x8000);
|
||||
sig = softfloat_shiftRightJam32( sig, -exp );
|
||||
exp = 0;
|
||||
roundBits = sig & 0x7F;
|
||||
if ( isTiny && roundBits ) {
|
||||
softfloat_raiseFlags( softfloat_flag_underflow );
|
||||
}
|
||||
} else if ( (0xFD < exp) || (0x8000 <= sig + roundIncrement) ) {
|
||||
/*----------------------------------------------------------------
|
||||
*----------------------------------------------------------------*/
|
||||
softfloat_raiseFlags(
|
||||
softfloat_flag_overflow | softfloat_flag_inexact );
|
||||
uiZ = packToBF16UI( sign, 0xFF, 0 ) - ! roundIncrement;
|
||||
goto uiZ;
|
||||
}
|
||||
}
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
sig = (sig + roundIncrement)>>7;
|
||||
if ( roundBits ) {
|
||||
softfloat_exceptionFlags |= softfloat_flag_inexact;
|
||||
#ifdef SOFTFLOAT_ROUND_ODD
|
||||
if ( roundingMode == softfloat_round_odd ) {
|
||||
sig |= 1;
|
||||
goto packReturn;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
sig &= ~(uint_fast16_t) (! (roundBits ^ 0x40) & roundNearEven);
|
||||
if ( ! sig ) exp = 0;
|
||||
/*------------------------------------------------------------------------
|
||||
*------------------------------------------------------------------------*/
|
||||
packReturn:
|
||||
uiZ = packToBF16UI( sign, exp, sig );
|
||||
uiZ:
|
||||
uZ.ui = uiZ;
|
||||
return uZ.f;
|
||||
|
||||
}
|
||||
|
@ -39,6 +39,7 @@
|
||||
#include "iss/instrumentation_if.h"
|
||||
#include "iss/log_categories.h"
|
||||
#include "iss/vm_if.h"
|
||||
#include "iss/vm_types.h"
|
||||
#include "riscv_hart_common.h"
|
||||
#include <stdexcept>
|
||||
#ifndef FMT_HEADER_ONLY
|
||||
@ -691,6 +692,11 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
|
||||
case traits<BASE>::CSR: {
|
||||
if(length != sizeof(reg_t))
|
||||
return iss::Err;
|
||||
// We emulate the FCSR in the architectural state
|
||||
if(addr == 3) {
|
||||
*data = this->get_fcsr();
|
||||
return iss::Ok;
|
||||
}
|
||||
return read_csr(addr, *reinterpret_cast<reg_t* const>(data));
|
||||
} break;
|
||||
case traits<BASE>::FENCE: {
|
||||
@ -822,6 +828,11 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
|
||||
case traits<BASE>::CSR: {
|
||||
if(length != sizeof(reg_t))
|
||||
return iss::Err;
|
||||
// We emulate the FCSR in the architectural state
|
||||
if(addr == 3) {
|
||||
this->set_fcsr(*data);
|
||||
return iss::Ok;
|
||||
}
|
||||
return write_csr(addr, *reinterpret_cast<const reg_t*>(data));
|
||||
} break;
|
||||
case traits<BASE>::FENCE: {
|
||||
|
@ -33,6 +33,7 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "fp_functions.h"
|
||||
#include <array>
|
||||
|
||||
extern "C" {
|
||||
#include "internals.h"
|
||||
@ -43,9 +44,10 @@ extern "C" {
|
||||
#include <limits>
|
||||
|
||||
using this_t = uint8_t*;
|
||||
const uint8_t rmm_map[] = {
|
||||
softfloat_round_near_even /*RNE*/, softfloat_round_minMag /*RTZ*/, softfloat_round_min /*RDN*/, softfloat_round_max /*RUP?*/,
|
||||
softfloat_round_near_maxMag /*RMM*/, softfloat_round_max /*RTZ*/, softfloat_round_max /*RTZ*/, softfloat_round_max /*RTZ*/,
|
||||
// this does not inlcude any reserved rm or the DYN rm, as DYN rm should be taken care of in the vm_impl
|
||||
const std::array<uint8_t, 5> rmm_map = {
|
||||
softfloat_round_near_even /*RNE*/, softfloat_round_minMag /*RTZ*/, softfloat_round_min /*RDN*/, softfloat_round_max /*RUP?*/,
|
||||
softfloat_round_near_maxMag /*RMM*/
|
||||
};
|
||||
|
||||
const uint32_t quiet_nan32 = 0x7fC00000;
|
||||
@ -56,7 +58,7 @@ uint32_t fget_flags() { return softfloat_exceptionFlags & 0x1f; }
|
||||
|
||||
uint32_t fadd_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
float32_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float32_t r = f32_add(v1f, v2f);
|
||||
return r.v;
|
||||
@ -64,7 +66,7 @@ uint32_t fadd_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
|
||||
uint32_t fsub_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
float32_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float32_t r = f32_sub(v1f, v2f);
|
||||
return r.v;
|
||||
@ -72,7 +74,7 @@ uint32_t fsub_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
|
||||
uint32_t fmul_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
float32_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float32_t r = f32_mul(v1f, v2f);
|
||||
return r.v;
|
||||
@ -80,7 +82,7 @@ uint32_t fmul_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
|
||||
uint32_t fdiv_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
float32_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float32_t r = f32_div(v1f, v2f);
|
||||
return r.v;
|
||||
@ -88,7 +90,7 @@ uint32_t fdiv_s(uint32_t v1, uint32_t v2, uint8_t mode) {
|
||||
|
||||
uint32_t fsqrt_s(uint32_t v1, uint8_t mode) {
|
||||
float32_t v1f{v1};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float32_t r = f32_sqrt(v1f);
|
||||
return r.v;
|
||||
@ -126,22 +128,23 @@ uint32_t fcmp_s(uint32_t v1, uint32_t v2, uint32_t op) {
|
||||
}
|
||||
|
||||
uint32_t fcvt_s(uint32_t v1, uint32_t op, uint8_t mode) {
|
||||
|
||||
float32_t v1f{v1};
|
||||
softfloat_exceptionFlags = 0;
|
||||
float32_t r;
|
||||
switch(op) {
|
||||
case 0: { // w->s, fp to int32
|
||||
uint_fast32_t res = f32_to_i32(v1f, rmm_map[mode & 0x7], true);
|
||||
case 0: { // FCVT__W__S
|
||||
uint_fast32_t res = f32_to_i32(v1f, rmm_map.at(mode), true);
|
||||
return (uint32_t)res;
|
||||
}
|
||||
case 1: { // wu->s
|
||||
uint_fast32_t res = f32_to_ui32(v1f, rmm_map[mode & 0x7], true);
|
||||
case 1: { // FCVT__WU__S
|
||||
uint_fast32_t res = f32_to_ui32(v1f, rmm_map.at(mode), true);
|
||||
return (uint32_t)res;
|
||||
}
|
||||
case 2: // s->w
|
||||
r = i32_to_f32(v1);
|
||||
case 2: // FCVT__S__W
|
||||
r = i32_to_f32((int32_t)v1);
|
||||
return r.v;
|
||||
case 3: // s->wu
|
||||
case 3: // FCVT__S__WU
|
||||
r = ui32_to_f32(v1);
|
||||
return r.v;
|
||||
}
|
||||
@ -149,12 +152,24 @@ uint32_t fcvt_s(uint32_t v1, uint32_t op, uint8_t mode) {
|
||||
}
|
||||
|
||||
uint32_t fmadd_s(uint32_t v1, uint32_t v2, uint32_t v3, uint32_t op, uint8_t mode) {
|
||||
// op should be {softfloat_mulAdd_subProd(2), softfloat_mulAdd_subC(1)}
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
uint32_t F32_SIGN = 1UL << 31;
|
||||
switch(op) {
|
||||
case 0: // FMADD_S
|
||||
break;
|
||||
case 1: // FMSUB_S
|
||||
v3 ^= F32_SIGN;
|
||||
break;
|
||||
case 2: // FNMADD_S
|
||||
v1 ^= F32_SIGN;
|
||||
v3 ^= F32_SIGN;
|
||||
break;
|
||||
case 3: // FNMSUB_S
|
||||
v1 ^= F32_SIGN;
|
||||
break;
|
||||
}
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float32_t res = softfloat_mulAddF32(v1, v2, v3, op & 0x1);
|
||||
if(op > 1)
|
||||
res.v ^= 1ULL << 31;
|
||||
float32_t res = softfloat_mulAddF32(v1, v2, v3, 0);
|
||||
return res.v;
|
||||
}
|
||||
|
||||
@ -203,7 +218,7 @@ uint32_t fclass_s(uint32_t v1) {
|
||||
}
|
||||
|
||||
uint32_t fconv_d2f(uint64_t v1, uint8_t mode) {
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
bool nan = (v1 & defaultNaNF64UI) == defaultNaNF64UI;
|
||||
if(nan) {
|
||||
return defaultNaNF32UI;
|
||||
@ -218,7 +233,7 @@ uint64_t fconv_f2d(uint32_t v1, uint8_t mode) {
|
||||
if(nan) {
|
||||
return defaultNaNF64UI;
|
||||
} else {
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
float64_t res = f32_to_f64(float32_t{v1});
|
||||
return res.v;
|
||||
}
|
||||
@ -228,7 +243,7 @@ uint64_t fadd_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
bool nan = (v1 & defaultNaNF32UI) == quiet_nan32;
|
||||
bool snan = softfloat_isSigNaNF32UI(v1);
|
||||
float64_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float64_t r = f64_add(v1f, v2f);
|
||||
return r.v;
|
||||
@ -236,7 +251,7 @@ uint64_t fadd_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
|
||||
uint64_t fsub_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
float64_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float64_t r = f64_sub(v1f, v2f);
|
||||
return r.v;
|
||||
@ -244,7 +259,7 @@ uint64_t fsub_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
|
||||
uint64_t fmul_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
float64_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float64_t r = f64_mul(v1f, v2f);
|
||||
return r.v;
|
||||
@ -252,7 +267,7 @@ uint64_t fmul_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
|
||||
uint64_t fdiv_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
float64_t v1f{v1}, v2f{v2};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float64_t r = f64_div(v1f, v2f);
|
||||
return r.v;
|
||||
@ -260,7 +275,7 @@ uint64_t fdiv_d(uint64_t v1, uint64_t v2, uint8_t mode) {
|
||||
|
||||
uint64_t fsqrt_d(uint64_t v1, uint8_t mode) {
|
||||
float64_t v1f{v1};
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float64_t r = f64_sqrt(v1f);
|
||||
return r.v;
|
||||
@ -303,11 +318,11 @@ uint64_t fcvt_d(uint64_t v1, uint32_t op, uint8_t mode) {
|
||||
float64_t r;
|
||||
switch(op) {
|
||||
case 0: { // l->d, fp to int32
|
||||
int64_t res = f64_to_i64(v1f, rmm_map[mode & 0x7], true);
|
||||
int64_t res = f64_to_i64(v1f, rmm_map.at(mode), true);
|
||||
return (uint64_t)res;
|
||||
}
|
||||
case 1: { // lu->s
|
||||
uint64_t res = f64_to_ui64(v1f, rmm_map[mode & 0x7], true);
|
||||
uint64_t res = f64_to_ui64(v1f, rmm_map.at(mode), true);
|
||||
return res;
|
||||
}
|
||||
case 2: // s->l
|
||||
@ -322,7 +337,7 @@ uint64_t fcvt_d(uint64_t v1, uint32_t op, uint8_t mode) {
|
||||
|
||||
uint64_t fmadd_d(uint64_t v1, uint64_t v2, uint64_t v3, uint32_t op, uint8_t mode) {
|
||||
// op should be {softfloat_mulAdd_subProd(2), softfloat_mulAdd_subC(1)}
|
||||
softfloat_roundingMode = rmm_map[mode & 0x7];
|
||||
softfloat_roundingMode = rmm_map.at(mode);
|
||||
softfloat_exceptionFlags = 0;
|
||||
float64_t res = softfloat_mulAddF64(v1, v2, v3, op & 0x1);
|
||||
if(op > 1)
|
||||
@ -381,9 +396,9 @@ uint64_t fcvt_32_64(uint32_t v1, uint32_t op, uint8_t mode) {
|
||||
float64_t r;
|
||||
switch(op) {
|
||||
case 0: // l->s, fp to int32
|
||||
return f32_to_i64(v1f, rmm_map[mode & 0x7], true);
|
||||
return f32_to_i64(v1f, rmm_map.at(mode), true);
|
||||
case 1: // wu->s
|
||||
return f32_to_ui64(v1f, rmm_map[mode & 0x7], true);
|
||||
return f32_to_ui64(v1f, rmm_map.at(mode), true);
|
||||
case 2: // s->w
|
||||
r = i32_to_f64(v1);
|
||||
return r.v;
|
||||
@ -399,11 +414,11 @@ uint32_t fcvt_64_32(uint64_t v1, uint32_t op, uint8_t mode) {
|
||||
float32_t r;
|
||||
switch(op) {
|
||||
case 0: { // wu->s
|
||||
int32_t r = f64_to_i32(float64_t{v1}, rmm_map[mode & 0x7], true);
|
||||
int32_t r = f64_to_i32(float64_t{v1}, rmm_map.at(mode), true);
|
||||
return r;
|
||||
}
|
||||
case 1: { // wu->s
|
||||
uint32_t r = f64_to_ui32(float64_t{v1}, rmm_map[mode & 0x7], true);
|
||||
uint32_t r = f64_to_ui32(float64_t{v1}, rmm_map.at(mode), true);
|
||||
return r;
|
||||
}
|
||||
case 2: // l->s, fp to int32
|
||||
|
Reference in New Issue
Block a user