From ab928baadbfd3316988a3ad5b5d9b84693a8636f Mon Sep 17 00:00:00 2001 From: Andrew Waterman Date: Fri, 15 Oct 2010 16:17:53 -0700 Subject: [sim] made softfloat files C instead of C++ --- Makefile.in | 13 +- softfloat/f32_add.c | 29 +++++ softfloat/f32_add.cc | 29 ----- softfloat/f32_div.c | 96 ++++++++++++++ softfloat/f32_div.cc | 96 -------------- softfloat/f32_eq.c | 34 +++++ softfloat/f32_eq.cc | 34 ----- softfloat/f32_eq_signaling.c | 29 +++++ softfloat/f32_eq_signaling.cc | 29 ----- softfloat/f32_isSignalingNaN.c | 16 +++ softfloat/f32_isSignalingNaN.cc | 16 --- softfloat/f32_le.c | 34 +++++ softfloat/f32_le.cc | 34 ----- softfloat/f32_le_quiet.c | 39 ++++++ softfloat/f32_le_quiet.cc | 39 ------ softfloat/f32_lt.c | 34 +++++ softfloat/f32_lt.cc | 34 ----- softfloat/f32_lt_quiet.c | 39 ++++++ softfloat/f32_lt_quiet.cc | 39 ------ softfloat/f32_mul.c | 89 +++++++++++++ softfloat/f32_mul.cc | 89 ------------- softfloat/f32_mulAdd.c | 25 ++++ softfloat/f32_mulAdd.cc | 25 ---- softfloat/f32_rem.c | 124 ++++++++++++++++++ softfloat/f32_rem.cc | 124 ------------------ softfloat/f32_roundToInt.c | 78 ++++++++++++ softfloat/f32_roundToInt.cc | 78 ------------ softfloat/f32_sqrt.c | 74 +++++++++++ softfloat/f32_sqrt.cc | 74 ----------- softfloat/f32_sub.c | 29 +++++ softfloat/f32_sub.cc | 29 ----- softfloat/f32_to_f64.c | 47 +++++++ softfloat/f32_to_f64.cc | 47 ------- softfloat/f32_to_i32.c | 34 +++++ softfloat/f32_to_i32.cc | 34 ----- softfloat/f32_to_i32_r_minMag.c | 45 +++++++ softfloat/f32_to_i32_r_minMag.cc | 45 ------- softfloat/f32_to_i64.c | 44 +++++++ softfloat/f32_to_i64.cc | 44 ------- softfloat/f32_to_i64_r_minMag.c | 52 ++++++++ softfloat/f32_to_i64_r_minMag.cc | 52 -------- softfloat/f32_to_ui32.c | 33 +++++ softfloat/f32_to_ui32.cc | 33 ----- softfloat/f32_to_ui32_r_minMag.c | 41 ++++++ softfloat/f32_to_ui32_r_minMag.cc | 41 ------ softfloat/f32_to_ui64.c | 42 +++++++ softfloat/f32_to_ui64.cc | 42 ------- softfloat/f32_to_ui64_r_minMag.c | 45 +++++++ softfloat/f32_to_ui64_r_minMag.cc | 45 ------- softfloat/f64_add.c | 29 +++++ softfloat/f64_add.cc | 29 ----- softfloat/f64_div.c | 104 +++++++++++++++ softfloat/f64_div.cc | 104 --------------- softfloat/f64_eq.c | 35 ++++++ softfloat/f64_eq.cc | 35 ------ softfloat/f64_eq_signaling.c | 30 +++++ softfloat/f64_eq_signaling.cc | 30 ----- softfloat/f64_isSignalingNaN.c | 16 +++ softfloat/f64_isSignalingNaN.cc | 16 --- softfloat/f64_le.c | 35 ++++++ softfloat/f64_le.cc | 35 ------ softfloat/f64_le_quiet.c | 40 ++++++ softfloat/f64_le_quiet.cc | 40 ------ softfloat/f64_lt.c | 35 ++++++ softfloat/f64_lt.cc | 35 ------ softfloat/f64_lt_quiet.c | 40 ++++++ softfloat/f64_lt_quiet.cc | 40 ------ softfloat/f64_mul.c | 91 ++++++++++++++ softfloat/f64_mul.cc | 91 -------------- softfloat/f64_mulAdd.c | 25 ++++ softfloat/f64_mulAdd.cc | 25 ---- softfloat/f64_rem.c | 113 +++++++++++++++++ softfloat/f64_rem.cc | 113 ----------------- softfloat/f64_roundToInt.c | 80 ++++++++++++ softfloat/f64_roundToInt.cc | 80 ------------ softfloat/f64_sqrt.c | 74 +++++++++++ softfloat/f64_sqrt.cc | 74 ----------- softfloat/f64_sub.c | 29 +++++ softfloat/f64_sub.cc | 29 ----- softfloat/f64_to_f32.c | 43 +++++++ softfloat/f64_to_f32.cc | 43 ------- softfloat/f64_to_i32.c | 30 +++++ softfloat/f64_to_i32.cc | 30 ----- softfloat/f64_to_i32_r_minMag.c | 50 ++++++++ softfloat/f64_to_i32_r_minMag.cc | 50 -------- softfloat/f64_to_i64.c | 46 +++++++ softfloat/f64_to_i64.cc | 46 ------- softfloat/f64_to_i64_r_minMag.c | 52 ++++++++ softfloat/f64_to_i64_r_minMag.cc | 52 -------- softfloat/f64_to_ui32.c | 29 +++++ softfloat/f64_to_ui32.cc | 29 ----- softfloat/f64_to_ui32_r_minMag.c | 40 ++++++ softfloat/f64_to_ui32_r_minMag.cc | 40 ------ softfloat/f64_to_ui64.c | 41 ++++++ softfloat/f64_to_ui64.cc | 41 ------ softfloat/f64_to_ui64_r_minMag.c | 45 +++++++ softfloat/f64_to_ui64_r_minMag.cc | 45 ------- softfloat/i32_to_f32.c | 21 ++++ softfloat/i32_to_f32.cc | 21 ---- softfloat/i32_to_f64.c | 31 +++++ softfloat/i32_to_f64.cc | 31 ----- softfloat/i64_to_f32.c | 36 ++++++ softfloat/i64_to_f32.cc | 36 ------ softfloat/i64_to_f64.c | 21 ++++ softfloat/i64_to_f64.cc | 21 ---- softfloat/s_add128.c | 17 +++ softfloat/s_add128.cc | 17 --- softfloat/s_add192.c | 30 +++++ softfloat/s_add192.cc | 30 ----- softfloat/s_addMagsF32.c | 75 +++++++++++ softfloat/s_addMagsF32.cc | 75 ----------- softfloat/s_addMagsF64.c | 77 ++++++++++++ softfloat/s_addMagsF64.cc | 77 ------------ softfloat/s_countLeadingZeros32.c | 22 ++++ softfloat/s_countLeadingZeros32.cc | 22 ---- softfloat/s_countLeadingZeros64.c | 32 +++++ softfloat/s_countLeadingZeros64.cc | 32 ----- softfloat/s_countLeadingZeros8.c | 24 ++++ softfloat/s_countLeadingZeros8.cc | 24 ---- softfloat/s_eq128.c | 13 ++ softfloat/s_eq128.cc | 13 -- softfloat/s_estimateDiv128To64.c | 28 +++++ softfloat/s_estimateDiv128To64.cc | 28 ----- softfloat/s_estimateSqrt32.c | 37 ++++++ softfloat/s_estimateSqrt32.cc | 37 ------ softfloat/s_le128.c | 13 ++ softfloat/s_le128.cc | 13 -- softfloat/s_lt128.c | 13 ++ softfloat/s_lt128.cc | 13 -- softfloat/s_mul128By64To192.c | 20 +++ softfloat/s_mul128By64To192.cc | 20 --- softfloat/s_mul128To256.c | 28 +++++ softfloat/s_mul128To256.cc | 28 ----- softfloat/s_mul64To128.c | 28 +++++ softfloat/s_mul64To128.cc | 28 ----- softfloat/s_mulAddF32.c | 171 +++++++++++++++++++++++++ softfloat/s_mulAddF32.cc | 171 ------------------------- softfloat/s_mulAddF64.c | 188 +++++++++++++++++++++++++++ softfloat/s_mulAddF64.cc | 188 --------------------------- softfloat/s_normRoundPackToF32.c | 24 ++++ softfloat/s_normRoundPackToF32.cc | 24 ---- softfloat/s_normRoundPackToF64.c | 24 ++++ softfloat/s_normRoundPackToF64.cc | 24 ---- softfloat/s_normSubnormalF32Sig.c | 18 +++ softfloat/s_normSubnormalF32Sig.cc | 18 --- softfloat/s_normSubnormalF64Sig.c | 18 +++ softfloat/s_normSubnormalF64Sig.cc | 18 --- softfloat/s_roundPackToF32.c | 65 ++++++++++ softfloat/s_roundPackToF32.cc | 65 ---------- softfloat/s_roundPackToF64.c | 66 ++++++++++ softfloat/s_roundPackToF64.cc | 66 ---------- softfloat/s_roundPackToI32.c | 48 +++++++ softfloat/s_roundPackToI32.cc | 48 ------- softfloat/s_roundPackToI64.c | 52 ++++++++ softfloat/s_roundPackToI64.cc | 52 -------- softfloat/s_roundPackToUI32.c | 44 +++++++ softfloat/s_roundPackToUI32.cc | 44 ------- softfloat/s_roundPackToUI64.c | 46 +++++++ softfloat/s_roundPackToUI64.cc | 46 ------- softfloat/s_shift128ExtraRightJam.c | 38 ++++++ softfloat/s_shift128ExtraRightJam.cc | 38 ------ softfloat/s_shift128RightJam.c | 31 +++++ softfloat/s_shift128RightJam.cc | 31 ----- softfloat/s_shift32RightJam.c | 15 +++ softfloat/s_shift32RightJam.cc | 15 --- softfloat/s_shift64ExtraRightJam.c | 23 ++++ softfloat/s_shift64ExtraRightJam.cc | 23 ---- softfloat/s_shift64RightJam.c | 15 +++ softfloat/s_shift64RightJam.cc | 15 --- softfloat/s_shortShift128ExtraRightJam.c | 20 +++ softfloat/s_shortShift128ExtraRightJam.cc | 20 --- softfloat/s_shortShift128Left.c | 16 +++ softfloat/s_shortShift128Left.cc | 16 --- softfloat/s_shortShift128Right.c | 16 +++ softfloat/s_shortShift128Right.cc | 16 --- softfloat/s_shortShift192Left.c | 20 +++ softfloat/s_shortShift192Left.cc | 20 --- softfloat/s_shortShift32Right1Jam.c | 12 ++ softfloat/s_shortShift32Right1Jam.cc | 12 -- softfloat/s_shortShift64ExtraRightJam.c | 17 +++ softfloat/s_shortShift64ExtraRightJam.cc | 17 --- softfloat/s_shortShift64RightJam.c | 12 ++ softfloat/s_shortShift64RightJam.cc | 12 -- softfloat/s_sub128.c | 17 +++ softfloat/s_sub128.cc | 17 --- softfloat/s_sub192.c | 30 +++++ softfloat/s_sub192.cc | 30 ----- softfloat/s_subMagsF32.c | 81 ++++++++++++ softfloat/s_subMagsF32.cc | 81 ------------ softfloat/s_subMagsF64.c | 81 ++++++++++++ softfloat/s_subMagsF64.cc | 81 ------------ softfloat/softfloat.h | 8 ++ softfloat/softfloat.mk.in | 202 +++++++++++++++--------------- softfloat/softfloat_state.c | 19 +++ softfloat/softfloat_state.cc | 19 --- softfloat/ui32_to_f32.c | 25 ++++ softfloat/ui32_to_f32.cc | 25 ---- softfloat/ui32_to_f64.c | 26 ++++ softfloat/ui32_to_f64.cc | 26 ---- softfloat/ui64_to_f32.c | 31 +++++ softfloat/ui64_to_f32.cc | 31 ----- softfloat/ui64_to_f64.c | 25 ++++ softfloat/ui64_to_f64.cc | 25 ---- softfloat_riscv/s_commonNaNToF32UI.c | 17 +++ softfloat_riscv/s_commonNaNToF32UI.cc | 17 --- softfloat_riscv/s_commonNaNToF64UI.c | 18 +++ softfloat_riscv/s_commonNaNToF64UI.cc | 18 --- softfloat_riscv/s_f32UIToCommonNaN.c | 25 ++++ softfloat_riscv/s_f32UIToCommonNaN.cc | 25 ---- softfloat_riscv/s_f64UIToCommonNaN.c | 25 ++++ softfloat_riscv/s_f64UIToCommonNaN.cc | 25 ---- softfloat_riscv/s_isSigNaNF32UI.c | 13 ++ softfloat_riscv/s_isSigNaNF32UI.cc | 13 -- softfloat_riscv/s_isSigNaNF64UI.c | 15 +++ softfloat_riscv/s_isSigNaNF64UI.cc | 15 --- softfloat_riscv/s_propagateNaNF32UI.c | 55 ++++++++ softfloat_riscv/s_propagateNaNF32UI.cc | 55 -------- softfloat_riscv/s_propagateNaNF64UI.c | 55 ++++++++ softfloat_riscv/s_propagateNaNF64UI.cc | 55 -------- softfloat_riscv/softfloat_raiseFlags.c | 51 ++++++++ softfloat_riscv/softfloat_raiseFlags.cc | 51 -------- softfloat_riscv/softfloat_riscv.mk.in | 20 +-- 222 files changed, 4607 insertions(+), 4592 deletions(-) create mode 100755 softfloat/f32_add.c delete mode 100755 softfloat/f32_add.cc create mode 100755 softfloat/f32_div.c delete mode 100755 softfloat/f32_div.cc create mode 100755 softfloat/f32_eq.c delete mode 100755 softfloat/f32_eq.cc create mode 100755 softfloat/f32_eq_signaling.c delete mode 100755 softfloat/f32_eq_signaling.cc create mode 100755 softfloat/f32_isSignalingNaN.c delete mode 100755 softfloat/f32_isSignalingNaN.cc create mode 100755 softfloat/f32_le.c delete mode 100755 softfloat/f32_le.cc create mode 100755 softfloat/f32_le_quiet.c delete mode 100755 softfloat/f32_le_quiet.cc create mode 100755 softfloat/f32_lt.c delete mode 100755 softfloat/f32_lt.cc create mode 100755 softfloat/f32_lt_quiet.c delete mode 100755 softfloat/f32_lt_quiet.cc create mode 100755 softfloat/f32_mul.c delete mode 100755 softfloat/f32_mul.cc create mode 100755 softfloat/f32_mulAdd.c delete mode 100755 softfloat/f32_mulAdd.cc create mode 100755 softfloat/f32_rem.c delete mode 100755 softfloat/f32_rem.cc create mode 100755 softfloat/f32_roundToInt.c delete mode 100755 softfloat/f32_roundToInt.cc create mode 100755 softfloat/f32_sqrt.c delete mode 100755 softfloat/f32_sqrt.cc create mode 100755 softfloat/f32_sub.c delete mode 100755 softfloat/f32_sub.cc create mode 100755 softfloat/f32_to_f64.c delete mode 100755 softfloat/f32_to_f64.cc create mode 100755 softfloat/f32_to_i32.c delete mode 100755 softfloat/f32_to_i32.cc create mode 100755 softfloat/f32_to_i32_r_minMag.c delete mode 100755 softfloat/f32_to_i32_r_minMag.cc create mode 100755 softfloat/f32_to_i64.c delete mode 100755 softfloat/f32_to_i64.cc create mode 100755 softfloat/f32_to_i64_r_minMag.c delete mode 100755 softfloat/f32_to_i64_r_minMag.cc create mode 100755 softfloat/f32_to_ui32.c delete mode 100755 softfloat/f32_to_ui32.cc create mode 100755 softfloat/f32_to_ui32_r_minMag.c delete mode 100755 softfloat/f32_to_ui32_r_minMag.cc create mode 100755 softfloat/f32_to_ui64.c delete mode 100755 softfloat/f32_to_ui64.cc create mode 100755 softfloat/f32_to_ui64_r_minMag.c delete mode 100755 softfloat/f32_to_ui64_r_minMag.cc create mode 100755 softfloat/f64_add.c delete mode 100755 softfloat/f64_add.cc create mode 100755 softfloat/f64_div.c delete mode 100755 softfloat/f64_div.cc create mode 100755 softfloat/f64_eq.c delete mode 100755 softfloat/f64_eq.cc create mode 100755 softfloat/f64_eq_signaling.c delete mode 100755 softfloat/f64_eq_signaling.cc create mode 100755 softfloat/f64_isSignalingNaN.c delete mode 100755 softfloat/f64_isSignalingNaN.cc create mode 100755 softfloat/f64_le.c delete mode 100755 softfloat/f64_le.cc create mode 100755 softfloat/f64_le_quiet.c delete mode 100755 softfloat/f64_le_quiet.cc create mode 100755 softfloat/f64_lt.c delete mode 100755 softfloat/f64_lt.cc create mode 100755 softfloat/f64_lt_quiet.c delete mode 100755 softfloat/f64_lt_quiet.cc create mode 100755 softfloat/f64_mul.c delete mode 100755 softfloat/f64_mul.cc create mode 100755 softfloat/f64_mulAdd.c delete mode 100755 softfloat/f64_mulAdd.cc create mode 100755 softfloat/f64_rem.c delete mode 100755 softfloat/f64_rem.cc create mode 100755 softfloat/f64_roundToInt.c delete mode 100755 softfloat/f64_roundToInt.cc create mode 100755 softfloat/f64_sqrt.c delete mode 100755 softfloat/f64_sqrt.cc create mode 100755 softfloat/f64_sub.c delete mode 100755 softfloat/f64_sub.cc create mode 100755 softfloat/f64_to_f32.c delete mode 100755 softfloat/f64_to_f32.cc create mode 100755 softfloat/f64_to_i32.c delete mode 100755 softfloat/f64_to_i32.cc create mode 100755 softfloat/f64_to_i32_r_minMag.c delete mode 100755 softfloat/f64_to_i32_r_minMag.cc create mode 100755 softfloat/f64_to_i64.c delete mode 100755 softfloat/f64_to_i64.cc create mode 100755 softfloat/f64_to_i64_r_minMag.c delete mode 100755 softfloat/f64_to_i64_r_minMag.cc create mode 100755 softfloat/f64_to_ui32.c delete mode 100755 softfloat/f64_to_ui32.cc create mode 100755 softfloat/f64_to_ui32_r_minMag.c delete mode 100755 softfloat/f64_to_ui32_r_minMag.cc create mode 100755 softfloat/f64_to_ui64.c delete mode 100755 softfloat/f64_to_ui64.cc create mode 100755 softfloat/f64_to_ui64_r_minMag.c delete mode 100755 softfloat/f64_to_ui64_r_minMag.cc create mode 100755 softfloat/i32_to_f32.c delete mode 100755 softfloat/i32_to_f32.cc create mode 100755 softfloat/i32_to_f64.c delete mode 100755 softfloat/i32_to_f64.cc create mode 100755 softfloat/i64_to_f32.c delete mode 100755 softfloat/i64_to_f32.cc create mode 100755 softfloat/i64_to_f64.c delete mode 100755 softfloat/i64_to_f64.cc create mode 100755 softfloat/s_add128.c delete mode 100755 softfloat/s_add128.cc create mode 100755 softfloat/s_add192.c delete mode 100755 softfloat/s_add192.cc create mode 100755 softfloat/s_addMagsF32.c delete mode 100755 softfloat/s_addMagsF32.cc create mode 100755 softfloat/s_addMagsF64.c delete mode 100755 softfloat/s_addMagsF64.cc create mode 100755 softfloat/s_countLeadingZeros32.c delete mode 100755 softfloat/s_countLeadingZeros32.cc create mode 100755 softfloat/s_countLeadingZeros64.c delete mode 100755 softfloat/s_countLeadingZeros64.cc create mode 100755 softfloat/s_countLeadingZeros8.c delete mode 100755 softfloat/s_countLeadingZeros8.cc create mode 100755 softfloat/s_eq128.c delete mode 100755 softfloat/s_eq128.cc create mode 100755 softfloat/s_estimateDiv128To64.c delete mode 100755 softfloat/s_estimateDiv128To64.cc create mode 100755 softfloat/s_estimateSqrt32.c delete mode 100755 softfloat/s_estimateSqrt32.cc create mode 100755 softfloat/s_le128.c delete mode 100755 softfloat/s_le128.cc create mode 100755 softfloat/s_lt128.c delete mode 100755 softfloat/s_lt128.cc create mode 100755 softfloat/s_mul128By64To192.c delete mode 100755 softfloat/s_mul128By64To192.cc create mode 100755 softfloat/s_mul128To256.c delete mode 100755 softfloat/s_mul128To256.cc create mode 100755 softfloat/s_mul64To128.c delete mode 100755 softfloat/s_mul64To128.cc create mode 100755 softfloat/s_mulAddF32.c delete mode 100755 softfloat/s_mulAddF32.cc create mode 100755 softfloat/s_mulAddF64.c delete mode 100755 softfloat/s_mulAddF64.cc create mode 100755 softfloat/s_normRoundPackToF32.c delete mode 100755 softfloat/s_normRoundPackToF32.cc create mode 100755 softfloat/s_normRoundPackToF64.c delete mode 100755 softfloat/s_normRoundPackToF64.cc create mode 100755 softfloat/s_normSubnormalF32Sig.c delete mode 100755 softfloat/s_normSubnormalF32Sig.cc create mode 100755 softfloat/s_normSubnormalF64Sig.c delete mode 100755 softfloat/s_normSubnormalF64Sig.cc create mode 100755 softfloat/s_roundPackToF32.c delete mode 100755 softfloat/s_roundPackToF32.cc create mode 100755 softfloat/s_roundPackToF64.c delete mode 100755 softfloat/s_roundPackToF64.cc create mode 100755 softfloat/s_roundPackToI32.c delete mode 100755 softfloat/s_roundPackToI32.cc create mode 100755 softfloat/s_roundPackToI64.c delete mode 100755 softfloat/s_roundPackToI64.cc create mode 100755 softfloat/s_roundPackToUI32.c delete mode 100755 softfloat/s_roundPackToUI32.cc create mode 100755 softfloat/s_roundPackToUI64.c delete mode 100755 softfloat/s_roundPackToUI64.cc create mode 100755 softfloat/s_shift128ExtraRightJam.c delete mode 100755 softfloat/s_shift128ExtraRightJam.cc create mode 100755 softfloat/s_shift128RightJam.c delete mode 100755 softfloat/s_shift128RightJam.cc create mode 100755 softfloat/s_shift32RightJam.c delete mode 100755 softfloat/s_shift32RightJam.cc create mode 100755 softfloat/s_shift64ExtraRightJam.c delete mode 100755 softfloat/s_shift64ExtraRightJam.cc create mode 100755 softfloat/s_shift64RightJam.c delete mode 100755 softfloat/s_shift64RightJam.cc create mode 100755 softfloat/s_shortShift128ExtraRightJam.c delete mode 100755 softfloat/s_shortShift128ExtraRightJam.cc create mode 100755 softfloat/s_shortShift128Left.c delete mode 100755 softfloat/s_shortShift128Left.cc create mode 100755 softfloat/s_shortShift128Right.c delete mode 100755 softfloat/s_shortShift128Right.cc create mode 100755 softfloat/s_shortShift192Left.c delete mode 100755 softfloat/s_shortShift192Left.cc create mode 100755 softfloat/s_shortShift32Right1Jam.c delete mode 100755 softfloat/s_shortShift32Right1Jam.cc create mode 100755 softfloat/s_shortShift64ExtraRightJam.c delete mode 100755 softfloat/s_shortShift64ExtraRightJam.cc create mode 100755 softfloat/s_shortShift64RightJam.c delete mode 100755 softfloat/s_shortShift64RightJam.cc create mode 100755 softfloat/s_sub128.c delete mode 100755 softfloat/s_sub128.cc create mode 100755 softfloat/s_sub192.c delete mode 100755 softfloat/s_sub192.cc create mode 100755 softfloat/s_subMagsF32.c delete mode 100755 softfloat/s_subMagsF32.cc create mode 100755 softfloat/s_subMagsF64.c delete mode 100755 softfloat/s_subMagsF64.cc create mode 100755 softfloat/softfloat_state.c delete mode 100755 softfloat/softfloat_state.cc create mode 100755 softfloat/ui32_to_f32.c delete mode 100755 softfloat/ui32_to_f32.cc create mode 100755 softfloat/ui32_to_f64.c delete mode 100755 softfloat/ui32_to_f64.cc create mode 100755 softfloat/ui64_to_f32.c delete mode 100755 softfloat/ui64_to_f32.cc create mode 100755 softfloat/ui64_to_f64.c delete mode 100755 softfloat/ui64_to_f64.cc create mode 100755 softfloat_riscv/s_commonNaNToF32UI.c delete mode 100755 softfloat_riscv/s_commonNaNToF32UI.cc create mode 100755 softfloat_riscv/s_commonNaNToF64UI.c delete mode 100755 softfloat_riscv/s_commonNaNToF64UI.cc create mode 100755 softfloat_riscv/s_f32UIToCommonNaN.c delete mode 100755 softfloat_riscv/s_f32UIToCommonNaN.cc create mode 100755 softfloat_riscv/s_f64UIToCommonNaN.c delete mode 100755 softfloat_riscv/s_f64UIToCommonNaN.cc create mode 100755 softfloat_riscv/s_isSigNaNF32UI.c delete mode 100755 softfloat_riscv/s_isSigNaNF32UI.cc create mode 100755 softfloat_riscv/s_isSigNaNF64UI.c delete mode 100755 softfloat_riscv/s_isSigNaNF64UI.cc create mode 100755 softfloat_riscv/s_propagateNaNF32UI.c delete mode 100755 softfloat_riscv/s_propagateNaNF32UI.cc create mode 100755 softfloat_riscv/s_propagateNaNF64UI.c delete mode 100755 softfloat_riscv/s_propagateNaNF64UI.cc create mode 100755 softfloat_riscv/softfloat_raiseFlags.c delete mode 100755 softfloat_riscv/softfloat_raiseFlags.cc diff --git a/Makefile.in b/Makefile.in index c4279a5..53dfb60 100644 --- a/Makefile.in +++ b/Makefile.in @@ -82,11 +82,14 @@ VPATH := $(addprefix $(src_dir)/, $(sprojs_enabled)) # - CPPFLAGS : flags for the preprocessor (eg. -I,-D) # - CXXFLAGS : flags for C++ compiler (eg. -Wall,-g,-O3) +CC := @CC@ CXX := @CXX@ CPPFLAGS := @CPPFLAGS@ CXXFLAGS := @CXXFLAGS@ COMPILE := $(CXX) -MMD -MP $(CPPFLAGS) $(CXXFLAGS) \ $(sprojs_include) +COMPILE_C := $(CC) -MMD -MP $(CPPFLAGS) $(CXXFLAGS) \ + $(sprojs_include) # Linker # - LDFLAGS : Flags for the linker (eg. -L) # - LIBS : Library flags (eg. -l) @@ -169,7 +172,7 @@ define subproject_template # system will create a library for this subproject with just the # corresponding dummy object file. -ifeq ($$(strip $$($(2)_srcs)),) +ifeq ($$(strip $$($(2)_srcs) $$($(2)_c_srcs)),) $(2)_srcs += _$(1).cc $(2)_junk += _$(1).cc endif @@ -180,15 +183,19 @@ _$(1).cc : # Build the object files for this subproject $(2)_objs := $$(patsubst %.cc, %.o, $$($(2)_srcs)) +$(2)_c_objs := $$(patsubst %.c, %.o, $$($(2)_c_srcs)) $(2)_deps := $$(patsubst %.o, %.d, $$($(2)_objs)) +$(2)_c_deps := $$(patsubst %.o, %.d, $$($(2)_c_objs)) $$($(2)_objs) : %.o : %.cc $(COMPILE) -c $$< +$$($(2)_c_objs) : %.o : %.c + $(COMPILE_C) -c $$< -$(2)_junk += $$($(2)_objs) $$($(2)_deps) +$(2)_junk += $$($(2)_objs) $$($(2)_c_objs) $$($(2)_deps) $$($(2)_c_deps) # Build a library for this subproject -lib$(1).a : $$($(2)_objs) +lib$(1).a : $$($(2)_objs) $$($(2)_c_objs) $(AR) rcv $$@ $$^ $(RANLIB) $$@ diff --git a/softfloat/f32_add.c b/softfloat/f32_add.c new file mode 100755 index 0000000..dc53d68 --- /dev/null +++ b/softfloat/f32_add.c @@ -0,0 +1,29 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t f32_add( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signB; + float32_t ( *magsRoutine )( uint_fast32_t, uint_fast32_t, bool ); + + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF32UI( uiB ); + magsRoutine = + ( signA == signB ) ? softfloat_addMagsF32 : softfloat_subMagsF32; + return magsRoutine( uiA, uiB, signA ); + +} + diff --git a/softfloat/f32_add.cc b/softfloat/f32_add.cc deleted file mode 100755 index dc53d68..0000000 --- a/softfloat/f32_add.cc +++ /dev/null @@ -1,29 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float32_t f32_add( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool signA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signB; - float32_t ( *magsRoutine )( uint_fast32_t, uint_fast32_t, bool ); - - uA.f = a; - uiA = uA.ui; - signA = signF32UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF32UI( uiB ); - magsRoutine = - ( signA == signB ) ? softfloat_addMagsF32 : softfloat_subMagsF32; - return magsRoutine( uiA, uiB, signA ); - -} - diff --git a/softfloat/f32_div.c b/softfloat/f32_div.c new file mode 100755 index 0000000..958b140 --- /dev/null +++ b/softfloat/f32_div.c @@ -0,0 +1,96 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_div( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signB; + int_fast16_t expB; + uint_fast32_t sigB; + bool signZ; + struct exp16_sig32 normExpSig; + int_fast16_t expZ; + uint_fast32_t sigZ; + uint_fast32_t uiZ; + union ui32_f32 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF32UI( uiB ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + signZ = signA ^ signB; + if ( expA == 0xFF ) { + if ( sigA ) goto propagateNaN; + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + goto invalid; + } + goto infinity; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + goto zero; + } + if ( ! expB ) { + if ( ! sigB ) { + if ( ! ( expA | sigA ) ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinity ); + goto infinity; + } + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + expZ = expA - expB + 0x7D; + sigA = ( sigA | 0x00800000 )<<7; + sigB = ( sigB | 0x00800000 )<<8; + if ( sigB <= ( sigA + sigA ) ) { + ++expZ; + sigA >>= 1; + } + sigZ = ( (uint_fast64_t) sigA<<32 ) / sigB; + if ( ! ( sigZ & 0x3F ) ) { + sigZ |= ( (uint_fast64_t) sigB * sigZ != (uint_fast64_t) sigA<<32 ); + } + return softfloat_roundPackToF32( signZ, expZ, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + goto uiZ; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + goto uiZ; + infinity: + uiZ = packToF32UI( signZ, 0xFF, 0 ); + goto uiZ; + zero: + uiZ = packToF32UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f32_div.cc b/softfloat/f32_div.cc deleted file mode 100755 index 958b140..0000000 --- a/softfloat/f32_div.cc +++ /dev/null @@ -1,96 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t f32_div( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool signA; - int_fast16_t expA; - uint_fast32_t sigA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signB; - int_fast16_t expB; - uint_fast32_t sigB; - bool signZ; - struct exp16_sig32 normExpSig; - int_fast16_t expZ; - uint_fast32_t sigZ; - uint_fast32_t uiZ; - union ui32_f32 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF32UI( uiA ); - expA = expF32UI( uiA ); - sigA = fracF32UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF32UI( uiB ); - expB = expF32UI( uiB ); - sigB = fracF32UI( uiB ); - signZ = signA ^ signB; - if ( expA == 0xFF ) { - if ( sigA ) goto propagateNaN; - if ( expB == 0xFF ) { - if ( sigB ) goto propagateNaN; - goto invalid; - } - goto infinity; - } - if ( expB == 0xFF ) { - if ( sigB ) goto propagateNaN; - goto zero; - } - if ( ! expB ) { - if ( ! sigB ) { - if ( ! ( expA | sigA ) ) goto invalid; - softfloat_raiseFlags( softfloat_flag_infinity ); - goto infinity; - } - normExpSig = softfloat_normSubnormalF32Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - if ( ! expA ) { - if ( ! sigA ) goto zero; - normExpSig = softfloat_normSubnormalF32Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - expZ = expA - expB + 0x7D; - sigA = ( sigA | 0x00800000 )<<7; - sigB = ( sigB | 0x00800000 )<<8; - if ( sigB <= ( sigA + sigA ) ) { - ++expZ; - sigA >>= 1; - } - sigZ = ( (uint_fast64_t) sigA<<32 ) / sigB; - if ( ! ( sigZ & 0x3F ) ) { - sigZ |= ( (uint_fast64_t) sigB * sigZ != (uint_fast64_t) sigA<<32 ); - } - return softfloat_roundPackToF32( signZ, expZ, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); - goto uiZ; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF32UI; - goto uiZ; - infinity: - uiZ = packToF32UI( signZ, 0xFF, 0 ); - goto uiZ; - zero: - uiZ = packToF32UI( signZ, 0, 0 ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f32_eq.c b/softfloat/f32_eq.c new file mode 100755 index 0000000..8f2306b --- /dev/null +++ b/softfloat/f32_eq.c @@ -0,0 +1,34 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_eq( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) + || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) + ) { + if ( + softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + return ( uiA == uiB ) || ! (uint32_t) ( ( uiA | uiB )<<1 ); + +} + diff --git a/softfloat/f32_eq.cc b/softfloat/f32_eq.cc deleted file mode 100755 index 8f2306b..0000000 --- a/softfloat/f32_eq.cc +++ /dev/null @@ -1,34 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f32_eq( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - union ui32_f32 uB; - uint_fast32_t uiB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) - || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) - ) { - if ( - softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - return false; - } - return ( uiA == uiB ) || ! (uint32_t) ( ( uiA | uiB )<<1 ); - -} - diff --git a/softfloat/f32_eq_signaling.c b/softfloat/f32_eq_signaling.c new file mode 100755 index 0000000..bfba48a --- /dev/null +++ b/softfloat/f32_eq_signaling.c @@ -0,0 +1,29 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f32_eq_signaling( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) + || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + return ( uiA == uiB ) || ! (uint32_t) ( ( uiA | uiB )<<1 ); + +} + diff --git a/softfloat/f32_eq_signaling.cc b/softfloat/f32_eq_signaling.cc deleted file mode 100755 index bfba48a..0000000 --- a/softfloat/f32_eq_signaling.cc +++ /dev/null @@ -1,29 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -bool f32_eq_signaling( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - union ui32_f32 uB; - uint_fast32_t uiB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) - || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return false; - } - return ( uiA == uiB ) || ! (uint32_t) ( ( uiA | uiB )<<1 ); - -} - diff --git a/softfloat/f32_isSignalingNaN.c b/softfloat/f32_isSignalingNaN.c new file mode 100755 index 0000000..09aaa82 --- /dev/null +++ b/softfloat/f32_isSignalingNaN.c @@ -0,0 +1,16 @@ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_isSignalingNaN( float32_t a ) +{ + union ui32_f32 uA; + + uA.f = a; + return softfloat_isSigNaNF32UI( uA.ui ); + +} + diff --git a/softfloat/f32_isSignalingNaN.cc b/softfloat/f32_isSignalingNaN.cc deleted file mode 100755 index 09aaa82..0000000 --- a/softfloat/f32_isSignalingNaN.cc +++ /dev/null @@ -1,16 +0,0 @@ - -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f32_isSignalingNaN( float32_t a ) -{ - union ui32_f32 uA; - - uA.f = a; - return softfloat_isSigNaNF32UI( uA.ui ); - -} - diff --git a/softfloat/f32_le.c b/softfloat/f32_le.c new file mode 100755 index 0000000..5f47be5 --- /dev/null +++ b/softfloat/f32_le.c @@ -0,0 +1,34 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f32_le( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) + || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + ( signA != signB ) ? signA || ! (uint32_t) ( ( uiA | uiB )<<1 ) + : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f32_le.cc b/softfloat/f32_le.cc deleted file mode 100755 index 5f47be5..0000000 --- a/softfloat/f32_le.cc +++ /dev/null @@ -1,34 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -bool f32_le( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) - || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return false; - } - signA = signF32UI( uiA ); - signB = signF32UI( uiB ); - return - ( signA != signB ) ? signA || ! (uint32_t) ( ( uiA | uiB )<<1 ) - : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f32_le_quiet.c b/softfloat/f32_le_quiet.c new file mode 100755 index 0000000..2b541da --- /dev/null +++ b/softfloat/f32_le_quiet.c @@ -0,0 +1,39 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_le_quiet( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) + || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) + ) { + if ( + softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + ( signA != signB ) ? signA || ! (uint32_t) ( ( uiA | uiB )<<1 ) + : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f32_le_quiet.cc b/softfloat/f32_le_quiet.cc deleted file mode 100755 index 2b541da..0000000 --- a/softfloat/f32_le_quiet.cc +++ /dev/null @@ -1,39 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f32_le_quiet( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) - || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) - ) { - if ( - softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - return false; - } - signA = signF32UI( uiA ); - signB = signF32UI( uiB ); - return - ( signA != signB ) ? signA || ! (uint32_t) ( ( uiA | uiB )<<1 ) - : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f32_lt.c b/softfloat/f32_lt.c new file mode 100755 index 0000000..753b28a --- /dev/null +++ b/softfloat/f32_lt.c @@ -0,0 +1,34 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f32_lt( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) + || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + ( signA != signB ) ? signA && ( (uint32_t) ( ( uiA | uiB )<<1 ) != 0 ) + : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f32_lt.cc b/softfloat/f32_lt.cc deleted file mode 100755 index 753b28a..0000000 --- a/softfloat/f32_lt.cc +++ /dev/null @@ -1,34 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -bool f32_lt( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) - || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return false; - } - signA = signF32UI( uiA ); - signB = signF32UI( uiB ); - return - ( signA != signB ) ? signA && ( (uint32_t) ( ( uiA | uiB )<<1 ) != 0 ) - : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f32_lt_quiet.c b/softfloat/f32_lt_quiet.c new file mode 100755 index 0000000..ecd90bf --- /dev/null +++ b/softfloat/f32_lt_quiet.c @@ -0,0 +1,39 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f32_lt_quiet( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) + || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) + ) { + if ( + softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF32UI( uiA ); + signB = signF32UI( uiB ); + return + ( signA != signB ) ? signA && ( (uint32_t) ( ( uiA | uiB )<<1 ) != 0 ) + : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f32_lt_quiet.cc b/softfloat/f32_lt_quiet.cc deleted file mode 100755 index ecd90bf..0000000 --- a/softfloat/f32_lt_quiet.cc +++ /dev/null @@ -1,39 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f32_lt_quiet( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF32UI( uiA ) == 0xFF ) && fracF32UI( uiA ) ) - || ( ( expF32UI( uiB ) == 0xFF ) && fracF32UI( uiB ) ) - ) { - if ( - softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - return false; - } - signA = signF32UI( uiA ); - signB = signF32UI( uiB ); - return - ( signA != signB ) ? signA && ( (uint32_t) ( ( uiA | uiB )<<1 ) != 0 ) - : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f32_mul.c b/softfloat/f32_mul.c new file mode 100755 index 0000000..d49c1dd --- /dev/null +++ b/softfloat/f32_mul.c @@ -0,0 +1,89 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_mul( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signB; + int_fast16_t expB; + uint_fast32_t sigB; + bool signZ; + uint_fast32_t magBits; + struct exp16_sig32 normExpSig; + int_fast16_t expZ; + uint_fast32_t sigZ, uiZ; + union ui32_f32 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF32UI( uiB ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + signZ = signA ^ signB; + if ( expA == 0xFF ) { + if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN; + magBits = expB | sigB; + goto infArg; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + magBits = expA | sigA; + goto infArg; + } + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zero; + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + expZ = expA + expB - 0x7F; + sigA = ( sigA | 0x00800000 )<<7; + sigB = ( sigB | 0x00800000 )<<8; + sigZ = softfloat_shortShift64RightJam( (uint_fast64_t) sigA * sigB, 32 ); + if ( sigZ < 0x40000000 ) { + --expZ; + sigZ <<= 1; + } + return softfloat_roundPackToF32( signZ, expZ, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + goto uiZ; + infArg: + if ( ! magBits ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + } else { + uiZ = packToF32UI( signZ, 0xFF, 0 ); + } + goto uiZ; + zero: + uiZ = packToF32UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f32_mul.cc b/softfloat/f32_mul.cc deleted file mode 100755 index d49c1dd..0000000 --- a/softfloat/f32_mul.cc +++ /dev/null @@ -1,89 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t f32_mul( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool signA; - int_fast16_t expA; - uint_fast32_t sigA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signB; - int_fast16_t expB; - uint_fast32_t sigB; - bool signZ; - uint_fast32_t magBits; - struct exp16_sig32 normExpSig; - int_fast16_t expZ; - uint_fast32_t sigZ, uiZ; - union ui32_f32 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF32UI( uiA ); - expA = expF32UI( uiA ); - sigA = fracF32UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF32UI( uiB ); - expB = expF32UI( uiB ); - sigB = fracF32UI( uiB ); - signZ = signA ^ signB; - if ( expA == 0xFF ) { - if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN; - magBits = expB | sigB; - goto infArg; - } - if ( expB == 0xFF ) { - if ( sigB ) goto propagateNaN; - magBits = expA | sigA; - goto infArg; - } - if ( ! expA ) { - if ( ! sigA ) goto zero; - normExpSig = softfloat_normSubnormalF32Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - if ( ! expB ) { - if ( ! sigB ) goto zero; - normExpSig = softfloat_normSubnormalF32Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - expZ = expA + expB - 0x7F; - sigA = ( sigA | 0x00800000 )<<7; - sigB = ( sigB | 0x00800000 )<<8; - sigZ = softfloat_shortShift64RightJam( (uint_fast64_t) sigA * sigB, 32 ); - if ( sigZ < 0x40000000 ) { - --expZ; - sigZ <<= 1; - } - return softfloat_roundPackToF32( signZ, expZ, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); - goto uiZ; - infArg: - if ( ! magBits ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF32UI; - } else { - uiZ = packToF32UI( signZ, 0xFF, 0 ); - } - goto uiZ; - zero: - uiZ = packToF32UI( signZ, 0, 0 ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f32_mulAdd.c b/softfloat/f32_mulAdd.c new file mode 100755 index 0000000..3d4cee9 --- /dev/null +++ b/softfloat/f32_mulAdd.c @@ -0,0 +1,25 @@ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + union ui32_f32 uB; + uint_fast32_t uiB; + union ui32_f32 uC; + uint_fast32_t uiC; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + uC.f = c; + uiC = uC.ui; + return softfloat_mulAddF32( 0, uiA, uiB, uiC ); + +} + diff --git a/softfloat/f32_mulAdd.cc b/softfloat/f32_mulAdd.cc deleted file mode 100755 index 3d4cee9..0000000 --- a/softfloat/f32_mulAdd.cc +++ /dev/null @@ -1,25 +0,0 @@ - -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - union ui32_f32 uB; - uint_fast32_t uiB; - union ui32_f32 uC; - uint_fast32_t uiC; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - uC.f = c; - uiC = uC.ui; - return softfloat_mulAddF32( 0, uiA, uiB, uiC ); - -} - diff --git a/softfloat/f32_rem.c b/softfloat/f32_rem.c new file mode 100755 index 0000000..d29b840 --- /dev/null +++ b/softfloat/f32_rem.c @@ -0,0 +1,124 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_rem( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signB; + int_fast16_t expB; + uint_fast32_t sigB; + struct exp16_sig32 normExpSig; + int_fast16_t expDiff; + uint_fast32_t q; + uint_fast64_t sigA64, sigB64, q64; + uint_fast32_t alternateSigA; + uint32_t sigMean; + bool signZ; + uint_fast32_t uiZ; + union ui32_f32 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF32UI( uiB ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + if ( expA == 0xFF ) { + if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN; + goto invalid; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + return a; + } + if ( ! expB ) { + if ( ! sigB ) goto invalid; + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + expDiff = expA - expB; + sigA |= 0x00800000; + sigB |= 0x00800000; + if ( expDiff < 32 ) { + sigA <<= 8; + sigB <<= 8; + if ( expDiff < 0 ) { + if ( expDiff < -1 ) return a; + sigA >>= 1; + } + q = ( sigB <= sigA ); + if ( q ) sigA -= sigB; + if ( 0 < expDiff ) { + q = ( (uint_fast64_t) sigA<<32 ) / sigB; + q >>= 32 - expDiff; + sigB >>= 2; + sigA = ( ( sigA>>1 )<<( expDiff - 1 ) ) - sigB * q; + } else { + sigA >>= 2; + sigB >>= 2; + } + } else { + if ( sigB <= sigA ) sigA -= sigB; + sigA64 = (uint_fast64_t) sigA<<40; + sigB64 = (uint_fast64_t) sigB<<40; + expDiff -= 64; + while ( 0 < expDiff ) { + q64 = softfloat_estimateDiv128To64( sigA64, 0, sigB64 ); + q64 = ( 2 < q64 ) ? q64 - 2 : 0; + sigA64 = - ( ( sigB * q64 )<<38 ); + expDiff -= 62; + } + expDiff += 64; + q64 = softfloat_estimateDiv128To64( sigA64, 0, sigB64 ); + q64 = ( 2 < q64 ) ? q64 - 2 : 0; + q = q64>>( 64 - expDiff ); + sigB <<= 6; + sigA = ( ( sigA64>>33 )<<( expDiff - 1 ) ) - sigB * q; + } + do { + alternateSigA = sigA; + ++q; + sigA -= sigB; + } while ( sigA < 0x80000000 ); + sigMean = sigA + alternateSigA; + if ( ( 0x80000000 <= sigMean ) || ( ! sigMean && ( q & 1 ) ) ) { + sigA = alternateSigA; + } + signZ = ( 0x80000000 <= sigA ); + if ( signZ ) sigA = - sigA; + return softfloat_normRoundPackToF32( signA ^ signZ, expB, sigA ); + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + goto uiZ; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f32_rem.cc b/softfloat/f32_rem.cc deleted file mode 100755 index d29b840..0000000 --- a/softfloat/f32_rem.cc +++ /dev/null @@ -1,124 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t f32_rem( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool signA; - int_fast16_t expA; - uint_fast32_t sigA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signB; - int_fast16_t expB; - uint_fast32_t sigB; - struct exp16_sig32 normExpSig; - int_fast16_t expDiff; - uint_fast32_t q; - uint_fast64_t sigA64, sigB64, q64; - uint_fast32_t alternateSigA; - uint32_t sigMean; - bool signZ; - uint_fast32_t uiZ; - union ui32_f32 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF32UI( uiA ); - expA = expF32UI( uiA ); - sigA = fracF32UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF32UI( uiB ); - expB = expF32UI( uiB ); - sigB = fracF32UI( uiB ); - if ( expA == 0xFF ) { - if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN; - goto invalid; - } - if ( expB == 0xFF ) { - if ( sigB ) goto propagateNaN; - return a; - } - if ( ! expB ) { - if ( ! sigB ) goto invalid; - normExpSig = softfloat_normSubnormalF32Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - if ( ! expA ) { - if ( ! sigA ) return a; - normExpSig = softfloat_normSubnormalF32Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - expDiff = expA - expB; - sigA |= 0x00800000; - sigB |= 0x00800000; - if ( expDiff < 32 ) { - sigA <<= 8; - sigB <<= 8; - if ( expDiff < 0 ) { - if ( expDiff < -1 ) return a; - sigA >>= 1; - } - q = ( sigB <= sigA ); - if ( q ) sigA -= sigB; - if ( 0 < expDiff ) { - q = ( (uint_fast64_t) sigA<<32 ) / sigB; - q >>= 32 - expDiff; - sigB >>= 2; - sigA = ( ( sigA>>1 )<<( expDiff - 1 ) ) - sigB * q; - } else { - sigA >>= 2; - sigB >>= 2; - } - } else { - if ( sigB <= sigA ) sigA -= sigB; - sigA64 = (uint_fast64_t) sigA<<40; - sigB64 = (uint_fast64_t) sigB<<40; - expDiff -= 64; - while ( 0 < expDiff ) { - q64 = softfloat_estimateDiv128To64( sigA64, 0, sigB64 ); - q64 = ( 2 < q64 ) ? q64 - 2 : 0; - sigA64 = - ( ( sigB * q64 )<<38 ); - expDiff -= 62; - } - expDiff += 64; - q64 = softfloat_estimateDiv128To64( sigA64, 0, sigB64 ); - q64 = ( 2 < q64 ) ? q64 - 2 : 0; - q = q64>>( 64 - expDiff ); - sigB <<= 6; - sigA = ( ( sigA64>>33 )<<( expDiff - 1 ) ) - sigB * q; - } - do { - alternateSigA = sigA; - ++q; - sigA -= sigB; - } while ( sigA < 0x80000000 ); - sigMean = sigA + alternateSigA; - if ( ( 0x80000000 <= sigMean ) || ( ! sigMean && ( q & 1 ) ) ) { - sigA = alternateSigA; - } - signZ = ( 0x80000000 <= sigA ); - if ( signZ ) sigA = - sigA; - return softfloat_normRoundPackToF32( signA ^ signZ, expB, sigA ); - propagateNaN: - uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); - goto uiZ; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF32UI; - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f32_roundToInt.c b/softfloat/f32_roundToInt.c new file mode 100755 index 0000000..f8f9114 --- /dev/null +++ b/softfloat/f32_roundToInt.c @@ -0,0 +1,78 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_roundToInt( float32_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t expA; + uint_fast32_t uiZ; + bool signA; + uint_fast32_t lastBitMask, roundBitsMask; + union ui32_f32 uZ; + + uA.f = a; + uiA = uA.ui; + expA = expF32UI( uiA ); + if ( 0x96 <= expA ) { + if ( ( expA == 0xFF ) && fracF32UI( uiA ) ) { + uiZ = softfloat_propagateNaNF32UI( uiA, 0 ); + goto uiZ; + } + return a; + } + if ( expA <= 0x7E ) { + if ( ! (uint32_t) ( uiA<<1 ) ) return a; + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + signA = signF32UI( uiA ); + switch ( roundingMode ) { + case softfloat_round_nearest_even: + if ( ( expA == 0x7E ) && fracF32UI( uiA ) ) { + uiZ = packToF32UI( signA, 0x7F, 0 ); + goto uiZ; + } + break; + case softfloat_round_min: + uiZ = signA ? 0xBF800000 : 0; + goto uiZ; + case softfloat_round_max: + uiZ = signA ? 0x80000000 : 0x3F800000; + goto uiZ; + case softfloat_round_nearest_maxMag: + if ( expA == 0x7E ) { + uiZ = packToF32UI( signA, 0x7F, 0 ); + goto uiZ; + } + break; + } + uiZ = packToF32UI( signA, 0, 0 ); + goto uiZ; + } + lastBitMask = (uint_fast32_t) 1<<( 0x96 - expA ); + roundBitsMask = lastBitMask - 1; + uiZ = uiA; + if ( roundingMode == softfloat_round_nearest_maxMag ) { + uiZ += lastBitMask>>1; + } else if ( roundingMode == softfloat_round_nearest_even ) { + uiZ += lastBitMask>>1; + if ( ! ( uiZ & roundBitsMask ) ) uiZ &= ~ lastBitMask; + } else if ( roundingMode != softfloat_round_minMag ) { + if ( signF32UI( uiZ ) ^ ( roundingMode == softfloat_round_max ) ) { + uiZ += roundBitsMask; + } + } + uiZ &= ~ roundBitsMask; + if ( exact && ( uiZ != uiA ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f32_roundToInt.cc b/softfloat/f32_roundToInt.cc deleted file mode 100755 index f8f9114..0000000 --- a/softfloat/f32_roundToInt.cc +++ /dev/null @@ -1,78 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t f32_roundToInt( float32_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - int_fast16_t expA; - uint_fast32_t uiZ; - bool signA; - uint_fast32_t lastBitMask, roundBitsMask; - union ui32_f32 uZ; - - uA.f = a; - uiA = uA.ui; - expA = expF32UI( uiA ); - if ( 0x96 <= expA ) { - if ( ( expA == 0xFF ) && fracF32UI( uiA ) ) { - uiZ = softfloat_propagateNaNF32UI( uiA, 0 ); - goto uiZ; - } - return a; - } - if ( expA <= 0x7E ) { - if ( ! (uint32_t) ( uiA<<1 ) ) return a; - if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; - signA = signF32UI( uiA ); - switch ( roundingMode ) { - case softfloat_round_nearest_even: - if ( ( expA == 0x7E ) && fracF32UI( uiA ) ) { - uiZ = packToF32UI( signA, 0x7F, 0 ); - goto uiZ; - } - break; - case softfloat_round_min: - uiZ = signA ? 0xBF800000 : 0; - goto uiZ; - case softfloat_round_max: - uiZ = signA ? 0x80000000 : 0x3F800000; - goto uiZ; - case softfloat_round_nearest_maxMag: - if ( expA == 0x7E ) { - uiZ = packToF32UI( signA, 0x7F, 0 ); - goto uiZ; - } - break; - } - uiZ = packToF32UI( signA, 0, 0 ); - goto uiZ; - } - lastBitMask = (uint_fast32_t) 1<<( 0x96 - expA ); - roundBitsMask = lastBitMask - 1; - uiZ = uiA; - if ( roundingMode == softfloat_round_nearest_maxMag ) { - uiZ += lastBitMask>>1; - } else if ( roundingMode == softfloat_round_nearest_even ) { - uiZ += lastBitMask>>1; - if ( ! ( uiZ & roundBitsMask ) ) uiZ &= ~ lastBitMask; - } else if ( roundingMode != softfloat_round_minMag ) { - if ( signF32UI( uiZ ) ^ ( roundingMode == softfloat_round_max ) ) { - uiZ += roundBitsMask; - } - } - uiZ &= ~ roundBitsMask; - if ( exact && ( uiZ != uiA ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f32_sqrt.c b/softfloat/f32_sqrt.c new file mode 100755 index 0000000..c9eb907 --- /dev/null +++ b/softfloat/f32_sqrt.c @@ -0,0 +1,74 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f32_sqrt( float32_t a ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + int_fast16_t expA; + uint_fast32_t sigA, uiZ; + struct exp16_sig32 normExpSig; + int_fast16_t expZ; + uint_fast32_t sigZ; + uint_fast64_t term, rem; + union ui32_f32 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + if ( expA == 0xFF ) { + if ( sigA ) { + uiZ = softfloat_propagateNaNF32UI( uiA, 0 ); + goto uiZ; + } + if ( ! signA ) return a; + goto invalid; + } + if ( signA ) { + if ( ! ( expA | sigA ) ) return a; + goto invalid; + } + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + expZ = ( ( expA - 0x7F )>>1 ) + 0x7E; + sigA = ( sigA | 0x00800000 )<<8; + sigZ = softfloat_estimateSqrt32( expA, sigA ) + 2; + if ( ( sigZ & 0x7F ) <= 5 ) { + if ( sigZ < 2 ) { + sigZ = 0x7FFFFFFF; + goto roundPack; + } + sigA >>= expA & 1; + term = (uint_fast64_t) sigZ * sigZ; + rem = ( (uint_fast64_t) sigA<<32 ) - term; + while ( UINT64_C( 0x8000000000000000 ) <= rem ) { + --sigZ; + rem += ( (uint_fast64_t) sigZ<<1 ) | 1; + } + sigZ |= ( rem != 0 ); + } + sigZ = softfloat_shortShift32Right1Jam( sigZ ); + roundPack: + return softfloat_roundPackToF32( 0, expZ, sigZ ); + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f32_sqrt.cc b/softfloat/f32_sqrt.cc deleted file mode 100755 index c9eb907..0000000 --- a/softfloat/f32_sqrt.cc +++ /dev/null @@ -1,74 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t f32_sqrt( float32_t a ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool signA; - int_fast16_t expA; - uint_fast32_t sigA, uiZ; - struct exp16_sig32 normExpSig; - int_fast16_t expZ; - uint_fast32_t sigZ; - uint_fast64_t term, rem; - union ui32_f32 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF32UI( uiA ); - expA = expF32UI( uiA ); - sigA = fracF32UI( uiA ); - if ( expA == 0xFF ) { - if ( sigA ) { - uiZ = softfloat_propagateNaNF32UI( uiA, 0 ); - goto uiZ; - } - if ( ! signA ) return a; - goto invalid; - } - if ( signA ) { - if ( ! ( expA | sigA ) ) return a; - goto invalid; - } - if ( ! expA ) { - if ( ! sigA ) return a; - normExpSig = softfloat_normSubnormalF32Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - expZ = ( ( expA - 0x7F )>>1 ) + 0x7E; - sigA = ( sigA | 0x00800000 )<<8; - sigZ = softfloat_estimateSqrt32( expA, sigA ) + 2; - if ( ( sigZ & 0x7F ) <= 5 ) { - if ( sigZ < 2 ) { - sigZ = 0x7FFFFFFF; - goto roundPack; - } - sigA >>= expA & 1; - term = (uint_fast64_t) sigZ * sigZ; - rem = ( (uint_fast64_t) sigA<<32 ) - term; - while ( UINT64_C( 0x8000000000000000 ) <= rem ) { - --sigZ; - rem += ( (uint_fast64_t) sigZ<<1 ) | 1; - } - sigZ |= ( rem != 0 ); - } - sigZ = softfloat_shortShift32Right1Jam( sigZ ); - roundPack: - return softfloat_roundPackToF32( 0, expZ, sigZ ); - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF32UI; - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f32_sub.c b/softfloat/f32_sub.c new file mode 100755 index 0000000..c64df8e --- /dev/null +++ b/softfloat/f32_sub.c @@ -0,0 +1,29 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t f32_sub( float32_t a, float32_t b ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool signA; + union ui32_f32 uB; + uint_fast32_t uiB; + bool signB; + float32_t ( *magsRoutine )( uint_fast32_t, uint_fast32_t, bool ); + + uA.f = a; + uiA = uA.ui; + signA = signF32UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF32UI( uiB ); + magsRoutine = + ( signA == signB ) ? softfloat_subMagsF32 : softfloat_addMagsF32; + return magsRoutine( uiA, uiB ^ 0x80000000, signA ); + +} + diff --git a/softfloat/f32_sub.cc b/softfloat/f32_sub.cc deleted file mode 100755 index c64df8e..0000000 --- a/softfloat/f32_sub.cc +++ /dev/null @@ -1,29 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float32_t f32_sub( float32_t a, float32_t b ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool signA; - union ui32_f32 uB; - uint_fast32_t uiB; - bool signB; - float32_t ( *magsRoutine )( uint_fast32_t, uint_fast32_t, bool ); - - uA.f = a; - uiA = uA.ui; - signA = signF32UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF32UI( uiB ); - magsRoutine = - ( signA == signB ) ? softfloat_subMagsF32 : softfloat_addMagsF32; - return magsRoutine( uiA, uiB ^ 0x80000000, signA ); - -} - diff --git a/softfloat/f32_to_f64.c b/softfloat/f32_to_f64.c new file mode 100755 index 0000000..9f0ae5c --- /dev/null +++ b/softfloat/f32_to_f64.c @@ -0,0 +1,47 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f32_to_f64( float32_t a ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + uint_fast64_t uiZ; + struct exp16_sig32 normExpSig; + union ui64_f64 uZ; + + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + if ( exp == 0xFF ) { + uiZ = + sig ? softfloat_commonNaNToF64UI( + softfloat_f32UIToCommonNaN( uiA ) ) + : packToF64UI( sign, 0x7FF, 0 ); + goto uiZ; + } + if ( ! exp ) { + if ( ! sig ) { + uiZ = packToF64UI( sign, 0, 0 ); + goto uiZ; + } + normExpSig = softfloat_normSubnormalF32Sig( sig ); + exp = normExpSig.exp - 1; + sig = normExpSig.sig; + } + uiZ = packToF64UI( sign, exp + 0x380, (uint_fast64_t) sig<<29 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f32_to_f64.cc b/softfloat/f32_to_f64.cc deleted file mode 100755 index 9f0ae5c..0000000 --- a/softfloat/f32_to_f64.cc +++ /dev/null @@ -1,47 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t f32_to_f64( float32_t a ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool sign; - int_fast16_t exp; - uint_fast32_t sig; - uint_fast64_t uiZ; - struct exp16_sig32 normExpSig; - union ui64_f64 uZ; - - uA.f = a; - uiA = uA.ui; - sign = signF32UI( uiA ); - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - if ( exp == 0xFF ) { - uiZ = - sig ? softfloat_commonNaNToF64UI( - softfloat_f32UIToCommonNaN( uiA ) ) - : packToF64UI( sign, 0x7FF, 0 ); - goto uiZ; - } - if ( ! exp ) { - if ( ! sig ) { - uiZ = packToF64UI( sign, 0, 0 ); - goto uiZ; - } - normExpSig = softfloat_normSubnormalF32Sig( sig ); - exp = normExpSig.exp - 1; - sig = normExpSig.sig; - } - uiZ = packToF64UI( sign, exp + 0x380, (uint_fast64_t) sig<<29 ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f32_to_i32.c b/softfloat/f32_to_i32.c new file mode 100755 index 0000000..bbbaee0 --- /dev/null +++ b/softfloat/f32_to_i32.c @@ -0,0 +1,34 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +int_fast32_t f32_to_i32( float32_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + uint_fast64_t sig64; + int_fast16_t shiftCount; + + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + if ( ( exp == 0xFF ) && sig ) sign = 0; + if ( exp ) sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<32; + shiftCount = 0xAF - exp; + if ( 0 < shiftCount ) { + sig64 = softfloat_shift64RightJam( sig64, shiftCount ); + } + return softfloat_roundPackToI32( sign, sig64, roundingMode, exact ); + +} + diff --git a/softfloat/f32_to_i32.cc b/softfloat/f32_to_i32.cc deleted file mode 100755 index bbbaee0..0000000 --- a/softfloat/f32_to_i32.cc +++ /dev/null @@ -1,34 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -int_fast32_t f32_to_i32( float32_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool sign; - int_fast16_t exp; - uint_fast32_t sig; - uint_fast64_t sig64; - int_fast16_t shiftCount; - - uA.f = a; - uiA = uA.ui; - sign = signF32UI( uiA ); - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - if ( ( exp == 0xFF ) && sig ) sign = 0; - if ( exp ) sig |= 0x00800000; - sig64 = (uint_fast64_t) sig<<32; - shiftCount = 0xAF - exp; - if ( 0 < shiftCount ) { - sig64 = softfloat_shift64RightJam( sig64, shiftCount ); - } - return softfloat_roundPackToI32( sign, sig64, roundingMode, exact ); - -} - diff --git a/softfloat/f32_to_i32_r_minMag.c b/softfloat/f32_to_i32_r_minMag.c new file mode 100755 index 0000000..63ff1e2 --- /dev/null +++ b/softfloat/f32_to_i32_r_minMag.c @@ -0,0 +1,45 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + bool sign; + int_fast16_t shiftCount; + int_fast32_t absZ; + + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + if ( exp < 0x7F ) { + if ( exact && ( exp | sig ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + sign = signF32UI( uiA ); + shiftCount = 0x9E - exp; + if ( shiftCount <= 0 ) { + if ( uiA != packToF32UI( 1, 0x9E, 0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( ! sign || ( ( exp == 0xFF ) && sig ) ) return 0x7FFFFFFF; + } + return -0x7FFFFFFF - 1; + } + sig = ( sig | 0x00800000 )<<8; + absZ = sig>>shiftCount; + if ( exact && (uint32_t) ( sig<<( ( - shiftCount ) & 31 ) ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return sign ? - absZ : absZ; + +} + diff --git a/softfloat/f32_to_i32_r_minMag.cc b/softfloat/f32_to_i32_r_minMag.cc deleted file mode 100755 index 63ff1e2..0000000 --- a/softfloat/f32_to_i32_r_minMag.cc +++ /dev/null @@ -1,45 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - int_fast16_t exp; - uint_fast32_t sig; - bool sign; - int_fast16_t shiftCount; - int_fast32_t absZ; - - uA.f = a; - uiA = uA.ui; - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - if ( exp < 0x7F ) { - if ( exact && ( exp | sig ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return 0; - } - sign = signF32UI( uiA ); - shiftCount = 0x9E - exp; - if ( shiftCount <= 0 ) { - if ( uiA != packToF32UI( 1, 0x9E, 0 ) ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - if ( ! sign || ( ( exp == 0xFF ) && sig ) ) return 0x7FFFFFFF; - } - return -0x7FFFFFFF - 1; - } - sig = ( sig | 0x00800000 )<<8; - absZ = sig>>shiftCount; - if ( exact && (uint32_t) ( sig<<( ( - shiftCount ) & 31 ) ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return sign ? - absZ : absZ; - -} - diff --git a/softfloat/f32_to_i64.c b/softfloat/f32_to_i64.c new file mode 100755 index 0000000..c0b8981 --- /dev/null +++ b/softfloat/f32_to_i64.c @@ -0,0 +1,44 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +int_fast64_t f32_to_i64( float32_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftCount; + uint_fast64_t sig64, extra; + struct uint64_extra sig64Extra; + + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + shiftCount = 0xBE - exp; + if ( shiftCount < 0 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( ! sign || ( ( exp == 0xFF ) && sig ) ) { + return INT64_C( 0x7FFFFFFFFFFFFFFF ); + } + return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + if ( exp ) sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<40; + extra = 0; + if ( shiftCount ) { + sig64Extra = softfloat_shift64ExtraRightJam( sig64, 0, shiftCount ); + sig64 = sig64Extra.v; + extra = sig64Extra.extra; + } + return softfloat_roundPackToI64( sign, sig64, extra, roundingMode, exact ); + +} + diff --git a/softfloat/f32_to_i64.cc b/softfloat/f32_to_i64.cc deleted file mode 100755 index c0b8981..0000000 --- a/softfloat/f32_to_i64.cc +++ /dev/null @@ -1,44 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -int_fast64_t f32_to_i64( float32_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool sign; - int_fast16_t exp; - uint_fast32_t sig; - int_fast16_t shiftCount; - uint_fast64_t sig64, extra; - struct uint64_extra sig64Extra; - - uA.f = a; - uiA = uA.ui; - sign = signF32UI( uiA ); - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - shiftCount = 0xBE - exp; - if ( shiftCount < 0 ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - if ( ! sign || ( ( exp == 0xFF ) && sig ) ) { - return INT64_C( 0x7FFFFFFFFFFFFFFF ); - } - return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; - } - if ( exp ) sig |= 0x00800000; - sig64 = (uint_fast64_t) sig<<40; - extra = 0; - if ( shiftCount ) { - sig64Extra = softfloat_shift64ExtraRightJam( sig64, 0, shiftCount ); - sig64 = sig64Extra.v; - extra = sig64Extra.extra; - } - return softfloat_roundPackToI64( sign, sig64, extra, roundingMode, exact ); - -} - diff --git a/softfloat/f32_to_i64_r_minMag.c b/softfloat/f32_to_i64_r_minMag.c new file mode 100755 index 0000000..33bff93 --- /dev/null +++ b/softfloat/f32_to_i64_r_minMag.c @@ -0,0 +1,52 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + bool sign; + int_fast16_t shiftCount; + uint_fast64_t sig64; + int_fast64_t absZ; + + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + if ( exp < 0x7F ) { + if ( exact && ( exp | sig ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + sign = signF32UI( uiA ); + shiftCount = 0xBE - exp; + if ( shiftCount <= 0 ) { + if ( uiA != packToF32UI( 1, 0xBE, 0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( ! sign || ( ( exp == 0xFF ) && sig ) ) { + return INT64_C( 0x7FFFFFFFFFFFFFFF ); + } + } + return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<40; + absZ = sig64>>shiftCount; + shiftCount = 40 - shiftCount; + if ( + exact && ( shiftCount < 0 ) && (uint32_t) ( sig<<( shiftCount & 31 ) ) + ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return sign ? - absZ : absZ; + +} + diff --git a/softfloat/f32_to_i64_r_minMag.cc b/softfloat/f32_to_i64_r_minMag.cc deleted file mode 100755 index 33bff93..0000000 --- a/softfloat/f32_to_i64_r_minMag.cc +++ /dev/null @@ -1,52 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - int_fast16_t exp; - uint_fast32_t sig; - bool sign; - int_fast16_t shiftCount; - uint_fast64_t sig64; - int_fast64_t absZ; - - uA.f = a; - uiA = uA.ui; - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - if ( exp < 0x7F ) { - if ( exact && ( exp | sig ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return 0; - } - sign = signF32UI( uiA ); - shiftCount = 0xBE - exp; - if ( shiftCount <= 0 ) { - if ( uiA != packToF32UI( 1, 0xBE, 0 ) ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - if ( ! sign || ( ( exp == 0xFF ) && sig ) ) { - return INT64_C( 0x7FFFFFFFFFFFFFFF ); - } - } - return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; - } - sig |= 0x00800000; - sig64 = (uint_fast64_t) sig<<40; - absZ = sig64>>shiftCount; - shiftCount = 40 - shiftCount; - if ( - exact && ( shiftCount < 0 ) && (uint32_t) ( sig<<( shiftCount & 31 ) ) - ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return sign ? - absZ : absZ; - -} - diff --git a/softfloat/f32_to_ui32.c b/softfloat/f32_to_ui32.c new file mode 100755 index 0000000..3501db8 --- /dev/null +++ b/softfloat/f32_to_ui32.c @@ -0,0 +1,33 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast32_t f32_to_ui32( float32_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + uint_fast64_t sig64; + int_fast16_t shiftCount; + + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + if ( exp ) sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<32; + shiftCount = 0xAF - exp; + if ( 0 < shiftCount ) { + sig64 = softfloat_shift64RightJam( sig64, shiftCount ); + } + return softfloat_roundPackToUI32( sign, sig64, roundingMode, exact ); + +} + diff --git a/softfloat/f32_to_ui32.cc b/softfloat/f32_to_ui32.cc deleted file mode 100755 index 3501db8..0000000 --- a/softfloat/f32_to_ui32.cc +++ /dev/null @@ -1,33 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast32_t f32_to_ui32( float32_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool sign; - int_fast16_t exp; - uint_fast32_t sig; - uint_fast64_t sig64; - int_fast16_t shiftCount; - - uA.f = a; - uiA = uA.ui; - sign = signF32UI( uiA ); - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - if ( exp ) sig |= 0x00800000; - sig64 = (uint_fast64_t) sig<<32; - shiftCount = 0xAF - exp; - if ( 0 < shiftCount ) { - sig64 = softfloat_shift64RightJam( sig64, shiftCount ); - } - return softfloat_roundPackToUI32( sign, sig64, roundingMode, exact ); - -} - diff --git a/softfloat/f32_to_ui32_r_minMag.c b/softfloat/f32_to_ui32_r_minMag.c new file mode 100755 index 0000000..edd858d --- /dev/null +++ b/softfloat/f32_to_ui32_r_minMag.c @@ -0,0 +1,41 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftCount; + uint_fast32_t z; + + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + if ( exp < 0x7F ) { + if ( exact && ( exp | sig ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + if ( signF32UI( uiA ) ) goto invalid; + shiftCount = 0x9E - exp; + if ( shiftCount < 0 ) goto invalid; + sig = ( sig | 0x00800000 )<<8; + z = sig>>shiftCount; + if ( exact && ( sig & ( ( (uint_fast32_t) 1< -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - int_fast16_t exp; - uint_fast32_t sig; - int_fast16_t shiftCount; - uint_fast32_t z; - - uA.f = a; - uiA = uA.ui; - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - if ( exp < 0x7F ) { - if ( exact && ( exp | sig ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return 0; - } - if ( signF32UI( uiA ) ) goto invalid; - shiftCount = 0x9E - exp; - if ( shiftCount < 0 ) goto invalid; - sig = ( sig | 0x00800000 )<<8; - z = sig>>shiftCount; - if ( exact && ( sig & ( ( (uint_fast32_t) 1< +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast64_t f32_to_ui64( float32_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + bool sign; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftCount; + uint_fast64_t sig64, extra; + struct uint64_extra sig64Extra; + + uA.f = a; + uiA = uA.ui; + sign = signF32UI( uiA ); + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + shiftCount = 0xBE - exp; + if ( shiftCount < 0 ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return UINT64_C( 0xFFFFFFFFFFFFFFFF ); + } + if ( exp ) sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<40; + extra = 0; + if ( shiftCount ) { + sig64Extra = softfloat_shift64ExtraRightJam( sig64, 0, shiftCount ); + sig64 = sig64Extra.v; + extra = sig64Extra.extra; + } + return + softfloat_roundPackToUI64( sign, sig64, extra, roundingMode, exact ); + +} + diff --git a/softfloat/f32_to_ui64.cc b/softfloat/f32_to_ui64.cc deleted file mode 100755 index 6cdcf74..0000000 --- a/softfloat/f32_to_ui64.cc +++ /dev/null @@ -1,42 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast64_t f32_to_ui64( float32_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - bool sign; - int_fast16_t exp; - uint_fast32_t sig; - int_fast16_t shiftCount; - uint_fast64_t sig64, extra; - struct uint64_extra sig64Extra; - - uA.f = a; - uiA = uA.ui; - sign = signF32UI( uiA ); - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - shiftCount = 0xBE - exp; - if ( shiftCount < 0 ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return UINT64_C( 0xFFFFFFFFFFFFFFFF ); - } - if ( exp ) sig |= 0x00800000; - sig64 = (uint_fast64_t) sig<<40; - extra = 0; - if ( shiftCount ) { - sig64Extra = softfloat_shift64ExtraRightJam( sig64, 0, shiftCount ); - sig64 = sig64Extra.v; - extra = sig64Extra.extra; - } - return - softfloat_roundPackToUI64( sign, sig64, extra, roundingMode, exact ); - -} - diff --git a/softfloat/f32_to_ui64_r_minMag.c b/softfloat/f32_to_ui64_r_minMag.c new file mode 100755 index 0000000..738d6b1 --- /dev/null +++ b/softfloat/f32_to_ui64_r_minMag.c @@ -0,0 +1,45 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact ) +{ + union ui32_f32 uA; + uint_fast32_t uiA; + int_fast16_t exp; + uint_fast32_t sig; + int_fast16_t shiftCount; + uint_fast64_t sig64, z; + + uA.f = a; + uiA = uA.ui; + exp = expF32UI( uiA ); + sig = fracF32UI( uiA ); + if ( exp < 0x7F ) { + if ( exact && ( exp | sig ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + if ( signF32UI( uiA ) ) goto invalid; + shiftCount = 0xBE - exp; + if ( shiftCount < 0 ) goto invalid; + sig |= 0x00800000; + sig64 = (uint_fast64_t) sig<<40; + z = sig64>>shiftCount; + shiftCount = 40 - shiftCount; + if ( + exact && ( shiftCount < 0 ) && (uint32_t) ( sig<<( shiftCount & 31 ) ) + ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return UINT64_C( 0xFFFFFFFFFFFFFFFF ); + +} + diff --git a/softfloat/f32_to_ui64_r_minMag.cc b/softfloat/f32_to_ui64_r_minMag.cc deleted file mode 100755 index 738d6b1..0000000 --- a/softfloat/f32_to_ui64_r_minMag.cc +++ /dev/null @@ -1,45 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact ) -{ - union ui32_f32 uA; - uint_fast32_t uiA; - int_fast16_t exp; - uint_fast32_t sig; - int_fast16_t shiftCount; - uint_fast64_t sig64, z; - - uA.f = a; - uiA = uA.ui; - exp = expF32UI( uiA ); - sig = fracF32UI( uiA ); - if ( exp < 0x7F ) { - if ( exact && ( exp | sig ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return 0; - } - if ( signF32UI( uiA ) ) goto invalid; - shiftCount = 0xBE - exp; - if ( shiftCount < 0 ) goto invalid; - sig |= 0x00800000; - sig64 = (uint_fast64_t) sig<<40; - z = sig64>>shiftCount; - shiftCount = 40 - shiftCount; - if ( - exact && ( shiftCount < 0 ) && (uint32_t) ( sig<<( shiftCount & 31 ) ) - ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return z; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - return UINT64_C( 0xFFFFFFFFFFFFFFFF ); - -} - diff --git a/softfloat/f64_add.c b/softfloat/f64_add.c new file mode 100755 index 0000000..9ec4b5f --- /dev/null +++ b/softfloat/f64_add.c @@ -0,0 +1,29 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t f64_add( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; + float64_t ( *magsRoutine )( uint_fast64_t, uint_fast64_t, bool ); + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); + magsRoutine = + ( signA == signB ) ? softfloat_addMagsF64 : softfloat_subMagsF64; + return magsRoutine( uiA, uiB, signA ); + +} + diff --git a/softfloat/f64_add.cc b/softfloat/f64_add.cc deleted file mode 100755 index 9ec4b5f..0000000 --- a/softfloat/f64_add.cc +++ /dev/null @@ -1,29 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float64_t f64_add( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool signA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signB; - float64_t ( *magsRoutine )( uint_fast64_t, uint_fast64_t, bool ); - - uA.f = a; - uiA = uA.ui; - signA = signF64UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF64UI( uiB ); - magsRoutine = - ( signA == signB ) ? softfloat_addMagsF64 : softfloat_subMagsF64; - return magsRoutine( uiA, uiB, signA ); - -} - diff --git a/softfloat/f64_div.c b/softfloat/f64_div.c new file mode 100755 index 0000000..9bc72b3 --- /dev/null +++ b/softfloat/f64_div.c @@ -0,0 +1,104 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_div( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; + int_fast16_t expB; + uint_fast64_t sigB; + bool signZ; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; + uint_fast64_t sigZ; + struct uint128 term, rem; + uint_fast64_t uiZ; + union ui64_f64 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + signZ = signA ^ signB; + if ( expA == 0x7FF ) { + if ( sigA ) goto propagateNaN; + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + goto invalid; + } + goto infinity; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + goto zero; + } + if ( ! expB ) { + if ( ! sigB ) { + if ( ! ( expA | sigA ) ) goto invalid; + softfloat_raiseFlags( softfloat_flag_infinity ); + goto infinity; + } + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + expZ = expA - expB + 0x3FD; + sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10; + sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11; + if ( sigB <= ( sigA + sigA ) ) { + ++expZ; + sigA >>= 1; + } + sigZ = softfloat_estimateDiv128To64( sigA, 0, sigB ); + if ( ( sigZ & 0x1FF ) <= 2 ) { + term = softfloat_mul64To128( sigB, sigZ ); + rem = softfloat_sub128( sigA, 0, term.v64, term.v0 ); + while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) { + --sigZ; + rem = softfloat_add128( rem.v64, rem.v0, 0, sigB ); + } + sigZ |= ( rem.v0 != 0 ); + } + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto uiZ; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + goto uiZ; + infinity: + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + goto uiZ; + zero: + uiZ = packToF64UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f64_div.cc b/softfloat/f64_div.cc deleted file mode 100755 index 9bc72b3..0000000 --- a/softfloat/f64_div.cc +++ /dev/null @@ -1,104 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t f64_div( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool signA; - int_fast16_t expA; - uint_fast64_t sigA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signB; - int_fast16_t expB; - uint_fast64_t sigB; - bool signZ; - struct exp16_sig64 normExpSig; - int_fast16_t expZ; - uint_fast64_t sigZ; - struct uint128 term, rem; - uint_fast64_t uiZ; - union ui64_f64 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF64UI( uiA ); - expA = expF64UI( uiA ); - sigA = fracF64UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF64UI( uiB ); - expB = expF64UI( uiB ); - sigB = fracF64UI( uiB ); - signZ = signA ^ signB; - if ( expA == 0x7FF ) { - if ( sigA ) goto propagateNaN; - if ( expB == 0x7FF ) { - if ( sigB ) goto propagateNaN; - goto invalid; - } - goto infinity; - } - if ( expB == 0x7FF ) { - if ( sigB ) goto propagateNaN; - goto zero; - } - if ( ! expB ) { - if ( ! sigB ) { - if ( ! ( expA | sigA ) ) goto invalid; - softfloat_raiseFlags( softfloat_flag_infinity ); - goto infinity; - } - normExpSig = softfloat_normSubnormalF64Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - if ( ! expA ) { - if ( ! sigA ) goto zero; - normExpSig = softfloat_normSubnormalF64Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - expZ = expA - expB + 0x3FD; - sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10; - sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11; - if ( sigB <= ( sigA + sigA ) ) { - ++expZ; - sigA >>= 1; - } - sigZ = softfloat_estimateDiv128To64( sigA, 0, sigB ); - if ( ( sigZ & 0x1FF ) <= 2 ) { - term = softfloat_mul64To128( sigB, sigZ ); - rem = softfloat_sub128( sigA, 0, term.v64, term.v0 ); - while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) { - --sigZ; - rem = softfloat_add128( rem.v64, rem.v0, 0, sigB ); - } - sigZ |= ( rem.v0 != 0 ); - } - return softfloat_roundPackToF64( signZ, expZ, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); - goto uiZ; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF64UI; - goto uiZ; - infinity: - uiZ = packToF64UI( signZ, 0x7FF, 0 ); - goto uiZ; - zero: - uiZ = packToF64UI( signZ, 0, 0 ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f64_eq.c b/softfloat/f64_eq.c new file mode 100755 index 0000000..925aabc --- /dev/null +++ b/softfloat/f64_eq.c @@ -0,0 +1,35 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_eq( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) + || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) + ) { + if ( + softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + return + ( uiA == uiB ) || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ); + +} + diff --git a/softfloat/f64_eq.cc b/softfloat/f64_eq.cc deleted file mode 100755 index 925aabc..0000000 --- a/softfloat/f64_eq.cc +++ /dev/null @@ -1,35 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f64_eq( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - union ui64_f64 uB; - uint_fast64_t uiB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) - || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) - ) { - if ( - softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - return false; - } - return - ( uiA == uiB ) || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ); - -} - diff --git a/softfloat/f64_eq_signaling.c b/softfloat/f64_eq_signaling.c new file mode 100755 index 0000000..7a54dc1 --- /dev/null +++ b/softfloat/f64_eq_signaling.c @@ -0,0 +1,30 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f64_eq_signaling( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) + || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + return + ( uiA == uiB ) || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ); + +} + diff --git a/softfloat/f64_eq_signaling.cc b/softfloat/f64_eq_signaling.cc deleted file mode 100755 index 7a54dc1..0000000 --- a/softfloat/f64_eq_signaling.cc +++ /dev/null @@ -1,30 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -bool f64_eq_signaling( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - union ui64_f64 uB; - uint_fast64_t uiB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) - || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return false; - } - return - ( uiA == uiB ) || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ); - -} - diff --git a/softfloat/f64_isSignalingNaN.c b/softfloat/f64_isSignalingNaN.c new file mode 100755 index 0000000..d720ac1 --- /dev/null +++ b/softfloat/f64_isSignalingNaN.c @@ -0,0 +1,16 @@ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_isSignalingNaN( float64_t a ) +{ + union ui64_f64 uA; + + uA.f = a; + return softfloat_isSigNaNF64UI( uA.ui ); + +} + diff --git a/softfloat/f64_isSignalingNaN.cc b/softfloat/f64_isSignalingNaN.cc deleted file mode 100755 index d720ac1..0000000 --- a/softfloat/f64_isSignalingNaN.cc +++ /dev/null @@ -1,16 +0,0 @@ - -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f64_isSignalingNaN( float64_t a ) -{ - union ui64_f64 uA; - - uA.f = a; - return softfloat_isSigNaNF64UI( uA.ui ); - -} - diff --git a/softfloat/f64_le.c b/softfloat/f64_le.c new file mode 100755 index 0000000..e6c5caf --- /dev/null +++ b/softfloat/f64_le.c @@ -0,0 +1,35 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f64_le( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) + || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + ( signA != signB ) + ? signA || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) + : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f64_le.cc b/softfloat/f64_le.cc deleted file mode 100755 index e6c5caf..0000000 --- a/softfloat/f64_le.cc +++ /dev/null @@ -1,35 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -bool f64_le( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) - || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return false; - } - signA = signF64UI( uiA ); - signB = signF64UI( uiB ); - return - ( signA != signB ) - ? signA || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) - : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f64_le_quiet.c b/softfloat/f64_le_quiet.c new file mode 100755 index 0000000..e9b7ede --- /dev/null +++ b/softfloat/f64_le_quiet.c @@ -0,0 +1,40 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_le_quiet( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) + || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) + ) { + if ( + softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + ( signA != signB ) + ? signA || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) + : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f64_le_quiet.cc b/softfloat/f64_le_quiet.cc deleted file mode 100755 index e9b7ede..0000000 --- a/softfloat/f64_le_quiet.cc +++ /dev/null @@ -1,40 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f64_le_quiet( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) - || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) - ) { - if ( - softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - return false; - } - signA = signF64UI( uiA ); - signB = signF64UI( uiB ); - return - ( signA != signB ) - ? signA || ! ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) - : ( uiA == uiB ) || ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f64_lt.c b/softfloat/f64_lt.c new file mode 100755 index 0000000..1b2f696 --- /dev/null +++ b/softfloat/f64_lt.c @@ -0,0 +1,35 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +bool f64_lt( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) + || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + ( signA != signB ) + ? signA && ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) + : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f64_lt.cc b/softfloat/f64_lt.cc deleted file mode 100755 index 1b2f696..0000000 --- a/softfloat/f64_lt.cc +++ /dev/null @@ -1,35 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -bool f64_lt( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) - || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return false; - } - signA = signF64UI( uiA ); - signB = signF64UI( uiB ); - return - ( signA != signB ) - ? signA && ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) - : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f64_lt_quiet.c b/softfloat/f64_lt_quiet.c new file mode 100755 index 0000000..f27e6da --- /dev/null +++ b/softfloat/f64_lt_quiet.c @@ -0,0 +1,40 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +bool f64_lt_quiet( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signA, signB; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + if ( + ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) + || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) + ) { + if ( + softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) + ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + return false; + } + signA = signF64UI( uiA ); + signB = signF64UI( uiB ); + return + ( signA != signB ) + ? signA && ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) + : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); + +} + diff --git a/softfloat/f64_lt_quiet.cc b/softfloat/f64_lt_quiet.cc deleted file mode 100755 index f27e6da..0000000 --- a/softfloat/f64_lt_quiet.cc +++ /dev/null @@ -1,40 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -bool f64_lt_quiet( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signA, signB; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - if ( - ( ( expF64UI( uiA ) == 0x7FF ) && fracF64UI( uiA ) ) - || ( ( expF64UI( uiB ) == 0x7FF ) && fracF64UI( uiB ) ) - ) { - if ( - softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) - ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - return false; - } - signA = signF64UI( uiA ); - signB = signF64UI( uiB ); - return - ( signA != signB ) - ? signA && ( ( uiA | uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) - : ( uiA != uiB ) && ( signA ^ ( uiA < uiB ) ); - -} - diff --git a/softfloat/f64_mul.c b/softfloat/f64_mul.c new file mode 100755 index 0000000..4b5dc4e --- /dev/null +++ b/softfloat/f64_mul.c @@ -0,0 +1,91 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_mul( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; + int_fast16_t expB; + uint_fast64_t sigB; + bool signZ; + uint_fast64_t magBits; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; + struct uint128 sigZ128; + uint_fast64_t sigZ, uiZ; + union ui64_f64 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + signZ = signA ^ signB; + if ( expA == 0x7FF ) { + if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN; + magBits = expB | sigB; + goto infArg; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + magBits = expA | sigA; + goto infArg; + } + if ( ! expA ) { + if ( ! sigA ) goto zero; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zero; + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + expZ = expA + expB - 0x3FF; + sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10; + sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11; + sigZ128 = softfloat_mul64To128( sigA, sigB ); + sigZ = sigZ128.v64 | ( sigZ128.v0 != 0 ); + if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { + --expZ; + sigZ <<= 1; + } + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto uiZ; + infArg: + if ( ! magBits ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + } else { + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + } + goto uiZ; + zero: + uiZ = packToF64UI( signZ, 0, 0 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f64_mul.cc b/softfloat/f64_mul.cc deleted file mode 100755 index 4b5dc4e..0000000 --- a/softfloat/f64_mul.cc +++ /dev/null @@ -1,91 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t f64_mul( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool signA; - int_fast16_t expA; - uint_fast64_t sigA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signB; - int_fast16_t expB; - uint_fast64_t sigB; - bool signZ; - uint_fast64_t magBits; - struct exp16_sig64 normExpSig; - int_fast16_t expZ; - struct uint128 sigZ128; - uint_fast64_t sigZ, uiZ; - union ui64_f64 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF64UI( uiA ); - expA = expF64UI( uiA ); - sigA = fracF64UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF64UI( uiB ); - expB = expF64UI( uiB ); - sigB = fracF64UI( uiB ); - signZ = signA ^ signB; - if ( expA == 0x7FF ) { - if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN; - magBits = expB | sigB; - goto infArg; - } - if ( expB == 0x7FF ) { - if ( sigB ) goto propagateNaN; - magBits = expA | sigA; - goto infArg; - } - if ( ! expA ) { - if ( ! sigA ) goto zero; - normExpSig = softfloat_normSubnormalF64Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - if ( ! expB ) { - if ( ! sigB ) goto zero; - normExpSig = softfloat_normSubnormalF64Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - expZ = expA + expB - 0x3FF; - sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10; - sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11; - sigZ128 = softfloat_mul64To128( sigA, sigB ); - sigZ = sigZ128.v64 | ( sigZ128.v0 != 0 ); - if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { - --expZ; - sigZ <<= 1; - } - return softfloat_roundPackToF64( signZ, expZ, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); - goto uiZ; - infArg: - if ( ! magBits ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF64UI; - } else { - uiZ = packToF64UI( signZ, 0x7FF, 0 ); - } - goto uiZ; - zero: - uiZ = packToF64UI( signZ, 0, 0 ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f64_mulAdd.c b/softfloat/f64_mulAdd.c new file mode 100755 index 0000000..fa1669a --- /dev/null +++ b/softfloat/f64_mulAdd.c @@ -0,0 +1,25 @@ + +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + union ui64_f64 uB; + uint_fast64_t uiB; + union ui64_f64 uC; + uint_fast64_t uiC; + + uA.f = a; + uiA = uA.ui; + uB.f = b; + uiB = uB.ui; + uC.f = c; + uiC = uC.ui; + return softfloat_mulAddF64( 0, uiA, uiB, uiC ); + +} + diff --git a/softfloat/f64_mulAdd.cc b/softfloat/f64_mulAdd.cc deleted file mode 100755 index fa1669a..0000000 --- a/softfloat/f64_mulAdd.cc +++ /dev/null @@ -1,25 +0,0 @@ - -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - union ui64_f64 uB; - uint_fast64_t uiB; - union ui64_f64 uC; - uint_fast64_t uiC; - - uA.f = a; - uiA = uA.ui; - uB.f = b; - uiB = uB.ui; - uC.f = c; - uiC = uC.ui; - return softfloat_mulAddF64( 0, uiA, uiB, uiC ); - -} - diff --git a/softfloat/f64_rem.c b/softfloat/f64_rem.c new file mode 100755 index 0000000..08fcd78 --- /dev/null +++ b/softfloat/f64_rem.c @@ -0,0 +1,113 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_rem( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; + int_fast16_t expB; + uint_fast64_t sigB; + struct exp16_sig64 normExpSig; + int_fast16_t expDiff; + uint_fast64_t q, alternateSigA; + uint64_t sigMean; + bool signZ; + uint_fast64_t uiZ; + union ui64_f64 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + if ( expA == 0x7FF ) { + if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN; + goto invalid; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + return a; + } + if ( ! expB ) { + if ( ! sigB ) goto invalid; + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + expDiff = expA - expB; + sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<11; + sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11; + if ( expDiff < 0 ) { + if ( expDiff < -1 ) return a; + sigA >>= 1; + } + q = ( sigB <= sigA ); + if ( q ) sigA -= sigB; + expDiff -= 64; + while ( 0 < expDiff ) { + q = softfloat_estimateDiv128To64( sigA, 0, sigB ); + q = ( 2 < q ) ? q - 2 : 0; + sigA = - ( ( sigB>>2 ) * q ); + expDiff -= 62; + } + expDiff += 64; + if ( 0 < expDiff ) { + q = softfloat_estimateDiv128To64( sigA, 0, sigB ); + q = ( 2 < q ) ? q - 2 : 0; + q >>= 64 - expDiff; + sigB >>= 2; + sigA = ( ( sigA>>1 )<<( expDiff - 1 ) ) - sigB * q; + } else { + sigA >>= 2; + sigB >>= 2; + } + do { + alternateSigA = sigA; + ++q; + sigA -= sigB; + } while ( sigA < UINT64_C( 0x8000000000000000 ) ); + sigMean = sigA + alternateSigA; + if ( + ( UINT64_C( 0x8000000000000000 ) <= sigMean ) + || ( ! sigMean && ( q & 1 ) ) + ) { + sigA = alternateSigA; + } + signZ = ( UINT64_C( 0x8000000000000000 ) <= sigA ); + if ( signZ ) sigA = - sigA; + return softfloat_normRoundPackToF64( signA ^ signZ, expB, sigA ); + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto uiZ; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f64_rem.cc b/softfloat/f64_rem.cc deleted file mode 100755 index 08fcd78..0000000 --- a/softfloat/f64_rem.cc +++ /dev/null @@ -1,113 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t f64_rem( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool signA; - int_fast16_t expA; - uint_fast64_t sigA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signB; - int_fast16_t expB; - uint_fast64_t sigB; - struct exp16_sig64 normExpSig; - int_fast16_t expDiff; - uint_fast64_t q, alternateSigA; - uint64_t sigMean; - bool signZ; - uint_fast64_t uiZ; - union ui64_f64 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF64UI( uiA ); - expA = expF64UI( uiA ); - sigA = fracF64UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF64UI( uiB ); - expB = expF64UI( uiB ); - sigB = fracF64UI( uiB ); - if ( expA == 0x7FF ) { - if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN; - goto invalid; - } - if ( expB == 0x7FF ) { - if ( sigB ) goto propagateNaN; - return a; - } - if ( ! expB ) { - if ( ! sigB ) goto invalid; - normExpSig = softfloat_normSubnormalF64Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - if ( ! expA ) { - if ( ! sigA ) return a; - normExpSig = softfloat_normSubnormalF64Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - expDiff = expA - expB; - sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<11; - sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11; - if ( expDiff < 0 ) { - if ( expDiff < -1 ) return a; - sigA >>= 1; - } - q = ( sigB <= sigA ); - if ( q ) sigA -= sigB; - expDiff -= 64; - while ( 0 < expDiff ) { - q = softfloat_estimateDiv128To64( sigA, 0, sigB ); - q = ( 2 < q ) ? q - 2 : 0; - sigA = - ( ( sigB>>2 ) * q ); - expDiff -= 62; - } - expDiff += 64; - if ( 0 < expDiff ) { - q = softfloat_estimateDiv128To64( sigA, 0, sigB ); - q = ( 2 < q ) ? q - 2 : 0; - q >>= 64 - expDiff; - sigB >>= 2; - sigA = ( ( sigA>>1 )<<( expDiff - 1 ) ) - sigB * q; - } else { - sigA >>= 2; - sigB >>= 2; - } - do { - alternateSigA = sigA; - ++q; - sigA -= sigB; - } while ( sigA < UINT64_C( 0x8000000000000000 ) ); - sigMean = sigA + alternateSigA; - if ( - ( UINT64_C( 0x8000000000000000 ) <= sigMean ) - || ( ! sigMean && ( q & 1 ) ) - ) { - sigA = alternateSigA; - } - signZ = ( UINT64_C( 0x8000000000000000 ) <= sigA ); - if ( signZ ) sigA = - sigA; - return softfloat_normRoundPackToF64( signA ^ signZ, expB, sigA ); - propagateNaN: - uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); - goto uiZ; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF64UI; - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f64_roundToInt.c b/softfloat/f64_roundToInt.c new file mode 100755 index 0000000..ef16dfa --- /dev/null +++ b/softfloat/f64_roundToInt.c @@ -0,0 +1,80 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_roundToInt( float64_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t expA; + uint_fast64_t uiZ; + bool signA; + uint_fast64_t lastBitMask, roundBitsMask; + union ui64_f64 uZ; + + uA.f = a; + uiA = uA.ui; + expA = expF64UI( uiA ); + if ( 0x433 <= expA ) { + if ( ( expA == 0x7FF ) && fracF64UI( uiA ) ) { + uiZ = softfloat_propagateNaNF64UI( uiA, 0 ); + goto uiZ; + } + return a; + } + if ( expA <= 0x3FE ) { + if ( ! ( uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) ) return a; + if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; + signA = signF64UI( uiA ); + switch ( roundingMode ) { + case softfloat_round_nearest_even: + if ( ( expA == 0x3FE ) && fracF64UI( uiA ) ) { + uiZ = packToF64UI( signA, 0x3FF, 0 ); + goto uiZ; + } + break; + case softfloat_round_min: + uiZ = signA ? UINT64_C( 0xBFF0000000000000 ) : 0; + goto uiZ; + case softfloat_round_max: + uiZ = + signA ? UINT64_C( 0x8000000000000000 ) + : UINT64_C( 0x3FF0000000000000 ); + goto uiZ; + case softfloat_round_nearest_maxMag: + if ( expA == 0x3FE ) { + uiZ = packToF64UI( signA, 0x3FF, 0 ); + goto uiZ; + } + break; + } + uiZ = packToF64UI( signA, 0, 0 ); + goto uiZ; + } + lastBitMask = (uint_fast64_t) 1<<( 0x433 - expA ); + roundBitsMask = lastBitMask - 1; + uiZ = uiA; + if ( roundingMode == softfloat_round_nearest_maxMag ) { + uiZ += lastBitMask>>1; + } else if ( roundingMode == softfloat_round_nearest_even ) { + uiZ += lastBitMask>>1; + if ( ! ( uiZ & roundBitsMask ) ) uiZ &= ~ lastBitMask; + } else if ( roundingMode != softfloat_round_minMag ) { + if ( signF64UI( uiZ ) ^ ( roundingMode == softfloat_round_max ) ) { + uiZ += roundBitsMask; + } + } + uiZ &= ~ roundBitsMask; + if ( exact && ( uiZ != uiA ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f64_roundToInt.cc b/softfloat/f64_roundToInt.cc deleted file mode 100755 index ef16dfa..0000000 --- a/softfloat/f64_roundToInt.cc +++ /dev/null @@ -1,80 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t f64_roundToInt( float64_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - int_fast16_t expA; - uint_fast64_t uiZ; - bool signA; - uint_fast64_t lastBitMask, roundBitsMask; - union ui64_f64 uZ; - - uA.f = a; - uiA = uA.ui; - expA = expF64UI( uiA ); - if ( 0x433 <= expA ) { - if ( ( expA == 0x7FF ) && fracF64UI( uiA ) ) { - uiZ = softfloat_propagateNaNF64UI( uiA, 0 ); - goto uiZ; - } - return a; - } - if ( expA <= 0x3FE ) { - if ( ! ( uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) ) return a; - if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact; - signA = signF64UI( uiA ); - switch ( roundingMode ) { - case softfloat_round_nearest_even: - if ( ( expA == 0x3FE ) && fracF64UI( uiA ) ) { - uiZ = packToF64UI( signA, 0x3FF, 0 ); - goto uiZ; - } - break; - case softfloat_round_min: - uiZ = signA ? UINT64_C( 0xBFF0000000000000 ) : 0; - goto uiZ; - case softfloat_round_max: - uiZ = - signA ? UINT64_C( 0x8000000000000000 ) - : UINT64_C( 0x3FF0000000000000 ); - goto uiZ; - case softfloat_round_nearest_maxMag: - if ( expA == 0x3FE ) { - uiZ = packToF64UI( signA, 0x3FF, 0 ); - goto uiZ; - } - break; - } - uiZ = packToF64UI( signA, 0, 0 ); - goto uiZ; - } - lastBitMask = (uint_fast64_t) 1<<( 0x433 - expA ); - roundBitsMask = lastBitMask - 1; - uiZ = uiA; - if ( roundingMode == softfloat_round_nearest_maxMag ) { - uiZ += lastBitMask>>1; - } else if ( roundingMode == softfloat_round_nearest_even ) { - uiZ += lastBitMask>>1; - if ( ! ( uiZ & roundBitsMask ) ) uiZ &= ~ lastBitMask; - } else if ( roundingMode != softfloat_round_minMag ) { - if ( signF64UI( uiZ ) ^ ( roundingMode == softfloat_round_max ) ) { - uiZ += roundBitsMask; - } - } - uiZ &= ~ roundBitsMask; - if ( exact && ( uiZ != uiA ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f64_sqrt.c b/softfloat/f64_sqrt.c new file mode 100755 index 0000000..cd91010 --- /dev/null +++ b/softfloat/f64_sqrt.c @@ -0,0 +1,74 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t f64_sqrt( float64_t a ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + int_fast16_t expA; + uint_fast64_t sigA, uiZ; + struct exp16_sig64 normExpSig; + int_fast16_t expZ; + uint_fast32_t sigZ32; + uint_fast64_t sigZ; + struct uint128 term, rem; + union ui64_f64 uZ; + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + if ( expA == 0x7FF ) { + if ( sigA ) { + uiZ = softfloat_propagateNaNF64UI( uiA, 0 ); + goto uiZ; + } + if ( ! signA ) return a; + goto invalid; + } + if ( signA ) { + if ( ! ( expA | sigA ) ) return a; + goto invalid; + } + if ( ! expA ) { + if ( ! sigA ) return a; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + expZ = ( ( expA - 0x3FF )>>1 ) + 0x3FE; + sigA |= UINT64_C( 0x0010000000000000 ); + sigZ32 = softfloat_estimateSqrt32( expA, sigA>>21 ); + sigA <<= 9 - ( expA & 1 ); + sigZ = + softfloat_estimateDiv128To64( sigA, 0, (uint_fast64_t) sigZ32<<32 ) + + ( (uint_fast64_t) sigZ32<<30 ); + if ( ( sigZ & 0x1FF ) <= 5 ) { + term = softfloat_mul64To128( sigZ, sigZ ); + rem = softfloat_sub128( sigA, 0, term.v64, term.v0 ); + while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) { + --sigZ; + rem = + softfloat_add128( + rem.v64, rem.v0, sigZ>>63, (uint64_t) ( sigZ<<1 ) ); + } + sigZ |= ( ( rem.v64 | rem.v0 ) != 0 ); + } + return softfloat_roundPackToF64( 0, expZ, sigZ ); + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f64_sqrt.cc b/softfloat/f64_sqrt.cc deleted file mode 100755 index cd91010..0000000 --- a/softfloat/f64_sqrt.cc +++ /dev/null @@ -1,74 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t f64_sqrt( float64_t a ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool signA; - int_fast16_t expA; - uint_fast64_t sigA, uiZ; - struct exp16_sig64 normExpSig; - int_fast16_t expZ; - uint_fast32_t sigZ32; - uint_fast64_t sigZ; - struct uint128 term, rem; - union ui64_f64 uZ; - - uA.f = a; - uiA = uA.ui; - signA = signF64UI( uiA ); - expA = expF64UI( uiA ); - sigA = fracF64UI( uiA ); - if ( expA == 0x7FF ) { - if ( sigA ) { - uiZ = softfloat_propagateNaNF64UI( uiA, 0 ); - goto uiZ; - } - if ( ! signA ) return a; - goto invalid; - } - if ( signA ) { - if ( ! ( expA | sigA ) ) return a; - goto invalid; - } - if ( ! expA ) { - if ( ! sigA ) return a; - normExpSig = softfloat_normSubnormalF64Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - expZ = ( ( expA - 0x3FF )>>1 ) + 0x3FE; - sigA |= UINT64_C( 0x0010000000000000 ); - sigZ32 = softfloat_estimateSqrt32( expA, sigA>>21 ); - sigA <<= 9 - ( expA & 1 ); - sigZ = - softfloat_estimateDiv128To64( sigA, 0, (uint_fast64_t) sigZ32<<32 ) - + ( (uint_fast64_t) sigZ32<<30 ); - if ( ( sigZ & 0x1FF ) <= 5 ) { - term = softfloat_mul64To128( sigZ, sigZ ); - rem = softfloat_sub128( sigA, 0, term.v64, term.v0 ); - while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) { - --sigZ; - rem = - softfloat_add128( - rem.v64, rem.v0, sigZ>>63, (uint64_t) ( sigZ<<1 ) ); - } - sigZ |= ( ( rem.v64 | rem.v0 ) != 0 ); - } - return softfloat_roundPackToF64( 0, expZ, sigZ ); - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF64UI; - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f64_sub.c b/softfloat/f64_sub.c new file mode 100755 index 0000000..38bd574 --- /dev/null +++ b/softfloat/f64_sub.c @@ -0,0 +1,29 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t f64_sub( float64_t a, float64_t b ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool signA; + union ui64_f64 uB; + uint_fast64_t uiB; + bool signB; + float64_t ( *magsRoutine )( uint_fast64_t, uint_fast64_t, bool ); + + uA.f = a; + uiA = uA.ui; + signA = signF64UI( uiA ); + uB.f = b; + uiB = uB.ui; + signB = signF64UI( uiB ); + magsRoutine = + ( signA == signB ) ? softfloat_subMagsF64 : softfloat_addMagsF64; + return magsRoutine( uiA, uiB, signA ); + +} + diff --git a/softfloat/f64_sub.cc b/softfloat/f64_sub.cc deleted file mode 100755 index 38bd574..0000000 --- a/softfloat/f64_sub.cc +++ /dev/null @@ -1,29 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float64_t f64_sub( float64_t a, float64_t b ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool signA; - union ui64_f64 uB; - uint_fast64_t uiB; - bool signB; - float64_t ( *magsRoutine )( uint_fast64_t, uint_fast64_t, bool ); - - uA.f = a; - uiA = uA.ui; - signA = signF64UI( uiA ); - uB.f = b; - uiB = uB.ui; - signB = signF64UI( uiB ); - magsRoutine = - ( signA == signB ) ? softfloat_subMagsF64 : softfloat_addMagsF64; - return magsRoutine( uiA, uiB, signA ); - -} - diff --git a/softfloat/f64_to_f32.c b/softfloat/f64_to_f32.c new file mode 100755 index 0000000..395d6c6 --- /dev/null +++ b/softfloat/f64_to_f32.c @@ -0,0 +1,43 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t f64_to_f32( float64_t a ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + uint_fast32_t uiZ, sig32; + union ui32_f32 uZ; + + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( exp == 0x7FF ) { + uiZ = + sig ? softfloat_commonNaNToF32UI( + softfloat_f64UIToCommonNaN( uiA ) ) + : packToF32UI( sign, 0xFF, 0 ); + goto uiZ; + } + sig32 = softfloat_shortShift64RightJam( sig, 22 ); + if ( ! ( exp | sig32 ) ) { + uiZ = packToF32UI( sign, 0, 0 ); + goto uiZ; + } + return softfloat_roundPackToF32( sign, exp - 0x381, sig32 | 0x40000000 ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/f64_to_f32.cc b/softfloat/f64_to_f32.cc deleted file mode 100755 index 395d6c6..0000000 --- a/softfloat/f64_to_f32.cc +++ /dev/null @@ -1,43 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t f64_to_f32( float64_t a ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool sign; - int_fast16_t exp; - uint_fast64_t sig; - uint_fast32_t uiZ, sig32; - union ui32_f32 uZ; - - uA.f = a; - uiA = uA.ui; - sign = signF64UI( uiA ); - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( exp == 0x7FF ) { - uiZ = - sig ? softfloat_commonNaNToF32UI( - softfloat_f64UIToCommonNaN( uiA ) ) - : packToF32UI( sign, 0xFF, 0 ); - goto uiZ; - } - sig32 = softfloat_shortShift64RightJam( sig, 22 ); - if ( ! ( exp | sig32 ) ) { - uiZ = packToF32UI( sign, 0, 0 ); - goto uiZ; - } - return softfloat_roundPackToF32( sign, exp - 0x381, sig32 | 0x40000000 ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/f64_to_i32.c b/softfloat/f64_to_i32.c new file mode 100755 index 0000000..0778a86 --- /dev/null +++ b/softfloat/f64_to_i32.c @@ -0,0 +1,30 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +int_fast32_t f64_to_i32( float64_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftCount; + + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( ( exp == 0x7FF ) && sig ) sign = 0; + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftCount = 0x42C - exp; + if ( 0 < shiftCount ) sig = softfloat_shift64RightJam( sig, shiftCount ); + return softfloat_roundPackToI32( sign, sig, roundingMode, exact ); + +} + diff --git a/softfloat/f64_to_i32.cc b/softfloat/f64_to_i32.cc deleted file mode 100755 index 0778a86..0000000 --- a/softfloat/f64_to_i32.cc +++ /dev/null @@ -1,30 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -int_fast32_t f64_to_i32( float64_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool sign; - int_fast16_t exp; - uint_fast64_t sig; - int_fast16_t shiftCount; - - uA.f = a; - uiA = uA.ui; - sign = signF64UI( uiA ); - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( ( exp == 0x7FF ) && sig ) sign = 0; - if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); - shiftCount = 0x42C - exp; - if ( 0 < shiftCount ) sig = softfloat_shift64RightJam( sig, shiftCount ); - return softfloat_roundPackToI32( sign, sig, roundingMode, exact ); - -} - diff --git a/softfloat/f64_to_i32_r_minMag.c b/softfloat/f64_to_i32_r_minMag.c new file mode 100755 index 0000000..39246c2 --- /dev/null +++ b/softfloat/f64_to_i32_r_minMag.c @@ -0,0 +1,50 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t sig; + bool sign; + int_fast16_t shiftCount; + uint_fast32_t absZ; + union { uint32_t ui; int32_t i; } uZ; + int_fast32_t z; + + uA.f = a; + uiA = uA.ui; + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( exp < 0x3FF ) { + if ( exact && ( exp | sig ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + sign = signF64UI( uiA ); + if ( 0x41E < exp ) { + if ( ( exp == 0x7FF ) && sig ) sign = 0; + goto invalid; + } + sig |= UINT64_C( 0x0010000000000000 ); + shiftCount = 0x433 - exp; + absZ = sig>>shiftCount; + uZ.ui = sign ? - absZ : absZ; + z = uZ.i; + if ( ( z < 0 ) != sign ) goto invalid; + if ( exact && ( (uint_fast64_t) absZ< -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - int_fast16_t exp; - uint_fast64_t sig; - bool sign; - int_fast16_t shiftCount; - uint_fast32_t absZ; - union { uint32_t ui; int32_t i; } uZ; - int_fast32_t z; - - uA.f = a; - uiA = uA.ui; - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( exp < 0x3FF ) { - if ( exact && ( exp | sig ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return 0; - } - sign = signF64UI( uiA ); - if ( 0x41E < exp ) { - if ( ( exp == 0x7FF ) && sig ) sign = 0; - goto invalid; - } - sig |= UINT64_C( 0x0010000000000000 ); - shiftCount = 0x433 - exp; - absZ = sig>>shiftCount; - uZ.ui = sign ? - absZ : absZ; - z = uZ.i; - if ( ( z < 0 ) != sign ) goto invalid; - if ( exact && ( (uint_fast64_t) absZ< +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +int_fast64_t f64_to_i64( float64_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftCount; + struct uint64_extra sigExtra; + + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftCount = 0x433 - exp; + if ( shiftCount <= 0 ) { + if ( 0x43E < exp ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return + ! sign + || ( ( exp == 0x7FF ) + && ( sig != UINT64_C( 0x0010000000000000 ) ) ) + ? INT64_C( 0x7FFFFFFFFFFFFFFF ) + : - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + sigExtra.v = sig<<( - shiftCount ); + sigExtra.extra = 0; + } else { + sigExtra = softfloat_shift64ExtraRightJam( sig, 0, shiftCount ); + } + return + softfloat_roundPackToI64( + sign, sigExtra.v, sigExtra.extra, roundingMode, exact ); + +} + diff --git a/softfloat/f64_to_i64.cc b/softfloat/f64_to_i64.cc deleted file mode 100755 index 89663ee..0000000 --- a/softfloat/f64_to_i64.cc +++ /dev/null @@ -1,46 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -int_fast64_t f64_to_i64( float64_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool sign; - int_fast16_t exp; - uint_fast64_t sig; - int_fast16_t shiftCount; - struct uint64_extra sigExtra; - - uA.f = a; - uiA = uA.ui; - sign = signF64UI( uiA ); - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); - shiftCount = 0x433 - exp; - if ( shiftCount <= 0 ) { - if ( 0x43E < exp ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return - ! sign - || ( ( exp == 0x7FF ) - && ( sig != UINT64_C( 0x0010000000000000 ) ) ) - ? INT64_C( 0x7FFFFFFFFFFFFFFF ) - : - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; - } - sigExtra.v = sig<<( - shiftCount ); - sigExtra.extra = 0; - } else { - sigExtra = softfloat_shift64ExtraRightJam( sig, 0, shiftCount ); - } - return - softfloat_roundPackToI64( - sign, sigExtra.v, sigExtra.extra, roundingMode, exact ); - -} - diff --git a/softfloat/f64_to_i64_r_minMag.c b/softfloat/f64_to_i64_r_minMag.c new file mode 100755 index 0000000..525705b --- /dev/null +++ b/softfloat/f64_to_i64_r_minMag.c @@ -0,0 +1,52 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftCount; + int_fast64_t absZ; + + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + shiftCount = exp - 0x433; + if ( 0 <= shiftCount ) { + if ( 0x43E <= exp ) { + if ( uiA != packToF64UI( 1, 0x43E, 0 ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + if ( ! sign || ( ( exp == 0x7FF ) && sig ) ) { + return INT64_C( 0x7FFFFFFFFFFFFFFF ); + } + } + return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; + } + sig |= UINT64_C( 0x0010000000000000 ); + absZ = sig<>( - shiftCount ); + if ( exact && (uint64_t) ( sig<<( shiftCount & 63 ) ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + } + return sign ? - absZ : absZ; + +} + diff --git a/softfloat/f64_to_i64_r_minMag.cc b/softfloat/f64_to_i64_r_minMag.cc deleted file mode 100755 index 525705b..0000000 --- a/softfloat/f64_to_i64_r_minMag.cc +++ /dev/null @@ -1,52 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool sign; - int_fast16_t exp; - uint_fast64_t sig; - int_fast16_t shiftCount; - int_fast64_t absZ; - - uA.f = a; - uiA = uA.ui; - sign = signF64UI( uiA ); - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - shiftCount = exp - 0x433; - if ( 0 <= shiftCount ) { - if ( 0x43E <= exp ) { - if ( uiA != packToF64UI( 1, 0x43E, 0 ) ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - if ( ! sign || ( ( exp == 0x7FF ) && sig ) ) { - return INT64_C( 0x7FFFFFFFFFFFFFFF ); - } - } - return - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1; - } - sig |= UINT64_C( 0x0010000000000000 ); - absZ = sig<>( - shiftCount ); - if ( exact && (uint64_t) ( sig<<( shiftCount & 63 ) ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - } - return sign ? - absZ : absZ; - -} - diff --git a/softfloat/f64_to_ui32.c b/softfloat/f64_to_ui32.c new file mode 100755 index 0000000..b186605 --- /dev/null +++ b/softfloat/f64_to_ui32.c @@ -0,0 +1,29 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast32_t f64_to_ui32( float64_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftCount; + + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftCount = 0x42C - exp; + if ( 0 < shiftCount ) sig = softfloat_shift64RightJam( sig, shiftCount ); + return softfloat_roundPackToUI32( sign, sig, roundingMode, exact ); + +} + diff --git a/softfloat/f64_to_ui32.cc b/softfloat/f64_to_ui32.cc deleted file mode 100755 index b186605..0000000 --- a/softfloat/f64_to_ui32.cc +++ /dev/null @@ -1,29 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast32_t f64_to_ui32( float64_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool sign; - int_fast16_t exp; - uint_fast64_t sig; - int_fast16_t shiftCount; - - uA.f = a; - uiA = uA.ui; - sign = signF64UI( uiA ); - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); - shiftCount = 0x42C - exp; - if ( 0 < shiftCount ) sig = softfloat_shift64RightJam( sig, shiftCount ); - return softfloat_roundPackToUI32( sign, sig, roundingMode, exact ); - -} - diff --git a/softfloat/f64_to_ui32_r_minMag.c b/softfloat/f64_to_ui32_r_minMag.c new file mode 100755 index 0000000..9f1dd4d --- /dev/null +++ b/softfloat/f64_to_ui32_r_minMag.c @@ -0,0 +1,40 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftCount; + uint_fast32_t z; + + uA.f = a; + uiA = uA.ui; + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( exp < 0x3FF ) { + if ( exact && ( exp | sig ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + if ( signF64UI( uiA ) || ( 0x41E < exp ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return 0xFFFFFFFF; + } + sig |= UINT64_C( 0x0010000000000000 ); + shiftCount = 0x433 - exp; + z = sig>>shiftCount; + if ( exact && ( (uint_fast64_t) z< -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - int_fast16_t exp; - uint_fast64_t sig; - int_fast16_t shiftCount; - uint_fast32_t z; - - uA.f = a; - uiA = uA.ui; - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( exp < 0x3FF ) { - if ( exact && ( exp | sig ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return 0; - } - if ( signF64UI( uiA ) || ( 0x41E < exp ) ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return 0xFFFFFFFF; - } - sig |= UINT64_C( 0x0010000000000000 ); - shiftCount = 0x433 - exp; - z = sig>>shiftCount; - if ( exact && ( (uint_fast64_t) z< +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast64_t f64_to_ui64( float64_t a, int_fast8_t roundingMode, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + bool sign; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftCount; + struct uint64_extra sigExtra; + + uA.f = a; + uiA = uA.ui; + sign = signF64UI( uiA ); + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); + shiftCount = 0x433 - exp; + if ( shiftCount <= 0 ) { + if ( 0x43E < exp ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + return UINT64_C( 0xFFFFFFFFFFFFFFFF ); + } + sigExtra.v = sig<<( - shiftCount ); + sigExtra.extra = 0; + } else { + sigExtra = softfloat_shift64ExtraRightJam( sig, 0, shiftCount ); + } + return + softfloat_roundPackToUI64( + sign, sigExtra.v, sigExtra.extra, roundingMode, exact ); + +} + diff --git a/softfloat/f64_to_ui64.cc b/softfloat/f64_to_ui64.cc deleted file mode 100755 index 9afebd7..0000000 --- a/softfloat/f64_to_ui64.cc +++ /dev/null @@ -1,41 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast64_t f64_to_ui64( float64_t a, int_fast8_t roundingMode, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - bool sign; - int_fast16_t exp; - uint_fast64_t sig; - int_fast16_t shiftCount; - struct uint64_extra sigExtra; - - uA.f = a; - uiA = uA.ui; - sign = signF64UI( uiA ); - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( exp ) sig |= UINT64_C( 0x0010000000000000 ); - shiftCount = 0x433 - exp; - if ( shiftCount <= 0 ) { - if ( 0x43E < exp ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - return UINT64_C( 0xFFFFFFFFFFFFFFFF ); - } - sigExtra.v = sig<<( - shiftCount ); - sigExtra.extra = 0; - } else { - sigExtra = softfloat_shift64ExtraRightJam( sig, 0, shiftCount ); - } - return - softfloat_roundPackToUI64( - sign, sigExtra.v, sigExtra.extra, roundingMode, exact ); - -} - diff --git a/softfloat/f64_to_ui64_r_minMag.c b/softfloat/f64_to_ui64_r_minMag.c new file mode 100755 index 0000000..a66d3ff --- /dev/null +++ b/softfloat/f64_to_ui64_r_minMag.c @@ -0,0 +1,45 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact ) +{ + union ui64_f64 uA; + uint_fast64_t uiA; + int_fast16_t exp; + uint_fast64_t sig; + int_fast16_t shiftCount; + uint_fast64_t z; + + uA.f = a; + uiA = uA.ui; + exp = expF64UI( uiA ); + sig = fracF64UI( uiA ); + if ( exp < 0x3FF ) { + if ( exact && ( exp | sig ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return 0; + } + if ( signF64UI( uiA ) ) goto invalid; + shiftCount = exp - 0x433; + if ( 0 <= shiftCount ) { + if ( 0x43E < exp ) goto invalid; + z = ( sig | UINT64_C( 0x0010000000000000 ) )<>( - shiftCount ); + if ( exact && (uint64_t) ( sig<<( shiftCount & 63 ) ) ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + } + return z; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return UINT64_C( 0xFFFFFFFFFFFFFFFF ); + +} + diff --git a/softfloat/f64_to_ui64_r_minMag.cc b/softfloat/f64_to_ui64_r_minMag.cc deleted file mode 100755 index a66d3ff..0000000 --- a/softfloat/f64_to_ui64_r_minMag.cc +++ /dev/null @@ -1,45 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact ) -{ - union ui64_f64 uA; - uint_fast64_t uiA; - int_fast16_t exp; - uint_fast64_t sig; - int_fast16_t shiftCount; - uint_fast64_t z; - - uA.f = a; - uiA = uA.ui; - exp = expF64UI( uiA ); - sig = fracF64UI( uiA ); - if ( exp < 0x3FF ) { - if ( exact && ( exp | sig ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return 0; - } - if ( signF64UI( uiA ) ) goto invalid; - shiftCount = exp - 0x433; - if ( 0 <= shiftCount ) { - if ( 0x43E < exp ) goto invalid; - z = ( sig | UINT64_C( 0x0010000000000000 ) )<>( - shiftCount ); - if ( exact && (uint64_t) ( sig<<( shiftCount & 63 ) ) ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - } - return z; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - return UINT64_C( 0xFFFFFFFFFFFFFFFF ); - -} - diff --git a/softfloat/i32_to_f32.c b/softfloat/i32_to_f32.c new file mode 100755 index 0000000..f51facd --- /dev/null +++ b/softfloat/i32_to_f32.c @@ -0,0 +1,21 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float32_t i32_to_f32( int_fast32_t a ) +{ + bool sign; + union ui32_f32 uZ; + + sign = ( a < 0 ); + if ( ! ( a & 0x7FFFFFFF ) ) { + uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0; + return uZ.f; + } + return softfloat_normRoundPackToF32( sign, 0x9C, sign ? - a : a ); + +} + diff --git a/softfloat/i32_to_f32.cc b/softfloat/i32_to_f32.cc deleted file mode 100755 index f51facd..0000000 --- a/softfloat/i32_to_f32.cc +++ /dev/null @@ -1,21 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float32_t i32_to_f32( int_fast32_t a ) -{ - bool sign; - union ui32_f32 uZ; - - sign = ( a < 0 ); - if ( ! ( a & 0x7FFFFFFF ) ) { - uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0; - return uZ.f; - } - return softfloat_normRoundPackToF32( sign, 0x9C, sign ? - a : a ); - -} - diff --git a/softfloat/i32_to_f64.c b/softfloat/i32_to_f64.c new file mode 100755 index 0000000..d42cbe8 --- /dev/null +++ b/softfloat/i32_to_f64.c @@ -0,0 +1,31 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float64_t i32_to_f64( int_fast32_t a ) +{ + uint_fast64_t uiZ; + bool sign; + uint_fast32_t absA; + int shiftCount; + union ui64_f64 uZ; + + if ( ! a ) { + uiZ = 0; + } else { + sign = ( a < 0 ); + absA = sign ? - a : a; + shiftCount = softfloat_countLeadingZeros32( absA ) + 21; + uiZ = + packToF64UI( + sign, 0x432 - shiftCount, (uint_fast64_t) absA< -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float64_t i32_to_f64( int_fast32_t a ) -{ - uint_fast64_t uiZ; - bool sign; - uint_fast32_t absA; - int shiftCount; - union ui64_f64 uZ; - - if ( ! a ) { - uiZ = 0; - } else { - sign = ( a < 0 ); - absA = sign ? - a : a; - shiftCount = softfloat_countLeadingZeros32( absA ) + 21; - uiZ = - packToF64UI( - sign, 0x432 - shiftCount, (uint_fast64_t) absA< +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float32_t i64_to_f32( int_fast64_t a ) +{ + bool sign; + uint_fast64_t absA; + int shiftCount; + union ui32_f32 u; + uint_fast32_t sig; + + sign = ( a < 0 ); + absA = sign ? - (uint_fast64_t) a : a; + shiftCount = softfloat_countLeadingZeros64( absA ) - 40; + if ( 0 <= shiftCount ) { + u.ui = + a ? packToF32UI( + sign, 0x95 - shiftCount, (uint_fast32_t) absA< -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float32_t i64_to_f32( int_fast64_t a ) -{ - bool sign; - uint_fast64_t absA; - int shiftCount; - union ui32_f32 u; - uint_fast32_t sig; - - sign = ( a < 0 ); - absA = sign ? - (uint_fast64_t) a : a; - shiftCount = softfloat_countLeadingZeros64( absA ) - 40; - if ( 0 <= shiftCount ) { - u.ui = - a ? packToF32UI( - sign, 0x95 - shiftCount, (uint_fast32_t) absA< +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +float64_t i64_to_f64( int_fast64_t a ) +{ + bool sign; + union ui64_f64 uZ; + + sign = ( a < 0 ); + if ( ! ( a & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) ) { + uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0; + return uZ.f; + } + return softfloat_normRoundPackToF64( sign, 0x43C, sign ? - a : a ); + +} + diff --git a/softfloat/i64_to_f64.cc b/softfloat/i64_to_f64.cc deleted file mode 100755 index 1add960..0000000 --- a/softfloat/i64_to_f64.cc +++ /dev/null @@ -1,21 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -float64_t i64_to_f64( int_fast64_t a ) -{ - bool sign; - union ui64_f64 uZ; - - sign = ( a < 0 ); - if ( ! ( a & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) ) { - uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0; - return uZ.f; - } - return softfloat_normRoundPackToF64( sign, 0x43C, sign ? - a : a ); - -} - diff --git a/softfloat/s_add128.c b/softfloat/s_add128.c new file mode 100755 index 0000000..59c0348 --- /dev/null +++ b/softfloat/s_add128.c @@ -0,0 +1,17 @@ + +#include +#include "platform.h" +#include "primitives.h" + +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.v64 += ( z.v0 < a0 ); + return z; + +} + diff --git a/softfloat/s_add128.cc b/softfloat/s_add128.cc deleted file mode 100755 index 59c0348..0000000 --- a/softfloat/s_add128.cc +++ /dev/null @@ -1,17 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -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.v64 += ( z.v0 < a0 ); - return z; - -} - diff --git a/softfloat/s_add192.c b/softfloat/s_add192.c new file mode 100755 index 0000000..543eb5d --- /dev/null +++ b/softfloat/s_add192.c @@ -0,0 +1,30 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint192 + softfloat_add192( + uint64_t a128, + uint64_t a64, + uint64_t a0, + uint64_t b128, + uint64_t b64, + uint64_t b0 + ) +{ + struct uint192 z; + unsigned int carry64, carry128; + + z.v0 = a0 + b0; + carry64 = ( z.v0 < a0 ); + z.v64 = a64 + b64; + carry128 = ( z.v64 < a64 ); + z.v128 = a128 + b128; + z.v64 += carry64; + carry128 += ( z.v64 < carry64 ); + z.v128 += carry128; + return z; + +} + diff --git a/softfloat/s_add192.cc b/softfloat/s_add192.cc deleted file mode 100755 index 543eb5d..0000000 --- a/softfloat/s_add192.cc +++ /dev/null @@ -1,30 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint192 - softfloat_add192( - uint64_t a128, - uint64_t a64, - uint64_t a0, - uint64_t b128, - uint64_t b64, - uint64_t b0 - ) -{ - struct uint192 z; - unsigned int carry64, carry128; - - z.v0 = a0 + b0; - carry64 = ( z.v0 < a0 ); - z.v64 = a64 + b64; - carry128 = ( z.v64 < a64 ); - z.v128 = a128 + b128; - z.v64 += carry64; - carry128 += ( z.v64 < carry64 ); - z.v128 += carry128; - return z; - -} - diff --git a/softfloat/s_addMagsF32.c b/softfloat/s_addMagsF32.c new file mode 100755 index 0000000..f361e2b --- /dev/null +++ b/softfloat/s_addMagsF32.c @@ -0,0 +1,75 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" + +float32_t + softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB, bool signZ ) +{ + int_fast16_t expA; + uint_fast32_t sigA; + int_fast16_t expB; + uint_fast32_t sigB; + int_fast16_t expDiff; + uint_fast32_t uiZ; + int_fast16_t expZ; + uint_fast32_t sigZ; + union ui32_f32 uZ; + + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + expDiff = expA - expB; + sigA <<= 6; + sigB <<= 6; + if ( ! expDiff ) { + if ( expA == 0xFF ) { + if ( sigA | sigB ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + if ( ! expA ) { + uiZ = packToF32UI( signZ, 0, ( uiA + uiB ) & 0x7FFFFFFF ); + goto uiZ; + } + expZ = expA; + sigZ = 0x40000000 + sigA + sigB; + } else { + if ( expDiff < 0 ) { + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + uiZ = packToF32UI( signZ, 0xFF, 0 ); + goto uiZ; + } + expZ = expB; + sigA += expA ? 0x20000000 : sigA; + sigA = softfloat_shift32RightJam( sigA, - expDiff ); + } else { + if ( expA == 0xFF ) { + if ( sigA ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + expZ = expA; + sigB += expB ? 0x20000000 : sigB; + sigB = softfloat_shift32RightJam( sigB, expDiff ); + } + sigZ = 0x20000000 + sigA + sigB; + if ( sigZ < 0x40000000 ) { + --expZ; + sigZ <<= 1; + } + } + return softfloat_roundPackToF32( signZ, expZ, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/s_addMagsF32.cc b/softfloat/s_addMagsF32.cc deleted file mode 100755 index f361e2b..0000000 --- a/softfloat/s_addMagsF32.cc +++ /dev/null @@ -1,75 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" - -float32_t - softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB, bool signZ ) -{ - int_fast16_t expA; - uint_fast32_t sigA; - int_fast16_t expB; - uint_fast32_t sigB; - int_fast16_t expDiff; - uint_fast32_t uiZ; - int_fast16_t expZ; - uint_fast32_t sigZ; - union ui32_f32 uZ; - - expA = expF32UI( uiA ); - sigA = fracF32UI( uiA ); - expB = expF32UI( uiB ); - sigB = fracF32UI( uiB ); - expDiff = expA - expB; - sigA <<= 6; - sigB <<= 6; - if ( ! expDiff ) { - if ( expA == 0xFF ) { - if ( sigA | sigB ) goto propagateNaN; - uiZ = uiA; - goto uiZ; - } - if ( ! expA ) { - uiZ = packToF32UI( signZ, 0, ( uiA + uiB ) & 0x7FFFFFFF ); - goto uiZ; - } - expZ = expA; - sigZ = 0x40000000 + sigA + sigB; - } else { - if ( expDiff < 0 ) { - if ( expB == 0xFF ) { - if ( sigB ) goto propagateNaN; - uiZ = packToF32UI( signZ, 0xFF, 0 ); - goto uiZ; - } - expZ = expB; - sigA += expA ? 0x20000000 : sigA; - sigA = softfloat_shift32RightJam( sigA, - expDiff ); - } else { - if ( expA == 0xFF ) { - if ( sigA ) goto propagateNaN; - uiZ = uiA; - goto uiZ; - } - expZ = expA; - sigB += expB ? 0x20000000 : sigB; - sigB = softfloat_shift32RightJam( sigB, expDiff ); - } - sigZ = 0x20000000 + sigA + sigB; - if ( sigZ < 0x40000000 ) { - --expZ; - sigZ <<= 1; - } - } - return softfloat_roundPackToF32( signZ, expZ, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/s_addMagsF64.c b/softfloat/s_addMagsF64.c new file mode 100755 index 0000000..a81c3e4 --- /dev/null +++ b/softfloat/s_addMagsF64.c @@ -0,0 +1,77 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" + +float64_t + softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ ) +{ + int_fast16_t expA; + uint_fast64_t sigA; + int_fast16_t expB; + uint_fast64_t sigB; + int_fast16_t expDiff; + uint_fast64_t uiZ; + int_fast16_t expZ; + uint_fast64_t sigZ; + union ui64_f64 uZ; + + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + expDiff = expA - expB; + sigA <<= 9; + sigB <<= 9; + if ( ! expDiff ) { + if ( expA == 0x7FF ) { + if ( sigA | sigB ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + if ( ! expA ) { + uiZ = + packToF64UI( + signZ, 0, ( uiA + uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ); + goto uiZ; + } + expZ = expA; + sigZ = UINT64_C( 0x4000000000000000 ) + sigA + sigB; + } else { + if ( expDiff < 0 ) { + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + uiZ = packToF64UI( signZ, 0x7FF, 0 ); + goto uiZ; + } + expZ = expB; + sigA += expA ? UINT64_C( 0x2000000000000000 ) : sigA; + sigA = softfloat_shift64RightJam( sigA, - expDiff ); + } else { + if ( expA == 0x7FF ) { + if ( sigA ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + expZ = expA; + sigB += expB ? UINT64_C( 0x2000000000000000 ) : sigB; + sigB = softfloat_shift64RightJam( sigB, expDiff ); + } + sigZ = UINT64_C( 0x2000000000000000 ) + sigA + sigB; + if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { + --expZ; + sigZ <<= 1; + } + } + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/s_addMagsF64.cc b/softfloat/s_addMagsF64.cc deleted file mode 100755 index a81c3e4..0000000 --- a/softfloat/s_addMagsF64.cc +++ /dev/null @@ -1,77 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" - -float64_t - softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ ) -{ - int_fast16_t expA; - uint_fast64_t sigA; - int_fast16_t expB; - uint_fast64_t sigB; - int_fast16_t expDiff; - uint_fast64_t uiZ; - int_fast16_t expZ; - uint_fast64_t sigZ; - union ui64_f64 uZ; - - expA = expF64UI( uiA ); - sigA = fracF64UI( uiA ); - expB = expF64UI( uiB ); - sigB = fracF64UI( uiB ); - expDiff = expA - expB; - sigA <<= 9; - sigB <<= 9; - if ( ! expDiff ) { - if ( expA == 0x7FF ) { - if ( sigA | sigB ) goto propagateNaN; - uiZ = uiA; - goto uiZ; - } - if ( ! expA ) { - uiZ = - packToF64UI( - signZ, 0, ( uiA + uiB ) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ); - goto uiZ; - } - expZ = expA; - sigZ = UINT64_C( 0x4000000000000000 ) + sigA + sigB; - } else { - if ( expDiff < 0 ) { - if ( expB == 0x7FF ) { - if ( sigB ) goto propagateNaN; - uiZ = packToF64UI( signZ, 0x7FF, 0 ); - goto uiZ; - } - expZ = expB; - sigA += expA ? UINT64_C( 0x2000000000000000 ) : sigA; - sigA = softfloat_shift64RightJam( sigA, - expDiff ); - } else { - if ( expA == 0x7FF ) { - if ( sigA ) goto propagateNaN; - uiZ = uiA; - goto uiZ; - } - expZ = expA; - sigB += expB ? UINT64_C( 0x2000000000000000 ) : sigB; - sigB = softfloat_shift64RightJam( sigB, expDiff ); - } - sigZ = UINT64_C( 0x2000000000000000 ) + sigA + sigB; - if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { - --expZ; - sigZ <<= 1; - } - } - return softfloat_roundPackToF64( signZ, expZ, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/s_countLeadingZeros32.c b/softfloat/s_countLeadingZeros32.c new file mode 100755 index 0000000..0bd17e1 --- /dev/null +++ b/softfloat/s_countLeadingZeros32.c @@ -0,0 +1,22 @@ + +#include +#include "primitives.h" + +int softfloat_countLeadingZeros32( uint32_t a ) +{ + int count; + + count = 0; + if ( a < 0x10000 ) { + count = 16; + a <<= 16; + } + if ( a < 0x1000000 ) { + count += 8; + a <<= 8; + } + count += softfloat_countLeadingZeros8[ a>>24 ]; + return count; + +} + diff --git a/softfloat/s_countLeadingZeros32.cc b/softfloat/s_countLeadingZeros32.cc deleted file mode 100755 index 0bd17e1..0000000 --- a/softfloat/s_countLeadingZeros32.cc +++ /dev/null @@ -1,22 +0,0 @@ - -#include -#include "primitives.h" - -int softfloat_countLeadingZeros32( uint32_t a ) -{ - int count; - - count = 0; - if ( a < 0x10000 ) { - count = 16; - a <<= 16; - } - if ( a < 0x1000000 ) { - count += 8; - a <<= 8; - } - count += softfloat_countLeadingZeros8[ a>>24 ]; - return count; - -} - diff --git a/softfloat/s_countLeadingZeros64.c b/softfloat/s_countLeadingZeros64.c new file mode 100755 index 0000000..79f4280 --- /dev/null +++ b/softfloat/s_countLeadingZeros64.c @@ -0,0 +1,32 @@ + +#include +#include "primitives.h" +#include "platform.h" + +int softfloat_countLeadingZeros64( uint64_t a ) +{ + int count; + uint32_t a32; + + count = 32; + a32 = a; + if ( UINT64_C( 0x100000000 ) <= a ) { + count = 0; + a32 = a>>32; + } + /*------------------------------------------------------------------------ + | From here, result is current count + count leading zeros of `a32'. + *------------------------------------------------------------------------*/ + if ( a32 < 0x10000 ) { + count += 16; + a32 <<= 16; + } + if ( a32 < 0x1000000 ) { + count += 8; + a32 <<= 8; + } + count += softfloat_countLeadingZeros8[ a32>>24 ]; + return count; + +} + diff --git a/softfloat/s_countLeadingZeros64.cc b/softfloat/s_countLeadingZeros64.cc deleted file mode 100755 index 79f4280..0000000 --- a/softfloat/s_countLeadingZeros64.cc +++ /dev/null @@ -1,32 +0,0 @@ - -#include -#include "primitives.h" -#include "platform.h" - -int softfloat_countLeadingZeros64( uint64_t a ) -{ - int count; - uint32_t a32; - - count = 32; - a32 = a; - if ( UINT64_C( 0x100000000 ) <= a ) { - count = 0; - a32 = a>>32; - } - /*------------------------------------------------------------------------ - | From here, result is current count + count leading zeros of `a32'. - *------------------------------------------------------------------------*/ - if ( a32 < 0x10000 ) { - count += 16; - a32 <<= 16; - } - if ( a32 < 0x1000000 ) { - count += 8; - a32 <<= 8; - } - count += softfloat_countLeadingZeros8[ a32>>24 ]; - return count; - -} - diff --git a/softfloat/s_countLeadingZeros8.c b/softfloat/s_countLeadingZeros8.c new file mode 100755 index 0000000..4eca7e9 --- /dev/null +++ b/softfloat/s_countLeadingZeros8.c @@ -0,0 +1,24 @@ + +#include +#include "platform.h" +#include "primitives.h" + +const uint8_t softfloat_countLeadingZeros8[ 256 ] = { + 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + diff --git a/softfloat/s_countLeadingZeros8.cc b/softfloat/s_countLeadingZeros8.cc deleted file mode 100755 index 4eca7e9..0000000 --- a/softfloat/s_countLeadingZeros8.cc +++ /dev/null @@ -1,24 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -const uint8_t softfloat_countLeadingZeros8[ 256 ] = { - 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - diff --git a/softfloat/s_eq128.c b/softfloat/s_eq128.c new file mode 100755 index 0000000..7261dc4 --- /dev/null +++ b/softfloat/s_eq128.c @@ -0,0 +1,13 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" + +bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + + return ( a64 == b64 ) && ( a0 == b0 ); + +} + diff --git a/softfloat/s_eq128.cc b/softfloat/s_eq128.cc deleted file mode 100755 index 7261dc4..0000000 --- a/softfloat/s_eq128.cc +++ /dev/null @@ -1,13 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" - -bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) -{ - - return ( a64 == b64 ) && ( a0 == b0 ); - -} - diff --git a/softfloat/s_estimateDiv128To64.c b/softfloat/s_estimateDiv128To64.c new file mode 100755 index 0000000..f8610a2 --- /dev/null +++ b/softfloat/s_estimateDiv128To64.c @@ -0,0 +1,28 @@ + +#include +#include "platform.h" +#include "primitives.h" + +uint64_t softfloat_estimateDiv128To64( uint64_t a64, uint64_t a0, uint64_t b ) +{ + uint32_t b32; + uint64_t z; + struct uint128 term, rem; + uint64_t rem32; + + if ( b <= a64 ) return UINT64_C( 0xFFFFFFFFFFFFFFFF ); + b32 = b>>32; + z = ( (uint64_t) b32<<32 <= a64 ) ? UINT64_C( 0xFFFFFFFF00000000 ) + : ( a64 / b32 )<<32; + term = softfloat_mul64To128( b, z ); + rem = softfloat_sub128( a64, a0, term.v64, term.v0 ); + while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) { + z -= UINT64_C( 0x100000000 ); + rem = softfloat_add128( rem.v64, rem.v0, b32, (uint64_t) ( b<<32 ) ); + } + rem32 = ( rem.v64<<32 ) | ( rem.v0>>32 ); + z |= ( (uint64_t) b32<<32 <= rem32 ) ? 0xFFFFFFFF : rem32 / b32; + return z; + +} + diff --git a/softfloat/s_estimateDiv128To64.cc b/softfloat/s_estimateDiv128To64.cc deleted file mode 100755 index f8610a2..0000000 --- a/softfloat/s_estimateDiv128To64.cc +++ /dev/null @@ -1,28 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -uint64_t softfloat_estimateDiv128To64( uint64_t a64, uint64_t a0, uint64_t b ) -{ - uint32_t b32; - uint64_t z; - struct uint128 term, rem; - uint64_t rem32; - - if ( b <= a64 ) return UINT64_C( 0xFFFFFFFFFFFFFFFF ); - b32 = b>>32; - z = ( (uint64_t) b32<<32 <= a64 ) ? UINT64_C( 0xFFFFFFFF00000000 ) - : ( a64 / b32 )<<32; - term = softfloat_mul64To128( b, z ); - rem = softfloat_sub128( a64, a0, term.v64, term.v0 ); - while ( UINT64_C( 0x8000000000000000 ) <= rem.v64 ) { - z -= UINT64_C( 0x100000000 ); - rem = softfloat_add128( rem.v64, rem.v0, b32, (uint64_t) ( b<<32 ) ); - } - rem32 = ( rem.v64<<32 ) | ( rem.v0>>32 ); - z |= ( (uint64_t) b32<<32 <= rem32 ) ? 0xFFFFFFFF : rem32 / b32; - return z; - -} - diff --git a/softfloat/s_estimateSqrt32.c b/softfloat/s_estimateSqrt32.c new file mode 100755 index 0000000..e22a9dc --- /dev/null +++ b/softfloat/s_estimateSqrt32.c @@ -0,0 +1,37 @@ + +#include +#include "platform.h" +#include "primitives.h" + +uint32_t softfloat_estimateSqrt32( unsigned int expA, uint32_t a ) +{ + static const uint16_t sqrtOddAdjustments[] = { + 0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0, + 0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67 + }; + static const uint16_t sqrtEvenAdjustments[] = { + 0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E, + 0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002 + }; + int index; + uint32_t z; + union { uint32_t ui; int32_t i; } u32; + + index = ( a>>27 ) & 15; + if ( expA & 1 ) { + z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ]; + z = ( ( a / z )<<14 ) + ( z<<15 ); + a >>= 1; + } else { + z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ]; + z = a / z + z; + z = ( 0x20000 <= z ) ? 0xFFFF8000 : z<<15; + if ( z <= a ) { + u32.ui = a; + return u32.i>>1; + } + } + return (uint32_t) ( ( (uint64_t) a<<31 ) / z ) + ( z>>1 ); + +} + diff --git a/softfloat/s_estimateSqrt32.cc b/softfloat/s_estimateSqrt32.cc deleted file mode 100755 index e22a9dc..0000000 --- a/softfloat/s_estimateSqrt32.cc +++ /dev/null @@ -1,37 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -uint32_t softfloat_estimateSqrt32( unsigned int expA, uint32_t a ) -{ - static const uint16_t sqrtOddAdjustments[] = { - 0x0004, 0x0022, 0x005D, 0x00B1, 0x011D, 0x019F, 0x0236, 0x02E0, - 0x039C, 0x0468, 0x0545, 0x0631, 0x072B, 0x0832, 0x0946, 0x0A67 - }; - static const uint16_t sqrtEvenAdjustments[] = { - 0x0A2D, 0x08AF, 0x075A, 0x0629, 0x051A, 0x0429, 0x0356, 0x029E, - 0x0200, 0x0179, 0x0109, 0x00AF, 0x0068, 0x0034, 0x0012, 0x0002 - }; - int index; - uint32_t z; - union { uint32_t ui; int32_t i; } u32; - - index = ( a>>27 ) & 15; - if ( expA & 1 ) { - z = 0x4000 + ( a>>17 ) - sqrtOddAdjustments[ index ]; - z = ( ( a / z )<<14 ) + ( z<<15 ); - a >>= 1; - } else { - z = 0x8000 + ( a>>17 ) - sqrtEvenAdjustments[ index ]; - z = a / z + z; - z = ( 0x20000 <= z ) ? 0xFFFF8000 : z<<15; - if ( z <= a ) { - u32.ui = a; - return u32.i>>1; - } - } - return (uint32_t) ( ( (uint64_t) a<<31 ) / z ) + ( z>>1 ); - -} - diff --git a/softfloat/s_le128.c b/softfloat/s_le128.c new file mode 100755 index 0000000..83b1d7f --- /dev/null +++ b/softfloat/s_le128.c @@ -0,0 +1,13 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" + +bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + + return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 <= b0 ) ); + +} + diff --git a/softfloat/s_le128.cc b/softfloat/s_le128.cc deleted file mode 100755 index 83b1d7f..0000000 --- a/softfloat/s_le128.cc +++ /dev/null @@ -1,13 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" - -bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) -{ - - return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 <= b0 ) ); - -} - diff --git a/softfloat/s_lt128.c b/softfloat/s_lt128.c new file mode 100755 index 0000000..33a3df4 --- /dev/null +++ b/softfloat/s_lt128.c @@ -0,0 +1,13 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" + +bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + + return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 < b0 ) ); + +} + diff --git a/softfloat/s_lt128.cc b/softfloat/s_lt128.cc deleted file mode 100755 index 33a3df4..0000000 --- a/softfloat/s_lt128.cc +++ /dev/null @@ -1,13 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" - -bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) -{ - - return ( a64 < b64 ) || ( ( a64 == b64 ) && ( a0 < b0 ) ); - -} - diff --git a/softfloat/s_mul128By64To192.c b/softfloat/s_mul128By64To192.c new file mode 100755 index 0000000..dfa8825 --- /dev/null +++ b/softfloat/s_mul128By64To192.c @@ -0,0 +1,20 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint192 + softfloat_mul128By64To192( uint64_t a64, uint64_t a0, uint64_t b ) +{ + struct uint128 p0, p64; + struct uint192 z; + + p0 = softfloat_mul64To128( a0, b ); + z.v0 = p0.v0; + p64 = softfloat_mul64To128( a64, b ); + z.v64 = p64.v0 + p0.v64; + z.v128 = p64.v64 + ( z.v64 < p64.v0 ); + return z; + +} + diff --git a/softfloat/s_mul128By64To192.cc b/softfloat/s_mul128By64To192.cc deleted file mode 100755 index dfa8825..0000000 --- a/softfloat/s_mul128By64To192.cc +++ /dev/null @@ -1,20 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint192 - softfloat_mul128By64To192( uint64_t a64, uint64_t a0, uint64_t b ) -{ - struct uint128 p0, p64; - struct uint192 z; - - p0 = softfloat_mul64To128( a0, b ); - z.v0 = p0.v0; - p64 = softfloat_mul64To128( a64, b ); - z.v64 = p64.v0 + p0.v64; - z.v128 = p64.v64 + ( z.v64 < p64.v0 ); - return z; - -} - diff --git a/softfloat/s_mul128To256.c b/softfloat/s_mul128To256.c new file mode 100755 index 0000000..a96cd94 --- /dev/null +++ b/softfloat/s_mul128To256.c @@ -0,0 +1,28 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint256 + softfloat_mul128To256( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) +{ + struct uint128 p0, p64, p128; + struct uint256 z; + + p0 = softfloat_mul64To128( a0, b0 ); + z.v0 = p0.v0; + p64 = softfloat_mul64To128( a64, b0 ); + z.v64 = p64.v0 + p0.v64; + z.v128 = p64.v64 + ( z.v64 < p64.v0 ); + p128 = softfloat_mul64To128( a64, b64 ); + z.v128 += p128.v0; + z.v192 = p128.v64 + ( z.v128 < p128.v0 ); + p64 = softfloat_mul64To128( a0, b64 ); + z.v64 += p64.v0; + p64.v64 += ( z.v64 < p64.v0 ); + z.v128 += p64.v64; + z.v192 += ( z.v128 < p64.v64 ); + return z; + +} + diff --git a/softfloat/s_mul128To256.cc b/softfloat/s_mul128To256.cc deleted file mode 100755 index a96cd94..0000000 --- a/softfloat/s_mul128To256.cc +++ /dev/null @@ -1,28 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint256 - softfloat_mul128To256( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 ) -{ - struct uint128 p0, p64, p128; - struct uint256 z; - - p0 = softfloat_mul64To128( a0, b0 ); - z.v0 = p0.v0; - p64 = softfloat_mul64To128( a64, b0 ); - z.v64 = p64.v0 + p0.v64; - z.v128 = p64.v64 + ( z.v64 < p64.v0 ); - p128 = softfloat_mul64To128( a64, b64 ); - z.v128 += p128.v0; - z.v192 = p128.v64 + ( z.v128 < p128.v0 ); - p64 = softfloat_mul64To128( a0, b64 ); - z.v64 += p64.v0; - p64.v64 += ( z.v64 < p64.v0 ); - z.v128 += p64.v64; - z.v192 += ( z.v128 < p64.v64 ); - return z; - -} - diff --git a/softfloat/s_mul64To128.c b/softfloat/s_mul64To128.c new file mode 100755 index 0000000..c17780b --- /dev/null +++ b/softfloat/s_mul64To128.c @@ -0,0 +1,28 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b ) +{ + uint32_t a32, a0, b32, b0; + struct uint128 z; + uint64_t mid1, mid2, mid; + + a32 = a>>32; + a0 = a; + b32 = b>>32; + b0 = b; + z.v0 = (uint64_t) a0 * b0; + mid1 = (uint64_t) a32 * b0; + mid2 = (uint64_t) a0 * b32; + z.v64 = (uint64_t) a32 * b32; + mid = mid1 + mid2; + z.v64 += ( (uint64_t) ( mid < mid1 ) )<<32 | mid>>32; + mid <<= 32; + z.v0 += mid; + z.v64 += ( z.v0 < mid ); + return z; + +} + diff --git a/softfloat/s_mul64To128.cc b/softfloat/s_mul64To128.cc deleted file mode 100755 index c17780b..0000000 --- a/softfloat/s_mul64To128.cc +++ /dev/null @@ -1,28 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b ) -{ - uint32_t a32, a0, b32, b0; - struct uint128 z; - uint64_t mid1, mid2, mid; - - a32 = a>>32; - a0 = a; - b32 = b>>32; - b0 = b; - z.v0 = (uint64_t) a0 * b0; - mid1 = (uint64_t) a32 * b0; - mid2 = (uint64_t) a0 * b32; - z.v64 = (uint64_t) a32 * b32; - mid = mid1 + mid2; - z.v64 += ( (uint64_t) ( mid < mid1 ) )<<32 | mid>>32; - mid <<= 32; - z.v0 += mid; - z.v64 += ( z.v0 < mid ); - return z; - -} - diff --git a/softfloat/s_mulAddF32.c b/softfloat/s_mulAddF32.c new file mode 100755 index 0000000..e55a0ba --- /dev/null +++ b/softfloat/s_mulAddF32.c @@ -0,0 +1,171 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t + softfloat_mulAddF32( + int op, uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC ) +{ + bool signA; + int_fast16_t expA; + uint_fast32_t sigA; + bool signB; + int_fast16_t expB; + uint_fast32_t sigB; + bool signC; + int_fast16_t expC; + uint_fast32_t sigC; + bool signProd; + uint_fast32_t magBits, uiZ; + struct exp16_sig32 normExpSig; + int_fast16_t expProd; + uint_fast64_t sigProd; + bool signZ; + int_fast16_t expZ; + uint_fast32_t sigZ; + int_fast16_t expDiff; + uint_fast64_t sigZ64, sigC64; + int shiftCount; + union ui32_f32 uZ; + + signA = signF32UI( uiA ); + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + signB = signF32UI( uiB ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + signC = signF32UI( uiC ) ^ ( op == softfloat_mulAdd_subC ); + expC = expF32UI( uiC ); + sigC = fracF32UI( uiC ); + signProd = signA ^ signB ^ ( op == softfloat_mulAdd_subProd ); + if ( expA == 0xFF ) { + if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN_ABC; + magBits = expB | sigB; + goto infProdArg; + } + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN_ABC; + magBits = expA | sigA; + goto infProdArg; + } + if ( expC == 0xFF ) { + if ( sigC ) { + uiZ = 0; + goto propagateNaN_ZC; + } + uiZ = uiC; + goto uiZ; + } + if ( ! expA ) { + if ( ! sigA ) goto zeroProd; + normExpSig = softfloat_normSubnormalF32Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zeroProd; + normExpSig = softfloat_normSubnormalF32Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + expProd = expA + expB - 0x7E; + sigA = ( sigA | 0x00800000 )<<7; + sigB = ( sigB | 0x00800000 )<<7; + sigProd = (uint_fast64_t) sigA * sigB; + if ( sigProd < UINT64_C( 0x2000000000000000 ) ) { + --expProd; + sigProd <<= 1; + } + signZ = signProd; + if ( ! expC ) { + if ( ! sigC ) { + expZ = expProd - 1; + sigZ = softfloat_shortShift64RightJam( sigProd, 31 ); + goto roundPack; + } + normExpSig = softfloat_normSubnormalF32Sig( sigC ); + expC = normExpSig.exp; + sigC = normExpSig.sig; + } + sigC = ( sigC | 0x00800000 )<<6; + expDiff = expProd - expC; + if ( signProd == signC ) { + if ( expDiff <= 0 ) { + expZ = expC; + sigZ = sigC + softfloat_shift64RightJam( sigProd, 32 - expDiff ); + } else { + expZ = expProd; + sigZ64 = + sigProd + + softfloat_shift64RightJam( + (uint_fast64_t) sigC<<32, expDiff ); + sigZ = softfloat_shortShift64RightJam( sigZ64, 32 ); + } + if ( sigZ < 0x40000000 ) { + --expZ; + sigZ <<= 1; + } + } else { +/*** OPTIMIZE BETTER? ***/ + sigC64 = (uint_fast64_t) sigC<<32; + if ( expDiff < 0 ) { + signZ = signC; + expZ = expC; + sigZ64 = sigC64 - softfloat_shift64RightJam( sigProd, - expDiff ); + } else if ( ! expDiff ) { + expZ = expProd; + sigZ64 = sigProd - sigC64; + if ( ! sigZ64 ) goto completeCancellation; + if ( sigZ64 & UINT64_C( 0x8000000000000000 ) ) { + signZ ^= 1; + sigZ64 = - sigZ64; + } + } else { + expZ = expProd; + sigZ64 = sigProd - softfloat_shift64RightJam( sigC64, expDiff ); + } + shiftCount = softfloat_countLeadingZeros64( sigZ64 ) - 1; + expZ -= shiftCount; + shiftCount -= 32; + if ( shiftCount < 0 ) { + sigZ = softfloat_shortShift64RightJam( sigZ64, - shiftCount ); + } else { + sigZ = (uint_fast32_t) sigZ64< -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t - softfloat_mulAddF32( - int op, uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC ) -{ - bool signA; - int_fast16_t expA; - uint_fast32_t sigA; - bool signB; - int_fast16_t expB; - uint_fast32_t sigB; - bool signC; - int_fast16_t expC; - uint_fast32_t sigC; - bool signProd; - uint_fast32_t magBits, uiZ; - struct exp16_sig32 normExpSig; - int_fast16_t expProd; - uint_fast64_t sigProd; - bool signZ; - int_fast16_t expZ; - uint_fast32_t sigZ; - int_fast16_t expDiff; - uint_fast64_t sigZ64, sigC64; - int shiftCount; - union ui32_f32 uZ; - - signA = signF32UI( uiA ); - expA = expF32UI( uiA ); - sigA = fracF32UI( uiA ); - signB = signF32UI( uiB ); - expB = expF32UI( uiB ); - sigB = fracF32UI( uiB ); - signC = signF32UI( uiC ) ^ ( op == softfloat_mulAdd_subC ); - expC = expF32UI( uiC ); - sigC = fracF32UI( uiC ); - signProd = signA ^ signB ^ ( op == softfloat_mulAdd_subProd ); - if ( expA == 0xFF ) { - if ( sigA || ( ( expB == 0xFF ) && sigB ) ) goto propagateNaN_ABC; - magBits = expB | sigB; - goto infProdArg; - } - if ( expB == 0xFF ) { - if ( sigB ) goto propagateNaN_ABC; - magBits = expA | sigA; - goto infProdArg; - } - if ( expC == 0xFF ) { - if ( sigC ) { - uiZ = 0; - goto propagateNaN_ZC; - } - uiZ = uiC; - goto uiZ; - } - if ( ! expA ) { - if ( ! sigA ) goto zeroProd; - normExpSig = softfloat_normSubnormalF32Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - if ( ! expB ) { - if ( ! sigB ) goto zeroProd; - normExpSig = softfloat_normSubnormalF32Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - expProd = expA + expB - 0x7E; - sigA = ( sigA | 0x00800000 )<<7; - sigB = ( sigB | 0x00800000 )<<7; - sigProd = (uint_fast64_t) sigA * sigB; - if ( sigProd < UINT64_C( 0x2000000000000000 ) ) { - --expProd; - sigProd <<= 1; - } - signZ = signProd; - if ( ! expC ) { - if ( ! sigC ) { - expZ = expProd - 1; - sigZ = softfloat_shortShift64RightJam( sigProd, 31 ); - goto roundPack; - } - normExpSig = softfloat_normSubnormalF32Sig( sigC ); - expC = normExpSig.exp; - sigC = normExpSig.sig; - } - sigC = ( sigC | 0x00800000 )<<6; - expDiff = expProd - expC; - if ( signProd == signC ) { - if ( expDiff <= 0 ) { - expZ = expC; - sigZ = sigC + softfloat_shift64RightJam( sigProd, 32 - expDiff ); - } else { - expZ = expProd; - sigZ64 = - sigProd - + softfloat_shift64RightJam( - (uint_fast64_t) sigC<<32, expDiff ); - sigZ = softfloat_shortShift64RightJam( sigZ64, 32 ); - } - if ( sigZ < 0x40000000 ) { - --expZ; - sigZ <<= 1; - } - } else { -/*** OPTIMIZE BETTER? ***/ - sigC64 = (uint_fast64_t) sigC<<32; - if ( expDiff < 0 ) { - signZ = signC; - expZ = expC; - sigZ64 = sigC64 - softfloat_shift64RightJam( sigProd, - expDiff ); - } else if ( ! expDiff ) { - expZ = expProd; - sigZ64 = sigProd - sigC64; - if ( ! sigZ64 ) goto completeCancellation; - if ( sigZ64 & UINT64_C( 0x8000000000000000 ) ) { - signZ ^= 1; - sigZ64 = - sigZ64; - } - } else { - expZ = expProd; - sigZ64 = sigProd - softfloat_shift64RightJam( sigC64, expDiff ); - } - shiftCount = softfloat_countLeadingZeros64( sigZ64 ) - 1; - expZ -= shiftCount; - shiftCount -= 32; - if ( shiftCount < 0 ) { - sigZ = softfloat_shortShift64RightJam( sigZ64, - shiftCount ); - } else { - sigZ = (uint_fast32_t) sigZ64< +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t + softfloat_mulAddF64( + int op, uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC ) +{ + bool signA; + int_fast16_t expA; + uint_fast64_t sigA; + bool signB; + int_fast16_t expB; + uint_fast64_t sigB; + bool signC; + int_fast16_t expC; + uint_fast64_t sigC; + bool signProd; + uint_fast64_t magBits, uiZ; + struct exp16_sig64 normExpSig; + int_fast16_t expProd; + struct uint128 sigProd; + bool signZ; + int_fast16_t expZ; + uint_fast64_t sigZ; + int_fast16_t expDiff; + struct uint128 sigC128, sigZ128; + int shiftCount; + union ui64_f64 uZ; + + signA = signF64UI( uiA ); + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + signB = signF64UI( uiB ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + signC = signF64UI( uiC ) ^ ( op == softfloat_mulAdd_subC ); + expC = expF64UI( uiC ); + sigC = fracF64UI( uiC ); + signProd = signA ^ signB ^ ( op == softfloat_mulAdd_subProd ); + if ( expA == 0x7FF ) { + if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN_ABC; + magBits = expB | sigB; + goto infProdArg; + } + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN_ABC; + magBits = expA | sigA; + goto infProdArg; + } + if ( expC == 0x7FF ) { + if ( sigC ) { + uiZ = 0; + goto propagateNaN_ZC; + } + uiZ = uiC; + goto uiZ; + } + if ( ! expA ) { + if ( ! sigA ) goto zeroProd; + normExpSig = softfloat_normSubnormalF64Sig( sigA ); + expA = normExpSig.exp; + sigA = normExpSig.sig; + } + if ( ! expB ) { + if ( ! sigB ) goto zeroProd; + normExpSig = softfloat_normSubnormalF64Sig( sigB ); + expB = normExpSig.exp; + sigB = normExpSig.sig; + } + expProd = expA + expB - 0x3FE; + sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10; + sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<10; + sigProd = softfloat_mul64To128( sigA, sigB ); + if ( sigProd.v64 < UINT64_C( 0x2000000000000000 ) ) { + --expProd; + sigProd = softfloat_shortShift128Left( sigProd.v64, sigProd.v0, 1 ); + } + signZ = signProd; + if ( ! expC ) { + if ( ! sigC ) { + expZ = expProd - 1; + sigZ = sigProd.v64<<1 | ( sigProd.v0 != 0 ); + goto roundPack; + } + normExpSig = softfloat_normSubnormalF64Sig( sigC ); + expC = normExpSig.exp; + sigC = normExpSig.sig; + } + sigC = ( sigC | UINT64_C( 0x0010000000000000 ) )<<9; + expDiff = expProd - expC; + if ( signProd == signC ) { + if ( expDiff <= 0 ) { + expZ = expC; + if ( expDiff ) { + sigProd.v64 = + softfloat_shift64RightJam( sigProd.v64, - expDiff ); + } + sigZ = ( sigC + sigProd.v64 ) | ( sigProd.v0 != 0 ); + } else { + expZ = expProd; + sigC128 = softfloat_shift128RightJam( sigC, 0, expDiff ); + sigZ128 = + softfloat_add128( + sigProd.v64, sigProd.v0, sigC128.v64, sigC128.v0 ); + sigZ = sigZ128.v64 | ( sigZ128.v0 != 0 ); + } + if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { + --expZ; + sigZ <<= 1; + } + } else { +/*** OPTIMIZE BETTER? ***/ + if ( expDiff < 0 ) { + signZ = signC; + expZ = expC; + sigProd = + softfloat_shift128RightJam( + sigProd.v64, sigProd.v0, - expDiff ); + sigZ128 = softfloat_sub128( sigC, 0, sigProd.v64, sigProd.v0 ); + } else if ( ! expDiff ) { + expZ = expProd; + sigZ128 = softfloat_sub128( sigProd.v64, sigProd.v0, sigC, 0 ); + if ( ! ( sigZ128.v64 | sigZ128.v0 ) ) goto completeCancellation; + if ( sigZ128.v64 & UINT64_C( 0x8000000000000000 ) ) { + signZ ^= 1; + sigZ128 = softfloat_sub128( 0, 0, sigZ128.v64, sigZ128.v0 ); + } + } else { + expZ = expProd; + sigC128 = softfloat_shift128RightJam( sigC, 0, expDiff ); + sigZ128 = + softfloat_sub128( + sigProd.v64, sigProd.v0, sigC128.v64, sigC128.v0 ); + } + if ( ! sigZ128.v64 ) { + expZ -= 64; + sigZ128.v64 = sigZ128.v0; + sigZ128.v0 = 0; + } + shiftCount = softfloat_countLeadingZeros64( sigZ128.v64 ) - 1; + expZ -= shiftCount; + if ( shiftCount < 0 ) { + sigZ = softfloat_shortShift64RightJam( sigZ128.v64, - shiftCount ); + } else { + sigZ128 = + softfloat_shortShift128Left( + sigZ128.v64, sigZ128.v0, shiftCount ); + sigZ = sigZ128.v64; + } + sigZ |= ( sigZ128.v0 != 0 ); + } + roundPack: + return softfloat_roundPackToF64( signZ, expZ, sigZ ); + propagateNaN_ABC: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + goto propagateNaN_ZC; + infProdArg: + if ( magBits ) { + uiZ = packToF64UI( signProd, 0x7FF, 0 ); + if ( expC != 0x7FF ) goto uiZ; + if ( sigC ) goto propagateNaN_ZC; + if ( signProd == signC ) goto uiZ; + } + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + propagateNaN_ZC: + uiZ = softfloat_propagateNaNF64UI( uiZ, uiC ); + goto uiZ; + zeroProd: + uiZ = uiC; + if ( ! ( expC | sigC ) && ( signProd != signC ) ) { + completeCancellation: + uiZ = + packToF64UI( softfloat_roundingMode == softfloat_round_min, 0, 0 ); + } + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/s_mulAddF64.cc b/softfloat/s_mulAddF64.cc deleted file mode 100755 index 01ba3b4..0000000 --- a/softfloat/s_mulAddF64.cc +++ /dev/null @@ -1,188 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t - softfloat_mulAddF64( - int op, uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC ) -{ - bool signA; - int_fast16_t expA; - uint_fast64_t sigA; - bool signB; - int_fast16_t expB; - uint_fast64_t sigB; - bool signC; - int_fast16_t expC; - uint_fast64_t sigC; - bool signProd; - uint_fast64_t magBits, uiZ; - struct exp16_sig64 normExpSig; - int_fast16_t expProd; - struct uint128 sigProd; - bool signZ; - int_fast16_t expZ; - uint_fast64_t sigZ; - int_fast16_t expDiff; - struct uint128 sigC128, sigZ128; - int shiftCount; - union ui64_f64 uZ; - - signA = signF64UI( uiA ); - expA = expF64UI( uiA ); - sigA = fracF64UI( uiA ); - signB = signF64UI( uiB ); - expB = expF64UI( uiB ); - sigB = fracF64UI( uiB ); - signC = signF64UI( uiC ) ^ ( op == softfloat_mulAdd_subC ); - expC = expF64UI( uiC ); - sigC = fracF64UI( uiC ); - signProd = signA ^ signB ^ ( op == softfloat_mulAdd_subProd ); - if ( expA == 0x7FF ) { - if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN_ABC; - magBits = expB | sigB; - goto infProdArg; - } - if ( expB == 0x7FF ) { - if ( sigB ) goto propagateNaN_ABC; - magBits = expA | sigA; - goto infProdArg; - } - if ( expC == 0x7FF ) { - if ( sigC ) { - uiZ = 0; - goto propagateNaN_ZC; - } - uiZ = uiC; - goto uiZ; - } - if ( ! expA ) { - if ( ! sigA ) goto zeroProd; - normExpSig = softfloat_normSubnormalF64Sig( sigA ); - expA = normExpSig.exp; - sigA = normExpSig.sig; - } - if ( ! expB ) { - if ( ! sigB ) goto zeroProd; - normExpSig = softfloat_normSubnormalF64Sig( sigB ); - expB = normExpSig.exp; - sigB = normExpSig.sig; - } - expProd = expA + expB - 0x3FE; - sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10; - sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<10; - sigProd = softfloat_mul64To128( sigA, sigB ); - if ( sigProd.v64 < UINT64_C( 0x2000000000000000 ) ) { - --expProd; - sigProd = softfloat_shortShift128Left( sigProd.v64, sigProd.v0, 1 ); - } - signZ = signProd; - if ( ! expC ) { - if ( ! sigC ) { - expZ = expProd - 1; - sigZ = sigProd.v64<<1 | ( sigProd.v0 != 0 ); - goto roundPack; - } - normExpSig = softfloat_normSubnormalF64Sig( sigC ); - expC = normExpSig.exp; - sigC = normExpSig.sig; - } - sigC = ( sigC | UINT64_C( 0x0010000000000000 ) )<<9; - expDiff = expProd - expC; - if ( signProd == signC ) { - if ( expDiff <= 0 ) { - expZ = expC; - if ( expDiff ) { - sigProd.v64 = - softfloat_shift64RightJam( sigProd.v64, - expDiff ); - } - sigZ = ( sigC + sigProd.v64 ) | ( sigProd.v0 != 0 ); - } else { - expZ = expProd; - sigC128 = softfloat_shift128RightJam( sigC, 0, expDiff ); - sigZ128 = - softfloat_add128( - sigProd.v64, sigProd.v0, sigC128.v64, sigC128.v0 ); - sigZ = sigZ128.v64 | ( sigZ128.v0 != 0 ); - } - if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { - --expZ; - sigZ <<= 1; - } - } else { -/*** OPTIMIZE BETTER? ***/ - if ( expDiff < 0 ) { - signZ = signC; - expZ = expC; - sigProd = - softfloat_shift128RightJam( - sigProd.v64, sigProd.v0, - expDiff ); - sigZ128 = softfloat_sub128( sigC, 0, sigProd.v64, sigProd.v0 ); - } else if ( ! expDiff ) { - expZ = expProd; - sigZ128 = softfloat_sub128( sigProd.v64, sigProd.v0, sigC, 0 ); - if ( ! ( sigZ128.v64 | sigZ128.v0 ) ) goto completeCancellation; - if ( sigZ128.v64 & UINT64_C( 0x8000000000000000 ) ) { - signZ ^= 1; - sigZ128 = softfloat_sub128( 0, 0, sigZ128.v64, sigZ128.v0 ); - } - } else { - expZ = expProd; - sigC128 = softfloat_shift128RightJam( sigC, 0, expDiff ); - sigZ128 = - softfloat_sub128( - sigProd.v64, sigProd.v0, sigC128.v64, sigC128.v0 ); - } - if ( ! sigZ128.v64 ) { - expZ -= 64; - sigZ128.v64 = sigZ128.v0; - sigZ128.v0 = 0; - } - shiftCount = softfloat_countLeadingZeros64( sigZ128.v64 ) - 1; - expZ -= shiftCount; - if ( shiftCount < 0 ) { - sigZ = softfloat_shortShift64RightJam( sigZ128.v64, - shiftCount ); - } else { - sigZ128 = - softfloat_shortShift128Left( - sigZ128.v64, sigZ128.v0, shiftCount ); - sigZ = sigZ128.v64; - } - sigZ |= ( sigZ128.v0 != 0 ); - } - roundPack: - return softfloat_roundPackToF64( signZ, expZ, sigZ ); - propagateNaN_ABC: - uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); - goto propagateNaN_ZC; - infProdArg: - if ( magBits ) { - uiZ = packToF64UI( signProd, 0x7FF, 0 ); - if ( expC != 0x7FF ) goto uiZ; - if ( sigC ) goto propagateNaN_ZC; - if ( signProd == signC ) goto uiZ; - } - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF64UI; - propagateNaN_ZC: - uiZ = softfloat_propagateNaNF64UI( uiZ, uiC ); - goto uiZ; - zeroProd: - uiZ = uiC; - if ( ! ( expC | sigC ) && ( signProd != signC ) ) { - completeCancellation: - uiZ = - packToF64UI( softfloat_roundingMode == softfloat_round_min, 0, 0 ); - } - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/s_normRoundPackToF32.c b/softfloat/s_normRoundPackToF32.c new file mode 100755 index 0000000..2e6f4b0 --- /dev/null +++ b/softfloat/s_normRoundPackToF32.c @@ -0,0 +1,24 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" + +float32_t + softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig ) +{ + int shiftCount; + union ui32_f32 uZ; + + shiftCount = softfloat_countLeadingZeros32( sig ) - 1; + exp -= shiftCount; + if ( ( 7 <= shiftCount ) && ( (uint16_t) exp < 0xFD ) ) { + uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<( shiftCount - 7 ) ); + return uZ.f; + } else { + return softfloat_roundPackToF32( sign, exp, sig< -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" - -float32_t - softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig ) -{ - int shiftCount; - union ui32_f32 uZ; - - shiftCount = softfloat_countLeadingZeros32( sig ) - 1; - exp -= shiftCount; - if ( ( 7 <= shiftCount ) && ( (uint16_t) exp < 0xFD ) ) { - uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<( shiftCount - 7 ) ); - return uZ.f; - } else { - return softfloat_roundPackToF32( sign, exp, sig< +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" + +float64_t + softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig ) +{ + int shiftCount; + union ui64_f64 uZ; + + shiftCount = softfloat_countLeadingZeros64( sig ) - 1; + exp -= shiftCount; + if ( ( 10 <= shiftCount ) && ( (uint16_t) exp < 0x7FD ) ) { + uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<( shiftCount - 10 ) ); + return uZ.f; + } else { + return softfloat_roundPackToF64( sign, exp, sig< -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" - -float64_t - softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig ) -{ - int shiftCount; - union ui64_f64 uZ; - - shiftCount = softfloat_countLeadingZeros64( sig ) - 1; - exp -= shiftCount; - if ( ( 10 <= shiftCount ) && ( (uint16_t) exp < 0x7FD ) ) { - uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<( shiftCount - 10 ) ); - return uZ.f; - } else { - return softfloat_roundPackToF64( sign, exp, sig< +#include "platform.h" +#include "primitives.h" +#include "internals.h" + +struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig ) +{ + int shiftCount; + struct exp16_sig32 z; + + shiftCount = softfloat_countLeadingZeros32( sig ) - 8; + z.exp = 1 - shiftCount; + z.sig = sig< -#include "platform.h" -#include "primitives.h" -#include "internals.h" - -struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig ) -{ - int shiftCount; - struct exp16_sig32 z; - - shiftCount = softfloat_countLeadingZeros32( sig ) - 8; - z.exp = 1 - shiftCount; - z.sig = sig< +#include "platform.h" +#include "primitives.h" +#include "internals.h" + +struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t sig ) +{ + int shiftCount; + struct exp16_sig64 z; + + shiftCount = softfloat_countLeadingZeros64( sig ) - 11; + z.exp = 1 - shiftCount; + z.sig = sig< -#include "platform.h" -#include "primitives.h" -#include "internals.h" - -struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t sig ) -{ - int shiftCount; - struct exp16_sig64 z; - - shiftCount = softfloat_countLeadingZeros64( sig ) - 11; - z.exp = 1 - shiftCount; - z.sig = sig< +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float32_t + softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig ) +{ + int roundingMode; + bool roundNearestEven; + int roundIncrement, roundBits; + bool isTiny; + uint_fast32_t uiZ; + union ui32_f32 uZ; + + roundingMode = softfloat_roundingMode; + roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); + roundIncrement = 0x40; + if ( + ! roundNearestEven + && ( roundingMode != softfloat_round_nearest_maxMag ) + ) { + roundIncrement = + ( roundingMode == softfloat_round_minMag ) + || ( roundingMode + == ( sign ? softfloat_round_max : softfloat_round_min ) ) + ? 0 + : 0x7F; + } + roundBits = sig & 0x7F; + if ( 0xFD <= (uint16_t) exp ) { + if ( exp < 0 ) { + isTiny = + ( softfloat_detectTininess + == softfloat_tininess_beforeRounding ) + || ( exp < -1 ) + || ( sig + roundIncrement < 0x80000000 ); + sig = softfloat_shift32RightJam( sig, - exp ); + exp = 0; + roundBits = sig & 0x7F; + if ( isTiny && roundBits ) { + softfloat_raiseFlags( softfloat_flag_underflow ); + } + } else if ( + ( 0xFD < exp ) || ( 0x80000000 <= sig + roundIncrement ) + ) { + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement; + goto uiZ; + } + } + if ( roundBits ) softfloat_exceptionFlags |= softfloat_flag_inexact; + sig = ( sig + roundIncrement )>>7; + sig &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven ); + uiZ = packToF32UI( sign, sig ? exp : 0, sig ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/s_roundPackToF32.cc b/softfloat/s_roundPackToF32.cc deleted file mode 100755 index 11764f1..0000000 --- a/softfloat/s_roundPackToF32.cc +++ /dev/null @@ -1,65 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float32_t - softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig ) -{ - int roundingMode; - bool roundNearestEven; - int roundIncrement, roundBits; - bool isTiny; - uint_fast32_t uiZ; - union ui32_f32 uZ; - - roundingMode = softfloat_roundingMode; - roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); - roundIncrement = 0x40; - if ( - ! roundNearestEven - && ( roundingMode != softfloat_round_nearest_maxMag ) - ) { - roundIncrement = - ( roundingMode == softfloat_round_minMag ) - || ( roundingMode - == ( sign ? softfloat_round_max : softfloat_round_min ) ) - ? 0 - : 0x7F; - } - roundBits = sig & 0x7F; - if ( 0xFD <= (uint16_t) exp ) { - if ( exp < 0 ) { - isTiny = - ( softfloat_detectTininess - == softfloat_tininess_beforeRounding ) - || ( exp < -1 ) - || ( sig + roundIncrement < 0x80000000 ); - sig = softfloat_shift32RightJam( sig, - exp ); - exp = 0; - roundBits = sig & 0x7F; - if ( isTiny && roundBits ) { - softfloat_raiseFlags( softfloat_flag_underflow ); - } - } else if ( - ( 0xFD < exp ) || ( 0x80000000 <= sig + roundIncrement ) - ) { - softfloat_raiseFlags( - softfloat_flag_overflow | softfloat_flag_inexact ); - uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement; - goto uiZ; - } - } - if ( roundBits ) softfloat_exceptionFlags |= softfloat_flag_inexact; - sig = ( sig + roundIncrement )>>7; - sig &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven ); - uiZ = packToF32UI( sign, sig ? exp : 0, sig ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/s_roundPackToF64.c b/softfloat/s_roundPackToF64.c new file mode 100755 index 0000000..fb0ef1d --- /dev/null +++ b/softfloat/s_roundPackToF64.c @@ -0,0 +1,66 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float64_t + softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig ) +{ + int roundingMode; + bool roundNearestEven; + int roundIncrement, roundBits; + bool isTiny; + uint_fast64_t uiZ; + union ui64_f64 uZ; + + roundingMode = softfloat_roundingMode; + roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); + roundIncrement = 0x200; + if ( + ! roundNearestEven + && ( roundingMode != softfloat_round_nearest_maxMag ) + ) { + roundIncrement = + ( roundingMode == softfloat_round_minMag ) + || ( roundingMode + == ( sign ? softfloat_round_max : softfloat_round_min ) ) + ? 0 + : 0x3FF; + } + roundBits = sig & 0x3FF; + if ( 0x7FD <= (uint16_t) exp ) { + if ( exp < 0 ) { + isTiny = + ( softfloat_detectTininess + == softfloat_tininess_beforeRounding ) + || ( exp < -1 ) + || ( sig + roundIncrement < UINT64_C( 0x8000000000000000 ) ); + sig = softfloat_shift64RightJam( sig, - exp ); + exp = 0; + roundBits = sig & 0x3FF; + if ( isTiny && roundBits ) { + softfloat_raiseFlags( softfloat_flag_underflow ); + } + } else if ( + ( 0x7FD < exp ) + || ( UINT64_C( 0x8000000000000000 ) <= sig + roundIncrement ) + ) { + softfloat_raiseFlags( + softfloat_flag_overflow | softfloat_flag_inexact ); + uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement; + goto uiZ; + } + } + if ( roundBits ) softfloat_exceptionFlags |= softfloat_flag_inexact; + sig = ( sig + roundIncrement )>>10; + sig &= ~ ( ! ( roundBits ^ 0x200 ) & roundNearestEven ); + uiZ = packToF64UI( sign, sig ? exp : 0, sig ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/s_roundPackToF64.cc b/softfloat/s_roundPackToF64.cc deleted file mode 100755 index fb0ef1d..0000000 --- a/softfloat/s_roundPackToF64.cc +++ /dev/null @@ -1,66 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float64_t - softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig ) -{ - int roundingMode; - bool roundNearestEven; - int roundIncrement, roundBits; - bool isTiny; - uint_fast64_t uiZ; - union ui64_f64 uZ; - - roundingMode = softfloat_roundingMode; - roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); - roundIncrement = 0x200; - if ( - ! roundNearestEven - && ( roundingMode != softfloat_round_nearest_maxMag ) - ) { - roundIncrement = - ( roundingMode == softfloat_round_minMag ) - || ( roundingMode - == ( sign ? softfloat_round_max : softfloat_round_min ) ) - ? 0 - : 0x3FF; - } - roundBits = sig & 0x3FF; - if ( 0x7FD <= (uint16_t) exp ) { - if ( exp < 0 ) { - isTiny = - ( softfloat_detectTininess - == softfloat_tininess_beforeRounding ) - || ( exp < -1 ) - || ( sig + roundIncrement < UINT64_C( 0x8000000000000000 ) ); - sig = softfloat_shift64RightJam( sig, - exp ); - exp = 0; - roundBits = sig & 0x3FF; - if ( isTiny && roundBits ) { - softfloat_raiseFlags( softfloat_flag_underflow ); - } - } else if ( - ( 0x7FD < exp ) - || ( UINT64_C( 0x8000000000000000 ) <= sig + roundIncrement ) - ) { - softfloat_raiseFlags( - softfloat_flag_overflow | softfloat_flag_inexact ); - uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement; - goto uiZ; - } - } - if ( roundBits ) softfloat_exceptionFlags |= softfloat_flag_inexact; - sig = ( sig + roundIncrement )>>10; - sig &= ~ ( ! ( roundBits ^ 0x200 ) & roundNearestEven ); - uiZ = packToF64UI( sign, sig ? exp : 0, sig ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/s_roundPackToI32.c b/softfloat/s_roundPackToI32.c new file mode 100755 index 0000000..1c91497 --- /dev/null +++ b/softfloat/s_roundPackToI32.c @@ -0,0 +1,48 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +int_fast32_t + softfloat_roundPackToI32( + bool sign, uint_fast64_t sig, int_fast8_t roundingMode, bool exact ) +{ + bool roundNearestEven; + int roundIncrement, roundBits; + uint_fast32_t sig32; + union { uint32_t ui; int32_t i; } uZ; + int_fast32_t z; + + roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); + roundIncrement = 0x40; + if ( + ! roundNearestEven + && ( roundingMode != softfloat_round_nearest_maxMag ) + ) { + roundIncrement = + ( roundingMode == softfloat_round_minMag ) + || ( roundingMode + == ( sign ? softfloat_round_max : softfloat_round_min ) ) + ? 0 + : 0x7F; + } + roundBits = sig & 0x7F; + sig += roundIncrement; + if ( sig & UINT64_C( 0xFFFFFF8000000000 ) ) goto invalid; + sig32 = sig>>7; + sig32 &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven ); + uZ.ui = sign ? - sig32 : sig32; + z = uZ.i; + if ( z && ( ( z < 0 ) ^ sign ) ) goto invalid; + if ( exact && roundBits ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return sign ? -0x7FFFFFFF - 1 : 0x7FFFFFFF; + +} + diff --git a/softfloat/s_roundPackToI32.cc b/softfloat/s_roundPackToI32.cc deleted file mode 100755 index 1c91497..0000000 --- a/softfloat/s_roundPackToI32.cc +++ /dev/null @@ -1,48 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -int_fast32_t - softfloat_roundPackToI32( - bool sign, uint_fast64_t sig, int_fast8_t roundingMode, bool exact ) -{ - bool roundNearestEven; - int roundIncrement, roundBits; - uint_fast32_t sig32; - union { uint32_t ui; int32_t i; } uZ; - int_fast32_t z; - - roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); - roundIncrement = 0x40; - if ( - ! roundNearestEven - && ( roundingMode != softfloat_round_nearest_maxMag ) - ) { - roundIncrement = - ( roundingMode == softfloat_round_minMag ) - || ( roundingMode - == ( sign ? softfloat_round_max : softfloat_round_min ) ) - ? 0 - : 0x7F; - } - roundBits = sig & 0x7F; - sig += roundIncrement; - if ( sig & UINT64_C( 0xFFFFFF8000000000 ) ) goto invalid; - sig32 = sig>>7; - sig32 &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven ); - uZ.ui = sign ? - sig32 : sig32; - z = uZ.i; - if ( z && ( ( z < 0 ) ^ sign ) ) goto invalid; - if ( exact && roundBits ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return z; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - return sign ? -0x7FFFFFFF - 1 : 0x7FFFFFFF; - -} - diff --git a/softfloat/s_roundPackToI64.c b/softfloat/s_roundPackToI64.c new file mode 100755 index 0000000..b2f5d63 --- /dev/null +++ b/softfloat/s_roundPackToI64.c @@ -0,0 +1,52 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +int_fast64_t + softfloat_roundPackToI64( + bool sign, + uint_fast64_t sig64, + uint_fast64_t sig0, + int_fast8_t roundingMode, + bool exact + ) +{ + bool roundNearestEven, increment; + union { uint64_t ui; int64_t i; } uZ; + int_fast64_t z; + + roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); + increment = ( UINT64_C( 0x8000000000000000 ) <= sig0 ); + if ( + ! roundNearestEven + && ( roundingMode != softfloat_round_nearest_maxMag ) + ) { + increment = + ( roundingMode != softfloat_round_minMag ) + && ( roundingMode + == ( sign ? softfloat_round_min : softfloat_round_max ) ) + && sig0; + } + if ( increment ) { + ++sig64; + if ( ! sig64 ) goto invalid; + sig64 &= + ~ ( ! ( sig0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) + & roundNearestEven ); + } + uZ.ui = sign ? - sig64 : sig64; + z = uZ.i; + if ( z && ( ( z < 0 ) ^ sign ) ) goto invalid; + if ( exact && sig0 ) softfloat_exceptionFlags |= softfloat_flag_inexact; + return z; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return + sign ? - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1 + : INT64_C( 0x7FFFFFFFFFFFFFFF ); + +} + diff --git a/softfloat/s_roundPackToI64.cc b/softfloat/s_roundPackToI64.cc deleted file mode 100755 index b2f5d63..0000000 --- a/softfloat/s_roundPackToI64.cc +++ /dev/null @@ -1,52 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -int_fast64_t - softfloat_roundPackToI64( - bool sign, - uint_fast64_t sig64, - uint_fast64_t sig0, - int_fast8_t roundingMode, - bool exact - ) -{ - bool roundNearestEven, increment; - union { uint64_t ui; int64_t i; } uZ; - int_fast64_t z; - - roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); - increment = ( UINT64_C( 0x8000000000000000 ) <= sig0 ); - if ( - ! roundNearestEven - && ( roundingMode != softfloat_round_nearest_maxMag ) - ) { - increment = - ( roundingMode != softfloat_round_minMag ) - && ( roundingMode - == ( sign ? softfloat_round_min : softfloat_round_max ) ) - && sig0; - } - if ( increment ) { - ++sig64; - if ( ! sig64 ) goto invalid; - sig64 &= - ~ ( ! ( sig0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) - & roundNearestEven ); - } - uZ.ui = sign ? - sig64 : sig64; - z = uZ.i; - if ( z && ( ( z < 0 ) ^ sign ) ) goto invalid; - if ( exact && sig0 ) softfloat_exceptionFlags |= softfloat_flag_inexact; - return z; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - return - sign ? - INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1 - : INT64_C( 0x7FFFFFFFFFFFFFFF ); - -} - diff --git a/softfloat/s_roundPackToUI32.c b/softfloat/s_roundPackToUI32.c new file mode 100755 index 0000000..ab44ec7 --- /dev/null +++ b/softfloat/s_roundPackToUI32.c @@ -0,0 +1,44 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast32_t + softfloat_roundPackToUI32( + bool sign, uint_fast64_t sig, int_fast8_t roundingMode, bool exact ) +{ + bool roundNearestEven; + int roundIncrement, roundBits; + uint_fast32_t z; + + roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); + roundIncrement = 0x40; + if ( + ! roundNearestEven + && ( roundingMode != softfloat_round_nearest_maxMag ) + ) { + roundIncrement = + ( roundingMode == softfloat_round_minMag ) + || ( roundingMode + == ( sign ? softfloat_round_max : softfloat_round_min ) ) + ? 0 + : 0x7F; + } + roundBits = sig & 0x7F; + sig += roundIncrement; + if ( sig & UINT64_C( 0xFFFFFF8000000000 ) ) goto invalid; + z = sig>>7; + z &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven ); + if ( sign && z ) goto invalid; + if ( exact && roundBits ) { + softfloat_exceptionFlags |= softfloat_flag_inexact; + } + return z; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return 0xFFFFFFFF; + +} + diff --git a/softfloat/s_roundPackToUI32.cc b/softfloat/s_roundPackToUI32.cc deleted file mode 100755 index ab44ec7..0000000 --- a/softfloat/s_roundPackToUI32.cc +++ /dev/null @@ -1,44 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast32_t - softfloat_roundPackToUI32( - bool sign, uint_fast64_t sig, int_fast8_t roundingMode, bool exact ) -{ - bool roundNearestEven; - int roundIncrement, roundBits; - uint_fast32_t z; - - roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); - roundIncrement = 0x40; - if ( - ! roundNearestEven - && ( roundingMode != softfloat_round_nearest_maxMag ) - ) { - roundIncrement = - ( roundingMode == softfloat_round_minMag ) - || ( roundingMode - == ( sign ? softfloat_round_max : softfloat_round_min ) ) - ? 0 - : 0x7F; - } - roundBits = sig & 0x7F; - sig += roundIncrement; - if ( sig & UINT64_C( 0xFFFFFF8000000000 ) ) goto invalid; - z = sig>>7; - z &= ~ ( ! ( roundBits ^ 0x40 ) & roundNearestEven ); - if ( sign && z ) goto invalid; - if ( exact && roundBits ) { - softfloat_exceptionFlags |= softfloat_flag_inexact; - } - return z; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - return 0xFFFFFFFF; - -} - diff --git a/softfloat/s_roundPackToUI64.c b/softfloat/s_roundPackToUI64.c new file mode 100755 index 0000000..d42266f --- /dev/null +++ b/softfloat/s_roundPackToUI64.c @@ -0,0 +1,46 @@ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "softfloat.h" + +uint_fast64_t + softfloat_roundPackToUI64( + bool sign, + uint_fast64_t sig64, + uint_fast64_t sig0, + int_fast8_t roundingMode, + bool exact + ) +{ + bool roundNearestEven, increment; + + roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); + increment = ( UINT64_C( 0x8000000000000000 ) <= sig0 ); + if ( + ! roundNearestEven + && ( roundingMode != softfloat_round_nearest_maxMag ) + ) { + increment = + ( roundingMode != softfloat_round_minMag ) + && ( roundingMode + == ( sign ? softfloat_round_min : softfloat_round_max ) ) + && sig0; + } + if ( increment ) { + ++sig64; + if ( ! sig64 ) goto invalid; + sig64 &= + ~ ( ! ( sig0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) + & roundNearestEven ); + } + if ( sign && sig64 ) goto invalid; + if ( exact && sig0 ) softfloat_exceptionFlags |= softfloat_flag_inexact; + return sig64; + invalid: + softfloat_raiseFlags( softfloat_flag_invalid ); + return UINT64_C( 0xFFFFFFFFFFFFFFFF ); + +} + diff --git a/softfloat/s_roundPackToUI64.cc b/softfloat/s_roundPackToUI64.cc deleted file mode 100755 index d42266f..0000000 --- a/softfloat/s_roundPackToUI64.cc +++ /dev/null @@ -1,46 +0,0 @@ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "softfloat.h" - -uint_fast64_t - softfloat_roundPackToUI64( - bool sign, - uint_fast64_t sig64, - uint_fast64_t sig0, - int_fast8_t roundingMode, - bool exact - ) -{ - bool roundNearestEven, increment; - - roundNearestEven = ( roundingMode == softfloat_round_nearest_even ); - increment = ( UINT64_C( 0x8000000000000000 ) <= sig0 ); - if ( - ! roundNearestEven - && ( roundingMode != softfloat_round_nearest_maxMag ) - ) { - increment = - ( roundingMode != softfloat_round_minMag ) - && ( roundingMode - == ( sign ? softfloat_round_min : softfloat_round_max ) ) - && sig0; - } - if ( increment ) { - ++sig64; - if ( ! sig64 ) goto invalid; - sig64 &= - ~ ( ! ( sig0 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) - & roundNearestEven ); - } - if ( sign && sig64 ) goto invalid; - if ( exact && sig0 ) softfloat_exceptionFlags |= softfloat_flag_inexact; - return sig64; - invalid: - softfloat_raiseFlags( softfloat_flag_invalid ); - return UINT64_C( 0xFFFFFFFFFFFFFFFF ); - -} - diff --git a/softfloat/s_shift128ExtraRightJam.c b/softfloat/s_shift128ExtraRightJam.c new file mode 100755 index 0000000..6c57974 --- /dev/null +++ b/softfloat/s_shift128ExtraRightJam.c @@ -0,0 +1,38 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint128_extra + softfloat_shift128ExtraRightJam( + uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count ) +{ + unsigned int negCount; + struct uint128_extra z; + + negCount = - count; + if ( count < 64 ) { + z.v64 = a64>>count; + z.v0 = a64<<( negCount & 63 ) | a0>>count; + z.extra = a0<<( negCount & 63 ); + } else { + z.v64 = 0; + if ( count == 64 ) { + z.v0 = a64; + z.extra = a0; + } else { + extra |= a0; + if ( count < 128 ) { + z.v0 = a64>>( count & 63 ); + z.extra = a64<<( negCount & 63 ); + } else { + z.v0 = 0; + z.extra = ( count == 128 ) ? a64 : ( a64 != 0 ); + } + } + } + z.extra |= ( extra != 0 ); + return z; + +} + diff --git a/softfloat/s_shift128ExtraRightJam.cc b/softfloat/s_shift128ExtraRightJam.cc deleted file mode 100755 index 6c57974..0000000 --- a/softfloat/s_shift128ExtraRightJam.cc +++ /dev/null @@ -1,38 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint128_extra - softfloat_shift128ExtraRightJam( - uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count ) -{ - unsigned int negCount; - struct uint128_extra z; - - negCount = - count; - if ( count < 64 ) { - z.v64 = a64>>count; - z.v0 = a64<<( negCount & 63 ) | a0>>count; - z.extra = a0<<( negCount & 63 ); - } else { - z.v64 = 0; - if ( count == 64 ) { - z.v0 = a64; - z.extra = a0; - } else { - extra |= a0; - if ( count < 128 ) { - z.v0 = a64>>( count & 63 ); - z.extra = a64<<( negCount & 63 ); - } else { - z.v0 = 0; - z.extra = ( count == 128 ) ? a64 : ( a64 != 0 ); - } - } - } - z.extra |= ( extra != 0 ); - return z; - -} - diff --git a/softfloat/s_shift128RightJam.c b/softfloat/s_shift128RightJam.c new file mode 100755 index 0000000..5a4e188 --- /dev/null +++ b/softfloat/s_shift128RightJam.c @@ -0,0 +1,31 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint128 + softfloat_shift128RightJam( uint64_t a64, uint64_t a0, unsigned int count ) +{ + unsigned int negCount; + struct uint128 z; + + if ( count < 64 ) { + negCount = - count; + z.v64 = a64>>( count & 63 ); + z.v0 = + a64<<( negCount & 63 ) | a0>>count + | ( (uint64_t) ( a0<<( negCount & 63 ) ) != 0 ); + } else { + z.v64 = 0; + z.v0 = + ( count < 128 ) + ? a64>>( count & 63 ) + | ( ( ( a64 & ( ( (uint64_t) 1<<( count & 63 ) ) - 1 ) ) + | a0 ) + != 0 ) + : ( ( a64 | a0 ) != 0 ); + } + return z; + +} + diff --git a/softfloat/s_shift128RightJam.cc b/softfloat/s_shift128RightJam.cc deleted file mode 100755 index 5a4e188..0000000 --- a/softfloat/s_shift128RightJam.cc +++ /dev/null @@ -1,31 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint128 - softfloat_shift128RightJam( uint64_t a64, uint64_t a0, unsigned int count ) -{ - unsigned int negCount; - struct uint128 z; - - if ( count < 64 ) { - negCount = - count; - z.v64 = a64>>( count & 63 ); - z.v0 = - a64<<( negCount & 63 ) | a0>>count - | ( (uint64_t) ( a0<<( negCount & 63 ) ) != 0 ); - } else { - z.v64 = 0; - z.v0 = - ( count < 128 ) - ? a64>>( count & 63 ) - | ( ( ( a64 & ( ( (uint64_t) 1<<( count & 63 ) ) - 1 ) ) - | a0 ) - != 0 ) - : ( ( a64 | a0 ) != 0 ); - } - return z; - -} - diff --git a/softfloat/s_shift32RightJam.c b/softfloat/s_shift32RightJam.c new file mode 100755 index 0000000..b697a34 --- /dev/null +++ b/softfloat/s_shift32RightJam.c @@ -0,0 +1,15 @@ + +#include +#include "platform.h" +#include "primitives.h" + +uint32_t softfloat_shift32RightJam( uint32_t a, unsigned int count ) +{ + + return + ( count < 32 ) + ? a>>count | ( (uint32_t) ( a<<( ( - count ) & 31 ) ) != 0 ) + : ( a != 0 ); + +} + diff --git a/softfloat/s_shift32RightJam.cc b/softfloat/s_shift32RightJam.cc deleted file mode 100755 index b697a34..0000000 --- a/softfloat/s_shift32RightJam.cc +++ /dev/null @@ -1,15 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -uint32_t softfloat_shift32RightJam( uint32_t a, unsigned int count ) -{ - - return - ( count < 32 ) - ? a>>count | ( (uint32_t) ( a<<( ( - count ) & 31 ) ) != 0 ) - : ( a != 0 ); - -} - diff --git a/softfloat/s_shift64ExtraRightJam.c b/softfloat/s_shift64ExtraRightJam.c new file mode 100755 index 0000000..167ea54 --- /dev/null +++ b/softfloat/s_shift64ExtraRightJam.c @@ -0,0 +1,23 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint64_extra + softfloat_shift64ExtraRightJam( + uint64_t a, uint64_t extra, unsigned int count ) +{ + struct uint64_extra z; + + if ( count < 64 ) { + z.v = a>>count; + z.extra = a<<( ( - count ) & 63 ); + } else { + z.v = 0; + z.extra = ( count == 64 ) ? a : ( a != 0 ); + } + z.extra |= ( extra != 0 ); + return z; + +} + diff --git a/softfloat/s_shift64ExtraRightJam.cc b/softfloat/s_shift64ExtraRightJam.cc deleted file mode 100755 index 167ea54..0000000 --- a/softfloat/s_shift64ExtraRightJam.cc +++ /dev/null @@ -1,23 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint64_extra - softfloat_shift64ExtraRightJam( - uint64_t a, uint64_t extra, unsigned int count ) -{ - struct uint64_extra z; - - if ( count < 64 ) { - z.v = a>>count; - z.extra = a<<( ( - count ) & 63 ); - } else { - z.v = 0; - z.extra = ( count == 64 ) ? a : ( a != 0 ); - } - z.extra |= ( extra != 0 ); - return z; - -} - diff --git a/softfloat/s_shift64RightJam.c b/softfloat/s_shift64RightJam.c new file mode 100755 index 0000000..ebebb61 --- /dev/null +++ b/softfloat/s_shift64RightJam.c @@ -0,0 +1,15 @@ + +#include +#include "platform.h" +#include "primitives.h" + +uint64_t softfloat_shift64RightJam( uint64_t a, unsigned int count ) +{ + + return + ( count < 64 ) + ? a>>count | ( (uint64_t) ( a<<( ( - count ) & 63 ) ) != 0 ) + : ( a != 0 ); + +} + diff --git a/softfloat/s_shift64RightJam.cc b/softfloat/s_shift64RightJam.cc deleted file mode 100755 index ebebb61..0000000 --- a/softfloat/s_shift64RightJam.cc +++ /dev/null @@ -1,15 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -uint64_t softfloat_shift64RightJam( uint64_t a, unsigned int count ) -{ - - return - ( count < 64 ) - ? a>>count | ( (uint64_t) ( a<<( ( - count ) & 63 ) ) != 0 ) - : ( a != 0 ); - -} - diff --git a/softfloat/s_shortShift128ExtraRightJam.c b/softfloat/s_shortShift128ExtraRightJam.c new file mode 100755 index 0000000..c772740 --- /dev/null +++ b/softfloat/s_shortShift128ExtraRightJam.c @@ -0,0 +1,20 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint128_extra + softfloat_shortShift128ExtraRightJam( + uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count ) +{ + unsigned int negCount; + struct uint128_extra z; + + negCount = - count; + z.v64 = a64>>count; + z.v0 = a64<<( negCount & 63 ) | a0>>count; + z.extra = a0<<( negCount & 63 ) | ( extra != 0 ); + return z; + +} + diff --git a/softfloat/s_shortShift128ExtraRightJam.cc b/softfloat/s_shortShift128ExtraRightJam.cc deleted file mode 100755 index c772740..0000000 --- a/softfloat/s_shortShift128ExtraRightJam.cc +++ /dev/null @@ -1,20 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint128_extra - softfloat_shortShift128ExtraRightJam( - uint64_t a64, uint64_t a0, uint64_t extra, unsigned int count ) -{ - unsigned int negCount; - struct uint128_extra z; - - negCount = - count; - z.v64 = a64>>count; - z.v0 = a64<<( negCount & 63 ) | a0>>count; - z.extra = a0<<( negCount & 63 ) | ( extra != 0 ); - return z; - -} - diff --git a/softfloat/s_shortShift128Left.c b/softfloat/s_shortShift128Left.c new file mode 100755 index 0000000..9c29988 --- /dev/null +++ b/softfloat/s_shortShift128Left.c @@ -0,0 +1,16 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint128 + softfloat_shortShift128Left( uint64_t a64, uint64_t a0, unsigned int count ) +{ + struct uint128 z; + + z.v64 = a64<>( ( - count ) & 63 ); + z.v0 = a0< -#include "platform.h" -#include "primitives.h" - -struct uint128 - softfloat_shortShift128Left( uint64_t a64, uint64_t a0, unsigned int count ) -{ - struct uint128 z; - - z.v64 = a64<>( ( - count ) & 63 ); - z.v0 = a0< +#include "platform.h" +#include "primitives.h" + +struct uint128 + softfloat_shortShift128Right( uint64_t a64, uint64_t a0, unsigned int count ) +{ + struct uint128 z; + + z.v64 = a64>>count; + z.v0 = a64<<( ( - count ) & 63 ) | a0>>count; + return z; + +} + diff --git a/softfloat/s_shortShift128Right.cc b/softfloat/s_shortShift128Right.cc deleted file mode 100755 index f7f4ce8..0000000 --- a/softfloat/s_shortShift128Right.cc +++ /dev/null @@ -1,16 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint128 - softfloat_shortShift128Right( uint64_t a64, uint64_t a0, unsigned int count ) -{ - struct uint128 z; - - z.v64 = a64>>count; - z.v0 = a64<<( ( - count ) & 63 ) | a0>>count; - return z; - -} - diff --git a/softfloat/s_shortShift192Left.c b/softfloat/s_shortShift192Left.c new file mode 100755 index 0000000..cf1e55d --- /dev/null +++ b/softfloat/s_shortShift192Left.c @@ -0,0 +1,20 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint192 + softfloat_shortShift192Left( + uint64_t a128, uint64_t a64, uint64_t a0, unsigned int count ) +{ + unsigned int negCount; + struct uint192 z; + + negCount = - count; + z.v128 = a128<>( negCount & 63 ); + z.v64 = a64<>( negCount & 63 ); + z.v0 = a0< -#include "platform.h" -#include "primitives.h" - -struct uint192 - softfloat_shortShift192Left( - uint64_t a128, uint64_t a64, uint64_t a0, unsigned int count ) -{ - unsigned int negCount; - struct uint192 z; - - negCount = - count; - z.v128 = a128<>( negCount & 63 ); - z.v64 = a64<>( negCount & 63 ); - z.v0 = a0< +#include "platform.h" +#include "primitives.h" + +uint32_t softfloat_shortShift32Right1Jam( uint32_t a ) +{ + + return a>>1 | ( a & 1 ); + +} + diff --git a/softfloat/s_shortShift32Right1Jam.cc b/softfloat/s_shortShift32Right1Jam.cc deleted file mode 100755 index db4c304..0000000 --- a/softfloat/s_shortShift32Right1Jam.cc +++ /dev/null @@ -1,12 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -uint32_t softfloat_shortShift32Right1Jam( uint32_t a ) -{ - - return a>>1 | ( a & 1 ); - -} - diff --git a/softfloat/s_shortShift64ExtraRightJam.c b/softfloat/s_shortShift64ExtraRightJam.c new file mode 100755 index 0000000..b861c67 --- /dev/null +++ b/softfloat/s_shortShift64ExtraRightJam.c @@ -0,0 +1,17 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint64_extra + softfloat_shortShift64ExtraRightJam( + uint64_t a, uint64_t extra, unsigned int count ) +{ + struct uint64_extra z; + + z.v = a>>count; + z.extra = a<<( ( - count ) & 63 ) | ( extra != 0 ); + return z; + +} + diff --git a/softfloat/s_shortShift64ExtraRightJam.cc b/softfloat/s_shortShift64ExtraRightJam.cc deleted file mode 100755 index b861c67..0000000 --- a/softfloat/s_shortShift64ExtraRightJam.cc +++ /dev/null @@ -1,17 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint64_extra - softfloat_shortShift64ExtraRightJam( - uint64_t a, uint64_t extra, unsigned int count ) -{ - struct uint64_extra z; - - z.v = a>>count; - z.extra = a<<( ( - count ) & 63 ) | ( extra != 0 ); - return z; - -} - diff --git a/softfloat/s_shortShift64RightJam.c b/softfloat/s_shortShift64RightJam.c new file mode 100755 index 0000000..0da6c93 --- /dev/null +++ b/softfloat/s_shortShift64RightJam.c @@ -0,0 +1,12 @@ + +#include +#include "platform.h" +#include "primitives.h" + +uint64_t softfloat_shortShift64RightJam( uint64_t a, unsigned int count ) +{ + + return a>>count | ( ( a & ( ( (uint64_t) 1< -#include "platform.h" -#include "primitives.h" - -uint64_t softfloat_shortShift64RightJam( uint64_t a, unsigned int count ) -{ - - return a>>count | ( ( a & ( ( (uint64_t) 1< +#include "platform.h" +#include "primitives.h" + +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; + z.v64 -= ( a0 < b0 ); + return z; + +} + diff --git a/softfloat/s_sub128.cc b/softfloat/s_sub128.cc deleted file mode 100755 index 0c4f181..0000000 --- a/softfloat/s_sub128.cc +++ /dev/null @@ -1,17 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -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; - z.v64 -= ( a0 < b0 ); - return z; - -} - diff --git a/softfloat/s_sub192.c b/softfloat/s_sub192.c new file mode 100755 index 0000000..96f21c9 --- /dev/null +++ b/softfloat/s_sub192.c @@ -0,0 +1,30 @@ + +#include +#include "platform.h" +#include "primitives.h" + +struct uint192 + softfloat_sub192( + uint64_t a128, + uint64_t a64, + uint64_t a0, + uint64_t b128, + uint64_t b64, + uint64_t b0 + ) +{ + struct uint192 z; + unsigned int borrow64, borrow128; + + z.v0 = a0 - b0; + borrow64 = ( a0 < b0 ); + z.v64 = a64 - b64; + borrow128 = ( a64 < b64 ); + z.v128 = a128 - b128; + borrow128 += ( z.v64 < borrow64 ); + z.v64 -= borrow64; + z.v128 -= borrow128; + return z; + +} + diff --git a/softfloat/s_sub192.cc b/softfloat/s_sub192.cc deleted file mode 100755 index 96f21c9..0000000 --- a/softfloat/s_sub192.cc +++ /dev/null @@ -1,30 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" - -struct uint192 - softfloat_sub192( - uint64_t a128, - uint64_t a64, - uint64_t a0, - uint64_t b128, - uint64_t b64, - uint64_t b0 - ) -{ - struct uint192 z; - unsigned int borrow64, borrow128; - - z.v0 = a0 - b0; - borrow64 = ( a0 < b0 ); - z.v64 = a64 - b64; - borrow128 = ( a64 < b64 ); - z.v128 = a128 - b128; - borrow128 += ( z.v64 < borrow64 ); - z.v64 -= borrow64; - z.v128 -= borrow128; - return z; - -} - diff --git a/softfloat/s_subMagsF32.c b/softfloat/s_subMagsF32.c new file mode 100755 index 0000000..0c83b02 --- /dev/null +++ b/softfloat/s_subMagsF32.c @@ -0,0 +1,81 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float32_t + softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB, bool signZ ) +{ + int_fast16_t expA; + uint_fast32_t sigA; + int_fast16_t expB; + uint_fast32_t sigB; + int_fast16_t expDiff; + uint_fast32_t uiZ; + int_fast16_t expZ; + uint_fast32_t sigZ; + union ui32_f32 uZ; + + expA = expF32UI( uiA ); + sigA = fracF32UI( uiA ); + expB = expF32UI( uiB ); + sigB = fracF32UI( uiB ); + expDiff = expA - expB; + sigA <<= 7; + sigB <<= 7; + if ( 0 < expDiff ) goto expABigger; + if ( expDiff < 0 ) goto expBBigger; + if ( expA == 0xFF ) { + if ( sigA | sigB ) goto propagateNaN; + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF32UI; + goto uiZ; + } + if ( ! expA ) { + expA = 1; + expB = 1; + } + if ( sigB < sigA ) goto aBigger; + if ( sigA < sigB ) goto bBigger; + uiZ = packToF32UI( softfloat_roundingMode == softfloat_round_min, 0, 0 ); + goto uiZ; + expBBigger: + if ( expB == 0xFF ) { + if ( sigB ) goto propagateNaN; + uiZ = packToF32UI( signZ ^ 1, 0xFF, 0 ); + goto uiZ; + } + sigA += expA ? 0x40000000 : sigA; + sigA = softfloat_shift32RightJam( sigA, - expDiff ); + sigB |= 0x40000000; + bBigger: + signZ ^= 1; + expZ = expB; + sigZ = sigB - sigA; + goto normRoundPack; + expABigger: + if ( expA == 0xFF ) { + if ( sigA ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + sigB += expB ? 0x40000000 : sigB; + sigB = softfloat_shift32RightJam( sigB, expDiff ); + sigA |= 0x40000000; + aBigger: + expZ = expA; + sigZ = sigA - sigB; + normRoundPack: + return softfloat_normRoundPackToF32( signZ, expZ - 1, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/s_subMagsF32.cc b/softfloat/s_subMagsF32.cc deleted file mode 100755 index 0c83b02..0000000 --- a/softfloat/s_subMagsF32.cc +++ /dev/null @@ -1,81 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float32_t - softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB, bool signZ ) -{ - int_fast16_t expA; - uint_fast32_t sigA; - int_fast16_t expB; - uint_fast32_t sigB; - int_fast16_t expDiff; - uint_fast32_t uiZ; - int_fast16_t expZ; - uint_fast32_t sigZ; - union ui32_f32 uZ; - - expA = expF32UI( uiA ); - sigA = fracF32UI( uiA ); - expB = expF32UI( uiB ); - sigB = fracF32UI( uiB ); - expDiff = expA - expB; - sigA <<= 7; - sigB <<= 7; - if ( 0 < expDiff ) goto expABigger; - if ( expDiff < 0 ) goto expBBigger; - if ( expA == 0xFF ) { - if ( sigA | sigB ) goto propagateNaN; - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF32UI; - goto uiZ; - } - if ( ! expA ) { - expA = 1; - expB = 1; - } - if ( sigB < sigA ) goto aBigger; - if ( sigA < sigB ) goto bBigger; - uiZ = packToF32UI( softfloat_roundingMode == softfloat_round_min, 0, 0 ); - goto uiZ; - expBBigger: - if ( expB == 0xFF ) { - if ( sigB ) goto propagateNaN; - uiZ = packToF32UI( signZ ^ 1, 0xFF, 0 ); - goto uiZ; - } - sigA += expA ? 0x40000000 : sigA; - sigA = softfloat_shift32RightJam( sigA, - expDiff ); - sigB |= 0x40000000; - bBigger: - signZ ^= 1; - expZ = expB; - sigZ = sigB - sigA; - goto normRoundPack; - expABigger: - if ( expA == 0xFF ) { - if ( sigA ) goto propagateNaN; - uiZ = uiA; - goto uiZ; - } - sigB += expB ? 0x40000000 : sigB; - sigB = softfloat_shift32RightJam( sigB, expDiff ); - sigA |= 0x40000000; - aBigger: - expZ = expA; - sigZ = sigA - sigB; - normRoundPack: - return softfloat_normRoundPackToF32( signZ, expZ - 1, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF32UI( uiA, uiB ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/s_subMagsF64.c b/softfloat/s_subMagsF64.c new file mode 100755 index 0000000..45b81ba --- /dev/null +++ b/softfloat/s_subMagsF64.c @@ -0,0 +1,81 @@ + +#include +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +float64_t + softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ ) +{ + int_fast16_t expA; + uint_fast64_t sigA; + int_fast16_t expB; + uint_fast64_t sigB; + int_fast16_t expDiff; + uint_fast64_t uiZ; + int_fast16_t expZ; + uint_fast64_t sigZ; + union ui64_f64 uZ; + + expA = expF64UI( uiA ); + sigA = fracF64UI( uiA ); + expB = expF64UI( uiB ); + sigB = fracF64UI( uiB ); + expDiff = expA - expB; + sigA <<= 10; + sigB <<= 10; + if ( 0 < expDiff ) goto expABigger; + if ( expDiff < 0 ) goto expBBigger; + if ( expA == 0x7FF ) { + if ( sigA | sigB ) goto propagateNaN; + softfloat_raiseFlags( softfloat_flag_invalid ); + uiZ = defaultNaNF64UI; + goto uiZ; + } + if ( ! expA ) { + expA = 1; + expB = 1; + } + if ( sigB < sigA ) goto aBigger; + if ( sigA < sigB ) goto bBigger; + uiZ = packToF64UI( softfloat_roundingMode == softfloat_round_min, 0, 0 ); + goto uiZ; + expBBigger: + if ( expB == 0x7FF ) { + if ( sigB ) goto propagateNaN; + uiZ = packToF64UI( signZ ^ 1, 0x7FF, 0 ); + goto uiZ; + } + sigA += expA ? UINT64_C( 0x4000000000000000 ) : sigA; + sigA = softfloat_shift64RightJam( sigA, - expDiff ); + sigB |= UINT64_C( 0x4000000000000000 ); + bBigger: + signZ ^= 1; + expZ = expB; + sigZ = sigB - sigA; + goto normRoundPack; + expABigger: + if ( expA == 0x7FF ) { + if ( sigA ) goto propagateNaN; + uiZ = uiA; + goto uiZ; + } + sigB += expB ? UINT64_C( 0x4000000000000000 ) : sigB; + sigB = softfloat_shift64RightJam( sigB, expDiff ); + sigA |= UINT64_C( 0x4000000000000000 ); + aBigger: + expZ = expA; + sigZ = sigA - sigB; + normRoundPack: + return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ ); + propagateNaN: + uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); + uiZ: + uZ.ui = uiZ; + return uZ.f; + +} + diff --git a/softfloat/s_subMagsF64.cc b/softfloat/s_subMagsF64.cc deleted file mode 100755 index 45b81ba..0000000 --- a/softfloat/s_subMagsF64.cc +++ /dev/null @@ -1,81 +0,0 @@ - -#include -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -float64_t - softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ ) -{ - int_fast16_t expA; - uint_fast64_t sigA; - int_fast16_t expB; - uint_fast64_t sigB; - int_fast16_t expDiff; - uint_fast64_t uiZ; - int_fast16_t expZ; - uint_fast64_t sigZ; - union ui64_f64 uZ; - - expA = expF64UI( uiA ); - sigA = fracF64UI( uiA ); - expB = expF64UI( uiB ); - sigB = fracF64UI( uiB ); - expDiff = expA - expB; - sigA <<= 10; - sigB <<= 10; - if ( 0 < expDiff ) goto expABigger; - if ( expDiff < 0 ) goto expBBigger; - if ( expA == 0x7FF ) { - if ( sigA | sigB ) goto propagateNaN; - softfloat_raiseFlags( softfloat_flag_invalid ); - uiZ = defaultNaNF64UI; - goto uiZ; - } - if ( ! expA ) { - expA = 1; - expB = 1; - } - if ( sigB < sigA ) goto aBigger; - if ( sigA < sigB ) goto bBigger; - uiZ = packToF64UI( softfloat_roundingMode == softfloat_round_min, 0, 0 ); - goto uiZ; - expBBigger: - if ( expB == 0x7FF ) { - if ( sigB ) goto propagateNaN; - uiZ = packToF64UI( signZ ^ 1, 0x7FF, 0 ); - goto uiZ; - } - sigA += expA ? UINT64_C( 0x4000000000000000 ) : sigA; - sigA = softfloat_shift64RightJam( sigA, - expDiff ); - sigB |= UINT64_C( 0x4000000000000000 ); - bBigger: - signZ ^= 1; - expZ = expB; - sigZ = sigB - sigA; - goto normRoundPack; - expABigger: - if ( expA == 0x7FF ) { - if ( sigA ) goto propagateNaN; - uiZ = uiA; - goto uiZ; - } - sigB += expB ? UINT64_C( 0x4000000000000000 ) : sigB; - sigB = softfloat_shift64RightJam( sigB, expDiff ); - sigA |= UINT64_C( 0x4000000000000000 ); - aBigger: - expZ = expA; - sigZ = sigA - sigB; - normRoundPack: - return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ ); - propagateNaN: - uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); - uiZ: - uZ.ui = uiZ; - return uZ.f; - -} - diff --git a/softfloat/softfloat.h b/softfloat/softfloat.h index a7ea248..3eddeed 100755 --- a/softfloat/softfloat.h +++ b/softfloat/softfloat.h @@ -2,6 +2,10 @@ #ifndef softfloat_h #define softfloat_h +#ifdef __cplusplus +extern "C" { +#endif + /*** UPDATE COMMENTS. ***/ /*============================================================================ @@ -221,5 +225,9 @@ bool f128_le_quiet( float128_t, float128_t ); bool f128_lt_quiet( float128_t, float128_t ); bool f128_isSignalingNaN( float128_t ); +#ifdef __cplusplus +} +#endif + #endif diff --git a/softfloat/softfloat.mk.in b/softfloat/softfloat.mk.in index 964bc47..59993cb 100644 --- a/softfloat/softfloat.mk.in +++ b/softfloat/softfloat.mk.in @@ -6,107 +6,107 @@ softfloat_hdrs = \ primitives.h \ softfloat.h \ -softfloat_srcs = \ - f32_add.cc \ - f32_div.cc \ - f32_eq.cc \ - f32_eq_signaling.cc \ - f32_isSignalingNaN.cc \ - f32_le.cc \ - f32_le_quiet.cc \ - f32_lt.cc \ - f32_lt_quiet.cc \ - f32_mulAdd.cc \ - f32_mul.cc \ - f32_rem.cc \ - f32_roundToInt.cc \ - f32_sqrt.cc \ - f32_sub.cc \ - f32_to_f64.cc \ - f32_to_i32.cc \ - f32_to_i32_r_minMag.cc \ - f32_to_i64.cc \ - f32_to_i64_r_minMag.cc \ - f32_to_ui32.cc \ - f32_to_ui32_r_minMag.cc \ - f32_to_ui64.cc \ - f32_to_ui64_r_minMag.cc \ - f64_add.cc \ - f64_div.cc \ - f64_eq.cc \ - f64_eq_signaling.cc \ - f64_isSignalingNaN.cc \ - f64_le.cc \ - f64_le_quiet.cc \ - f64_lt.cc \ - f64_lt_quiet.cc \ - f64_mulAdd.cc \ - f64_mul.cc \ - f64_rem.cc \ - f64_roundToInt.cc \ - f64_sqrt.cc \ - f64_sub.cc \ - f64_to_f32.cc \ - f64_to_i32.cc \ - f64_to_i32_r_minMag.cc \ - f64_to_i64.cc \ - f64_to_i64_r_minMag.cc \ - f64_to_ui32.cc \ - f64_to_ui32_r_minMag.cc \ - f64_to_ui64.cc \ - f64_to_ui64_r_minMag.cc \ - i32_to_f32.cc \ - i32_to_f64.cc \ - i64_to_f32.cc \ - i64_to_f64.cc \ - s_add128.cc \ - s_add192.cc \ - s_addMagsF32.cc \ - s_addMagsF64.cc \ - s_countLeadingZeros32.cc \ - s_countLeadingZeros64.cc \ - s_countLeadingZeros8.cc \ - s_eq128.cc \ - s_estimateDiv128To64.cc \ - s_estimateSqrt32.cc \ - s_le128.cc \ - s_lt128.cc \ - s_mul128By64To192.cc \ - s_mul128To256.cc \ - s_mul64To128.cc \ - s_mulAddF32.cc \ - s_mulAddF64.cc \ - s_normRoundPackToF32.cc \ - s_normRoundPackToF64.cc \ - s_normSubnormalF32Sig.cc \ - s_normSubnormalF64Sig.cc \ - softfloat_state.cc \ - s_roundPackToF32.cc \ - s_roundPackToF64.cc \ - s_roundPackToI32.cc \ - s_roundPackToI64.cc \ - s_roundPackToUI32.cc \ - s_roundPackToUI64.cc \ - s_shift128ExtraRightJam.cc \ - s_shift128RightJam.cc \ - s_shift32RightJam.cc \ - s_shift64ExtraRightJam.cc \ - s_shift64RightJam.cc \ - s_shortShift128ExtraRightJam.cc \ - s_shortShift128Left.cc \ - s_shortShift128Right.cc \ - s_shortShift192Left.cc \ - s_shortShift32Right1Jam.cc \ - s_shortShift64ExtraRightJam.cc \ - s_shortShift64RightJam.cc \ - s_sub128.cc \ - s_sub192.cc \ - s_subMagsF32.cc \ - s_subMagsF64.cc \ - ui32_to_f32.cc \ - ui32_to_f64.cc \ - ui64_to_f32.cc \ - ui64_to_f64.cc \ +softfloat_c_srcs = \ + f32_add.c \ + f32_div.c \ + f32_eq.c \ + f32_eq_signaling.c \ + f32_isSignalingNaN.c \ + f32_le.c \ + f32_le_quiet.c \ + f32_lt.c \ + f32_lt_quiet.c \ + f32_mulAdd.c \ + f32_mul.c \ + f32_rem.c \ + f32_roundToInt.c \ + f32_sqrt.c \ + f32_sub.c \ + f32_to_f64.c \ + f32_to_i32.c \ + f32_to_i32_r_minMag.c \ + f32_to_i64.c \ + f32_to_i64_r_minMag.c \ + f32_to_ui32.c \ + f32_to_ui32_r_minMag.c \ + f32_to_ui64.c \ + f32_to_ui64_r_minMag.c \ + f64_add.c \ + f64_div.c \ + f64_eq.c \ + f64_eq_signaling.c \ + f64_isSignalingNaN.c \ + f64_le.c \ + f64_le_quiet.c \ + f64_lt.c \ + f64_lt_quiet.c \ + f64_mulAdd.c \ + f64_mul.c \ + f64_rem.c \ + f64_roundToInt.c \ + f64_sqrt.c \ + f64_sub.c \ + f64_to_f32.c \ + f64_to_i32.c \ + f64_to_i32_r_minMag.c \ + f64_to_i64.c \ + f64_to_i64_r_minMag.c \ + f64_to_ui32.c \ + f64_to_ui32_r_minMag.c \ + f64_to_ui64.c \ + f64_to_ui64_r_minMag.c \ + i32_to_f32.c \ + i32_to_f64.c \ + i64_to_f32.c \ + i64_to_f64.c \ + s_add128.c \ + s_add192.c \ + s_addMagsF32.c \ + s_addMagsF64.c \ + s_countLeadingZeros32.c \ + s_countLeadingZeros64.c \ + s_countLeadingZeros8.c \ + s_eq128.c \ + s_estimateDiv128To64.c \ + s_estimateSqrt32.c \ + s_le128.c \ + s_lt128.c \ + s_mul128By64To192.c \ + s_mul128To256.c \ + s_mul64To128.c \ + s_mulAddF32.c \ + s_mulAddF64.c \ + s_normRoundPackToF32.c \ + s_normRoundPackToF64.c \ + s_normSubnormalF32Sig.c \ + s_normSubnormalF64Sig.c \ + softfloat_state.c \ + s_roundPackToF32.c \ + s_roundPackToF64.c \ + s_roundPackToI32.c \ + s_roundPackToI64.c \ + s_roundPackToUI32.c \ + s_roundPackToUI64.c \ + s_shift128ExtraRightJam.c \ + s_shift128RightJam.c \ + s_shift32RightJam.c \ + s_shift64ExtraRightJam.c \ + s_shift64RightJam.c \ + s_shortShift128ExtraRightJam.c \ + s_shortShift128Left.c \ + s_shortShift128Right.c \ + s_shortShift192Left.c \ + s_shortShift32Right1Jam.c \ + s_shortShift64ExtraRightJam.c \ + s_shortShift64RightJam.c \ + s_sub128.c \ + s_sub192.c \ + s_subMagsF32.c \ + s_subMagsF64.c \ + ui32_to_f32.c \ + ui32_to_f64.c \ + ui64_to_f32.c \ + ui64_to_f64.c \ softfloat_test_srcs = diff --git a/softfloat/softfloat_state.c b/softfloat/softfloat_state.c new file mode 100755 index 0000000..8859089 --- /dev/null +++ b/softfloat/softfloat_state.c @@ -0,0 +1,19 @@ + +/*** COMMENTS. ***/ + +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Floating-point rounding mode, extended double-precision rounding precision, +| and exception flags. +*----------------------------------------------------------------------------*/ +int_fast8_t softfloat_roundingMode = softfloat_round_nearest_even; +int_fast8_t softfloat_detectTininess = init_detectTininess; +int_fast8_t softfloat_exceptionFlags = 0; + +int_fast8_t floatx80_roundingPrecision = 80; + diff --git a/softfloat/softfloat_state.cc b/softfloat/softfloat_state.cc deleted file mode 100755 index 8859089..0000000 --- a/softfloat/softfloat_state.cc +++ /dev/null @@ -1,19 +0,0 @@ - -/*** COMMENTS. ***/ - -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -/*---------------------------------------------------------------------------- -| Floating-point rounding mode, extended double-precision rounding precision, -| and exception flags. -*----------------------------------------------------------------------------*/ -int_fast8_t softfloat_roundingMode = softfloat_round_nearest_even; -int_fast8_t softfloat_detectTininess = init_detectTininess; -int_fast8_t softfloat_exceptionFlags = 0; - -int_fast8_t floatx80_roundingPrecision = 80; - diff --git a/softfloat/ui32_to_f32.c b/softfloat/ui32_to_f32.c new file mode 100755 index 0000000..ba0fc1a --- /dev/null +++ b/softfloat/ui32_to_f32.c @@ -0,0 +1,25 @@ + +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float32_t ui32_to_f32( uint_fast32_t a ) +{ + union ui32_f32 uZ; + + if ( ! a ) { + uZ.ui = 0; + return uZ.f; + } + if ( a & 0x80000000 ) { + return + softfloat_roundPackToF32( + 0, 0x9D, softfloat_shortShift32Right1Jam( a ) ); + } else { + return softfloat_normRoundPackToF32( 0, 0x9C, a ); + } + +} + diff --git a/softfloat/ui32_to_f32.cc b/softfloat/ui32_to_f32.cc deleted file mode 100755 index ba0fc1a..0000000 --- a/softfloat/ui32_to_f32.cc +++ /dev/null @@ -1,25 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float32_t ui32_to_f32( uint_fast32_t a ) -{ - union ui32_f32 uZ; - - if ( ! a ) { - uZ.ui = 0; - return uZ.f; - } - if ( a & 0x80000000 ) { - return - softfloat_roundPackToF32( - 0, 0x9D, softfloat_shortShift32Right1Jam( a ) ); - } else { - return softfloat_normRoundPackToF32( 0, 0x9C, a ); - } - -} - diff --git a/softfloat/ui32_to_f64.c b/softfloat/ui32_to_f64.c new file mode 100755 index 0000000..d0bd177 --- /dev/null +++ b/softfloat/ui32_to_f64.c @@ -0,0 +1,26 @@ + +#include +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float64_t ui32_to_f64( uint_fast32_t a ) +{ + uint_fast64_t uiZ; + int shiftCount; + union ui64_f64 uZ; + + if ( ! a ) { + uiZ = 0; + } else { + shiftCount = softfloat_countLeadingZeros32( a ) + 21; + uiZ = + packToF64UI( + 0, 0x432 - shiftCount, (uint_fast64_t) a< -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float64_t ui32_to_f64( uint_fast32_t a ) -{ - uint_fast64_t uiZ; - int shiftCount; - union ui64_f64 uZ; - - if ( ! a ) { - uiZ = 0; - } else { - shiftCount = softfloat_countLeadingZeros32( a ) + 21; - uiZ = - packToF64UI( - 0, 0x432 - shiftCount, (uint_fast64_t) a< +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float32_t ui64_to_f32( uint_fast64_t a ) +{ + int shiftCount; + union ui32_f32 u; + uint_fast32_t sig; + + shiftCount = softfloat_countLeadingZeros64( a ) - 40; + if ( 0 <= shiftCount ) { + u.ui = + a ? packToF32UI( + 0, 0x95 - shiftCount, (uint_fast32_t) a< -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float32_t ui64_to_f32( uint_fast64_t a ) -{ - int shiftCount; - union ui32_f32 u; - uint_fast32_t sig; - - shiftCount = softfloat_countLeadingZeros64( a ) - 40; - if ( 0 <= shiftCount ) { - u.ui = - a ? packToF32UI( - 0, 0x95 - shiftCount, (uint_fast32_t) a< +#include "platform.h" +#include "primitives.h" +#include "internals.h" +#include "softfloat.h" + +float64_t ui64_to_f64( uint_fast64_t a ) +{ + union ui64_f64 uZ; + + if ( ! a ) { + uZ.ui = 0; + return uZ.f; + } + if ( a & UINT64_C( 0x8000000000000000 ) ) { + return + softfloat_roundPackToF64( + 0, 0x43D, softfloat_shortShift64RightJam( a, 1 ) ); + } else { + return softfloat_normRoundPackToF64( 0, 0x43C, a ); + } + +} + diff --git a/softfloat/ui64_to_f64.cc b/softfloat/ui64_to_f64.cc deleted file mode 100755 index 52c158b..0000000 --- a/softfloat/ui64_to_f64.cc +++ /dev/null @@ -1,25 +0,0 @@ - -#include -#include "platform.h" -#include "primitives.h" -#include "internals.h" -#include "softfloat.h" - -float64_t ui64_to_f64( uint_fast64_t a ) -{ - union ui64_f64 uZ; - - if ( ! a ) { - uZ.ui = 0; - return uZ.f; - } - if ( a & UINT64_C( 0x8000000000000000 ) ) { - return - softfloat_roundPackToF64( - 0, 0x43D, softfloat_shortShift64RightJam( a, 1 ) ); - } else { - return softfloat_normRoundPackToF64( 0, 0x43C, a ); - } - -} - diff --git a/softfloat_riscv/s_commonNaNToF32UI.c b/softfloat_riscv/s_commonNaNToF32UI.c new file mode 100755 index 0000000..61f2735 --- /dev/null +++ b/softfloat_riscv/s_commonNaNToF32UI.c @@ -0,0 +1,17 @@ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Returns the result of converting the canonical NaN `a' to the single- +| precision floating-point format. +*----------------------------------------------------------------------------*/ + +uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a ) +{ + + return (uint_fast32_t) a.sign<<31 | 0x7FFFFFFF; + +} + diff --git a/softfloat_riscv/s_commonNaNToF32UI.cc b/softfloat_riscv/s_commonNaNToF32UI.cc deleted file mode 100755 index 61f2735..0000000 --- a/softfloat_riscv/s_commonNaNToF32UI.cc +++ /dev/null @@ -1,17 +0,0 @@ - -#include -#include "platform.h" -#include "specialize.h" - -/*---------------------------------------------------------------------------- -| Returns the result of converting the canonical NaN `a' to the single- -| precision floating-point format. -*----------------------------------------------------------------------------*/ - -uint_fast32_t softfloat_commonNaNToF32UI( struct commonNaN a ) -{ - - return (uint_fast32_t) a.sign<<31 | 0x7FFFFFFF; - -} - diff --git a/softfloat_riscv/s_commonNaNToF64UI.c b/softfloat_riscv/s_commonNaNToF64UI.c new file mode 100755 index 0000000..da36c04 --- /dev/null +++ b/softfloat_riscv/s_commonNaNToF64UI.c @@ -0,0 +1,18 @@ + +#include +#include "platform.h" +#include "specialize.h" + +/*---------------------------------------------------------------------------- +| Returns the result of converting the canonical NaN `a' to the double- +| precision floating-point format. +*----------------------------------------------------------------------------*/ + +uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN a ) +{ + + return + (uint_fast64_t) a.sign<<63 | UINT64_C( 0x7FFFFFFFFFFFFFFF ); + +} + diff --git a/softfloat_riscv/s_commonNaNToF64UI.cc b/softfloat_riscv/s_commonNaNToF64UI.cc deleted file mode 100755 index da36c04..0000000 --- a/softfloat_riscv/s_commonNaNToF64UI.cc +++ /dev/null @@ -1,18 +0,0 @@ - -#include -#include "platform.h" -#include "specialize.h" - -/*---------------------------------------------------------------------------- -| Returns the result of converting the canonical NaN `a' to the double- -| precision floating-point format. -*----------------------------------------------------------------------------*/ - -uint_fast64_t softfloat_commonNaNToF64UI( struct commonNaN a ) -{ - - return - (uint_fast64_t) a.sign<<63 | UINT64_C( 0x7FFFFFFFFFFFFFFF ); - -} - diff --git a/softfloat_riscv/s_f32UIToCommonNaN.c b/softfloat_riscv/s_f32UIToCommonNaN.c new file mode 100755 index 0000000..9ee0db9 --- /dev/null +++ b/softfloat_riscv/s_f32UIToCommonNaN.c @@ -0,0 +1,25 @@ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Returns the result of converting the single-precision floating-point NaN +| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t uiA ) +{ + struct commonNaN z; + + if ( softfloat_isSigNaNF32UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + z.sign = uiA>>31; + z.v64 = (uint_fast64_t) 0x7FFFF <<41; + z.v0 = 0; + return z; + +} + diff --git a/softfloat_riscv/s_f32UIToCommonNaN.cc b/softfloat_riscv/s_f32UIToCommonNaN.cc deleted file mode 100755 index 9ee0db9..0000000 --- a/softfloat_riscv/s_f32UIToCommonNaN.cc +++ /dev/null @@ -1,25 +0,0 @@ - -#include -#include "platform.h" -#include "specialize.h" -#include "softfloat.h" - -/*---------------------------------------------------------------------------- -| Returns the result of converting the single-precision floating-point NaN -| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid -| exception is raised. -*----------------------------------------------------------------------------*/ -struct commonNaN softfloat_f32UIToCommonNaN( uint_fast32_t uiA ) -{ - struct commonNaN z; - - if ( softfloat_isSigNaNF32UI( uiA ) ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - z.sign = uiA>>31; - z.v64 = (uint_fast64_t) 0x7FFFF <<41; - z.v0 = 0; - return z; - -} - diff --git a/softfloat_riscv/s_f64UIToCommonNaN.c b/softfloat_riscv/s_f64UIToCommonNaN.c new file mode 100755 index 0000000..84d8ca0 --- /dev/null +++ b/softfloat_riscv/s_f64UIToCommonNaN.c @@ -0,0 +1,25 @@ + +#include +#include "platform.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Returns the result of converting the double-precision floating-point NaN +| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid +| exception is raised. +*----------------------------------------------------------------------------*/ +struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t uiA ) +{ + struct commonNaN z; + + if ( softfloat_isSigNaNF64UI( uiA ) ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + z.sign = uiA>>63; + z.v64 = (uint_fast64_t) 0xFFFFFFFFFFFFF <<12; + z.v0 = 0; + return z; + +} + diff --git a/softfloat_riscv/s_f64UIToCommonNaN.cc b/softfloat_riscv/s_f64UIToCommonNaN.cc deleted file mode 100755 index 84d8ca0..0000000 --- a/softfloat_riscv/s_f64UIToCommonNaN.cc +++ /dev/null @@ -1,25 +0,0 @@ - -#include -#include "platform.h" -#include "specialize.h" -#include "softfloat.h" - -/*---------------------------------------------------------------------------- -| Returns the result of converting the double-precision floating-point NaN -| `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid -| exception is raised. -*----------------------------------------------------------------------------*/ -struct commonNaN softfloat_f64UIToCommonNaN( uint_fast64_t uiA ) -{ - struct commonNaN z; - - if ( softfloat_isSigNaNF64UI( uiA ) ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - z.sign = uiA>>63; - z.v64 = (uint_fast64_t) 0xFFFFFFFFFFFFF <<12; - z.v0 = 0; - return z; - -} - diff --git a/softfloat_riscv/s_isSigNaNF32UI.c b/softfloat_riscv/s_isSigNaNF32UI.c new file mode 100755 index 0000000..0a9c33f --- /dev/null +++ b/softfloat_riscv/s_isSigNaNF32UI.c @@ -0,0 +1,13 @@ + +#include +#include +#include "platform.h" +#include "specialize.h" + +bool softfloat_isSigNaNF32UI( uint_fast32_t ui ) +{ + + return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF ); + +} + diff --git a/softfloat_riscv/s_isSigNaNF32UI.cc b/softfloat_riscv/s_isSigNaNF32UI.cc deleted file mode 100755 index 0a9c33f..0000000 --- a/softfloat_riscv/s_isSigNaNF32UI.cc +++ /dev/null @@ -1,13 +0,0 @@ - -#include -#include -#include "platform.h" -#include "specialize.h" - -bool softfloat_isSigNaNF32UI( uint_fast32_t ui ) -{ - - return ( ( ui>>22 & 0x1FF ) == 0x1FE ) && ( ui & 0x003FFFFF ); - -} - diff --git a/softfloat_riscv/s_isSigNaNF64UI.c b/softfloat_riscv/s_isSigNaNF64UI.c new file mode 100755 index 0000000..d255213 --- /dev/null +++ b/softfloat_riscv/s_isSigNaNF64UI.c @@ -0,0 +1,15 @@ + +#include +#include +#include "platform.h" +#include "specialize.h" + +bool softfloat_isSigNaNF64UI( uint_fast64_t ui ) +{ + + return + ( ( ui>>51 & 0xFFF ) == 0xFFE ) + && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) ); + +} + diff --git a/softfloat_riscv/s_isSigNaNF64UI.cc b/softfloat_riscv/s_isSigNaNF64UI.cc deleted file mode 100755 index d255213..0000000 --- a/softfloat_riscv/s_isSigNaNF64UI.cc +++ /dev/null @@ -1,15 +0,0 @@ - -#include -#include -#include "platform.h" -#include "specialize.h" - -bool softfloat_isSigNaNF64UI( uint_fast64_t ui ) -{ - - return - ( ( ui>>51 & 0xFFF ) == 0xFFE ) - && ( ui & UINT64_C( 0x0007FFFFFFFFFFFF ) ); - -} - diff --git a/softfloat_riscv/s_propagateNaNF32UI.c b/softfloat_riscv/s_propagateNaNF32UI.c new file mode 100755 index 0000000..07774e8 --- /dev/null +++ b/softfloat_riscv/s_propagateNaNF32UI.c @@ -0,0 +1,55 @@ + +/*** UPDATE COMMENTS. ***/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Takes two single-precision floating-point values `a' and `b', one of which +| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ + +uint_fast32_t + softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ) +{ + bool isNaNA, isSigNaNA, isNaNB, isSigNaNB; + uint_fast32_t uiMagA, uiMagB; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isNaNA = isNaNF32UI( uiA ); + isSigNaNA = softfloat_isSigNaNF32UI( uiA ); + isNaNB = isNaNF32UI( uiB ); + isSigNaNB = softfloat_isSigNaNF32UI( uiB ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiA |= 0x00400000; + uiB |= 0x00400000; + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerSignificand; + return isNaNB ? uiB : uiA; + } else if ( isNaNA ) { + if ( isSigNaNB || ! isNaNB ) return uiA; + returnLargerSignificand: + uiMagA = uiA<<1; + uiMagB = uiB<<1; + if ( uiMagA < uiMagB ) return uiB; + if ( uiMagB < uiMagA ) return uiA; + return ( uiA < uiB ) ? uiA : uiB; + } else { + return uiB; + } + +} + diff --git a/softfloat_riscv/s_propagateNaNF32UI.cc b/softfloat_riscv/s_propagateNaNF32UI.cc deleted file mode 100755 index 07774e8..0000000 --- a/softfloat_riscv/s_propagateNaNF32UI.cc +++ /dev/null @@ -1,55 +0,0 @@ - -/*** UPDATE COMMENTS. ***/ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -/*---------------------------------------------------------------------------- -| Takes two single-precision floating-point values `a' and `b', one of which -| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a -| signaling NaN, the invalid exception is raised. -*----------------------------------------------------------------------------*/ - -uint_fast32_t - softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB ) -{ - bool isNaNA, isSigNaNA, isNaNB, isSigNaNB; - uint_fast32_t uiMagA, uiMagB; - - /*------------------------------------------------------------------------ - *------------------------------------------------------------------------*/ - isNaNA = isNaNF32UI( uiA ); - isSigNaNA = softfloat_isSigNaNF32UI( uiA ); - isNaNB = isNaNF32UI( uiB ); - isSigNaNB = softfloat_isSigNaNF32UI( uiB ); - /*------------------------------------------------------------------------ - | Make NaNs non-signaling. - *------------------------------------------------------------------------*/ - uiA |= 0x00400000; - uiB |= 0x00400000; - /*------------------------------------------------------------------------ - *------------------------------------------------------------------------*/ - if ( isSigNaNA | isSigNaNB ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - if ( isSigNaNA ) { - if ( isSigNaNB ) goto returnLargerSignificand; - return isNaNB ? uiB : uiA; - } else if ( isNaNA ) { - if ( isSigNaNB || ! isNaNB ) return uiA; - returnLargerSignificand: - uiMagA = uiA<<1; - uiMagB = uiB<<1; - if ( uiMagA < uiMagB ) return uiB; - if ( uiMagB < uiMagA ) return uiA; - return ( uiA < uiB ) ? uiA : uiB; - } else { - return uiB; - } - -} - diff --git a/softfloat_riscv/s_propagateNaNF64UI.c b/softfloat_riscv/s_propagateNaNF64UI.c new file mode 100755 index 0000000..0ff6446 --- /dev/null +++ b/softfloat_riscv/s_propagateNaNF64UI.c @@ -0,0 +1,55 @@ + +/*** UPDATE COMMENTS. ***/ + +#include +#include +#include "platform.h" +#include "internals.h" +#include "specialize.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Takes two double-precision floating-point values `a' and `b', one of which +| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a +| signaling NaN, the invalid exception is raised. +*----------------------------------------------------------------------------*/ + +uint_fast64_t + softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ) +{ + bool isNaNA, isSigNaNA, isNaNB, isSigNaNB; + uint_fast64_t uiMagA, uiMagB; + + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + isNaNA = isNaNF64UI( uiA ); + isSigNaNA = softfloat_isSigNaNF64UI( uiA ); + isNaNB = isNaNF64UI( uiB ); + isSigNaNB = softfloat_isSigNaNF64UI( uiB ); + /*------------------------------------------------------------------------ + | Make NaNs non-signaling. + *------------------------------------------------------------------------*/ + uiA |= UINT64_C( 0x0008000000000000 ); + uiB |= UINT64_C( 0x0008000000000000 ); + /*------------------------------------------------------------------------ + *------------------------------------------------------------------------*/ + if ( isSigNaNA | isSigNaNB ) { + softfloat_raiseFlags( softfloat_flag_invalid ); + } + if ( isSigNaNA ) { + if ( isSigNaNB ) goto returnLargerSignificand; + return isNaNB ? uiB : uiA; + } else if ( isNaNA ) { + if ( isSigNaNB || ! isNaNB ) return uiA; + returnLargerSignificand: + uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF ); + if ( uiMagA < uiMagB ) return uiB; + if ( uiMagB < uiMagA ) return uiA; + return ( uiA < uiB ) ? uiA : uiB; + } else { + return uiB; + } + +} + diff --git a/softfloat_riscv/s_propagateNaNF64UI.cc b/softfloat_riscv/s_propagateNaNF64UI.cc deleted file mode 100755 index 0ff6446..0000000 --- a/softfloat_riscv/s_propagateNaNF64UI.cc +++ /dev/null @@ -1,55 +0,0 @@ - -/*** UPDATE COMMENTS. ***/ - -#include -#include -#include "platform.h" -#include "internals.h" -#include "specialize.h" -#include "softfloat.h" - -/*---------------------------------------------------------------------------- -| Takes two double-precision floating-point values `a' and `b', one of which -| is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a -| signaling NaN, the invalid exception is raised. -*----------------------------------------------------------------------------*/ - -uint_fast64_t - softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB ) -{ - bool isNaNA, isSigNaNA, isNaNB, isSigNaNB; - uint_fast64_t uiMagA, uiMagB; - - /*------------------------------------------------------------------------ - *------------------------------------------------------------------------*/ - isNaNA = isNaNF64UI( uiA ); - isSigNaNA = softfloat_isSigNaNF64UI( uiA ); - isNaNB = isNaNF64UI( uiB ); - isSigNaNB = softfloat_isSigNaNF64UI( uiB ); - /*------------------------------------------------------------------------ - | Make NaNs non-signaling. - *------------------------------------------------------------------------*/ - uiA |= UINT64_C( 0x0008000000000000 ); - uiB |= UINT64_C( 0x0008000000000000 ); - /*------------------------------------------------------------------------ - *------------------------------------------------------------------------*/ - if ( isSigNaNA | isSigNaNB ) { - softfloat_raiseFlags( softfloat_flag_invalid ); - } - if ( isSigNaNA ) { - if ( isSigNaNB ) goto returnLargerSignificand; - return isNaNB ? uiB : uiA; - } else if ( isNaNA ) { - if ( isSigNaNB || ! isNaNB ) return uiA; - returnLargerSignificand: - uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF ); - uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF ); - if ( uiMagA < uiMagB ) return uiB; - if ( uiMagB < uiMagA ) return uiA; - return ( uiA < uiB ) ? uiA : uiB; - } else { - return uiB; - } - -} - diff --git a/softfloat_riscv/softfloat_raiseFlags.c b/softfloat_riscv/softfloat_raiseFlags.c new file mode 100755 index 0000000..c0c0dc8 --- /dev/null +++ b/softfloat_riscv/softfloat_raiseFlags.c @@ -0,0 +1,51 @@ + +/*============================================================================ + +*** FIX. + +This C source fragment is part of the SoftFloat IEC/IEEE Floating-point +Arithmetic Package, Release 2b. + +Written by John R. Hauser. This work was made possible in part by the +International Computer Science Institute, located at Suite 600, 1947 Center +Street, Berkeley, California 94704. Funding was partially provided by the +National Science Foundation under grant MIP-9311980. The original version +of this code was written as part of a project to build a fixed-point vector +processor in collaboration with the University of California at Berkeley, +overseen by Profs. Nelson Morgan and John Wawrzynek. More information +is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ +arithmetic/SoftFloat.html'. + +THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has +been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES +RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS +AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, +COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE +EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE +INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR +OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. + +Derivative works are acceptable, even for commercial purposes, so long as +(1) the source code for the derivative work includes prominent notice that +the work is derivative, and (2) the source code includes prominent notice with +these four paragraphs for those parts of this code that are retained. + +=============================================================================*/ + +#include "platform.h" +#include "softfloat.h" + +/*---------------------------------------------------------------------------- +| Raises the exceptions specified by `flags'. Floating-point traps can be +| defined here if desired. It is currently not possible for such a trap +| to substitute a result value. If traps are not implemented, this routine +| should be simply `float_exception_flags |= flags;'. +*----------------------------------------------------------------------------*/ + +void softfloat_raiseFlags( int_fast8_t flags ) +{ + + softfloat_exceptionFlags |= flags; + +} + diff --git a/softfloat_riscv/softfloat_raiseFlags.cc b/softfloat_riscv/softfloat_raiseFlags.cc deleted file mode 100755 index c0c0dc8..0000000 --- a/softfloat_riscv/softfloat_raiseFlags.cc +++ /dev/null @@ -1,51 +0,0 @@ - -/*============================================================================ - -*** FIX. - -This C source fragment is part of the SoftFloat IEC/IEEE Floating-point -Arithmetic Package, Release 2b. - -Written by John R. Hauser. This work was made possible in part by the -International Computer Science Institute, located at Suite 600, 1947 Center -Street, Berkeley, California 94704. Funding was partially provided by the -National Science Foundation under grant MIP-9311980. The original version -of this code was written as part of a project to build a fixed-point vector -processor in collaboration with the University of California at Berkeley, -overseen by Profs. Nelson Morgan and John Wawrzynek. More information -is available through the Web page `http://www.cs.berkeley.edu/~jhauser/ -arithmetic/SoftFloat.html'. - -THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has -been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES -RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS -AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES, -COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE -EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE -INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR -OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE. - -Derivative works are acceptable, even for commercial purposes, so long as -(1) the source code for the derivative work includes prominent notice that -the work is derivative, and (2) the source code includes prominent notice with -these four paragraphs for those parts of this code that are retained. - -=============================================================================*/ - -#include "platform.h" -#include "softfloat.h" - -/*---------------------------------------------------------------------------- -| Raises the exceptions specified by `flags'. Floating-point traps can be -| defined here if desired. It is currently not possible for such a trap -| to substitute a result value. If traps are not implemented, this routine -| should be simply `float_exception_flags |= flags;'. -*----------------------------------------------------------------------------*/ - -void softfloat_raiseFlags( int_fast8_t flags ) -{ - - softfloat_exceptionFlags |= flags; - -} - diff --git a/softfloat_riscv/softfloat_riscv.mk.in b/softfloat_riscv/softfloat_riscv.mk.in index 0b996fb..0b898ed 100644 --- a/softfloat_riscv/softfloat_riscv.mk.in +++ b/softfloat_riscv/softfloat_riscv.mk.in @@ -5,16 +5,16 @@ softfloat_riscv_hdrs = \ platform.h \ specialize.h \ -softfloat_riscv_srcs = \ - softfloat_raiseFlags.cc \ - s_commonNaNToF32UI.cc \ - s_commonNaNToF64UI.cc \ - s_f32UIToCommonNaN.cc \ - s_f64UIToCommonNaN.cc \ - s_isSigNaNF32UI.cc \ - s_isSigNaNF64UI.cc \ - s_propagateNaNF32UI.cc \ - s_propagateNaNF64UI.cc \ +softfloat_riscv_c_srcs = \ + softfloat_raiseFlags.c \ + s_commonNaNToF32UI.c \ + s_commonNaNToF64UI.c \ + s_f32UIToCommonNaN.c \ + s_f64UIToCommonNaN.c \ + s_isSigNaNF32UI.c \ + s_isSigNaNF64UI.c \ + s_propagateNaNF32UI.c \ + s_propagateNaNF64UI.c \ softfloat_riscv_test_srcs = -- cgit v1.1