--- /dev/null
+/* Copyright (C) 2007, 2009 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+<http://www.gnu.org/licenses/>. */
+
+#include "bid_internal.h"
+
+#if DECIMAL_CALL_BY_REFERENCE
+void
+bid64dq_mul (UINT64 * pres, UINT64 * px, UINT128 * py
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+ UINT64 x = *px;
+#if !DECIMAL_GLOBAL_ROUNDING
+ unsigned int rnd_mode = *prnd_mode;
+#endif
+#else
+UINT64
+bid64dq_mul (UINT64 x, UINT128 y
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+#endif
+ UINT64 res = 0xbaddbaddbaddbaddull;
+ UINT128 x1;
+
+#if DECIMAL_CALL_BY_REFERENCE
+ bid64_to_bid128 (&x1, &x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid64qq_mul (&res, &x1, py
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#else
+ x1 = bid64_to_bid128 (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ res = bid64qq_mul (x1, y
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#endif
+ BID_RETURN (res);
+}
+
+
+#if DECIMAL_CALL_BY_REFERENCE
+void
+bid64qd_mul (UINT64 * pres, UINT128 * px, UINT64 * py
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+ UINT64 y = *py;
+#if !DECIMAL_GLOBAL_ROUNDING
+ unsigned int rnd_mode = *prnd_mode;
+#endif
+#else
+UINT64
+bid64qd_mul (UINT128 x, UINT64 y
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+#endif
+ UINT64 res = 0xbaddbaddbaddbaddull;
+ UINT128 y1;
+
+#if DECIMAL_CALL_BY_REFERENCE
+ bid64_to_bid128 (&y1, &y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid64qq_mul (&res, px, &y1
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#else
+ y1 = bid64_to_bid128 (y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ res = bid64qq_mul (x, y1
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#endif
+ BID_RETURN (res);
+}
+
+
+#if DECIMAL_CALL_BY_REFERENCE
+void
+bid64qq_mul (UINT64 * pres, UINT128 * px, UINT128 * py
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+ UINT128 x = *px, y = *py;
+#if !DECIMAL_GLOBAL_ROUNDING
+ unsigned int rnd_mode = *prnd_mode;
+#endif
+#else
+UINT64
+bid64qq_mul (UINT128 x, UINT128 y
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+#endif
+
+ UINT128 z = { {0x0000000000000000ull, 0x5ffe000000000000ull}
+ };
+ UINT64 res = 0xbaddbaddbaddbaddull;
+ UINT64 x_sign, y_sign, p_sign;
+ UINT64 x_exp, y_exp, p_exp;
+ int true_p_exp;
+ UINT128 C1, C2;
+
+ BID_SWAP128 (z);
+ // skip cases where at least one operand is NaN or infinity
+ if (!(((x.w[HIGH_128W] & MASK_NAN) == MASK_NAN) ||
+ ((y.w[HIGH_128W] & MASK_NAN) == MASK_NAN) ||
+ ((x.w[HIGH_128W] & MASK_ANY_INF) == MASK_INF) ||
+ ((y.w[HIGH_128W] & MASK_ANY_INF) == MASK_INF))) {
+ // x, y are 0 or f but not inf or NaN => unpack the arguments and check
+ // for non-canonical values
+
+ x_sign = x.w[HIGH_128W] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
+ C1.w[1] = x.w[HIGH_128W] & MASK_COEFF;
+ C1.w[0] = x.w[LOW_128W];
+ // check for non-canonical values - treated as zero
+ if ((x.w[HIGH_128W] & 0x6000000000000000ull) ==
+ 0x6000000000000000ull) {
+ // G0_G1=11 => non-canonical
+ x_exp = (x.w[HIGH_128W] << 2) & MASK_EXP; // biased and shifted left 49 bits
+ C1.w[1] = 0; // significand high
+ C1.w[0] = 0; // significand low
+ } else { // G0_G1 != 11
+ x_exp = x.w[HIGH_128W] & MASK_EXP; // biased and shifted left 49 bits
+ if (C1.w[1] > 0x0001ed09bead87c0ull ||
+ (C1.w[1] == 0x0001ed09bead87c0ull &&
+ C1.w[0] > 0x378d8e63ffffffffull)) {
+ // x is non-canonical if coefficient is larger than 10^34 -1
+ C1.w[1] = 0;
+ C1.w[0] = 0;
+ } else { // canonical
+ ;
+ }
+ }
+ y_sign = y.w[HIGH_128W] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
+ C2.w[1] = y.w[HIGH_128W] & MASK_COEFF;
+ C2.w[0] = y.w[LOW_128W];
+ // check for non-canonical values - treated as zero
+ if ((y.w[HIGH_128W] & 0x6000000000000000ull) ==
+ 0x6000000000000000ull) {
+ // G0_G1=11 => non-canonical
+ y_exp = (y.w[HIGH_128W] << 2) & MASK_EXP; // biased and shifted left 49 bits
+ C2.w[1] = 0; // significand high
+ C2.w[0] = 0; // significand low
+ } else { // G0_G1 != 11
+ y_exp = y.w[HIGH_128W] & MASK_EXP; // biased and shifted left 49 bits
+ if (C2.w[1] > 0x0001ed09bead87c0ull ||
+ (C2.w[1] == 0x0001ed09bead87c0ull &&
+ C2.w[0] > 0x378d8e63ffffffffull)) {
+ // y is non-canonical if coefficient is larger than 10^34 -1
+ C2.w[1] = 0;
+ C2.w[0] = 0;
+ } else { // canonical
+ ;
+ }
+ }
+ p_sign = x_sign ^ y_sign; // sign of the product
+
+ true_p_exp = (x_exp >> 49) - 6176 + (y_exp >> 49) - 6176;
+ // true_p_exp, p_exp are used only for 0 * 0, 0 * f, or f * 0
+ if (true_p_exp < -398)
+ p_exp = 0; // cannot be less than EXP_MIN
+ else if (true_p_exp > 369)
+ p_exp = (UINT64) (369 + 398) << 53; // cannot be more than EXP_MAX
+ else
+ p_exp = (UINT64) (true_p_exp + 398) << 53;
+
+ if ((C1.w[1] == 0x0 && C1.w[0] == 0x0) ||
+ (C2.w[1] == 0x0 && C2.w[0] == 0x0)) {
+ // x = 0 or y = 0
+ // the result is 0
+ res = p_sign | p_exp; // preferred exponent in [EXP_MIN, EXP_MAX]
+ BID_RETURN (res)
+ } // else continue
+ }
+ // swap x and y - ensure that a NaN in x has 'higher precedence' than one in y
+#if DECIMAL_CALL_BY_REFERENCE
+ bid64qqq_fma (&res, &y, &x, &z
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#else
+ res = bid64qqq_fma (y, x, z
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#endif
+ BID_RETURN (res);
+}
+
+
+#if DECIMAL_CALL_BY_REFERENCE
+void
+bid128dd_mul (UINT128 * pres, UINT64 * px, UINT64 * py
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+ UINT64 x = *px, y = *py;
+#if !DECIMAL_GLOBAL_ROUNDING
+ unsigned int rnd_mode = *prnd_mode;
+#endif
+#else
+UINT128
+bid128dd_mul (UINT64 x, UINT64 y
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+#endif
+ UINT128 res = { {0xbaddbaddbaddbaddull, 0xbaddbaddbaddbaddull}
+ };
+ UINT128 x1, y1;
+
+#if DECIMAL_CALL_BY_REFERENCE
+ bid64_to_bid128 (&x1, &x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid64_to_bid128 (&y1, &y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid128_mul (&res, &x1, &y1
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#else
+ x1 = bid64_to_bid128 (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ y1 = bid64_to_bid128 (y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ res = bid128_mul (x1, y1
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#endif
+ BID_RETURN (res);
+}
+
+
+#if DECIMAL_CALL_BY_REFERENCE
+void
+bid128dq_mul (UINT128 * pres, UINT64 * px, UINT128 * py
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+ UINT64 x = *px;
+#if !DECIMAL_GLOBAL_ROUNDING
+ unsigned int rnd_mode = *prnd_mode;
+#endif
+#else
+UINT128
+bid128dq_mul (UINT64 x, UINT128 y
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+#endif
+ UINT128 res = { {0xbaddbaddbaddbaddull, 0xbaddbaddbaddbaddull}
+ };
+ UINT128 x1;
+
+#if DECIMAL_CALL_BY_REFERENCE
+ bid64_to_bid128 (&x1, &x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid128_mul (&res, &x1, py
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#else
+ x1 = bid64_to_bid128 (x _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ res = bid128_mul (x1, y
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#endif
+ BID_RETURN (res);
+}
+
+
+#if DECIMAL_CALL_BY_REFERENCE
+void
+bid128qd_mul (UINT128 * pres, UINT128 * px, UINT64 * py
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+ UINT64 y = *py;
+#if !DECIMAL_GLOBAL_ROUNDING
+ unsigned int rnd_mode = *prnd_mode;
+#endif
+#else
+UINT128
+bid128qd_mul (UINT128 x, UINT64 y
+ _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+#endif
+ UINT128 res = { {0xbaddbaddbaddbaddull, 0xbaddbaddbaddbaddull}
+ };
+ UINT128 y1;
+
+#if DECIMAL_CALL_BY_REFERENCE
+ bid64_to_bid128 (&y1, &y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ bid128_mul (&res, px, &y1
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#else
+ y1 = bid64_to_bid128 (y _EXC_FLAGS_ARG _EXC_MASKS_ARG _EXC_INFO_ARG);
+ res = bid128_mul (x, y1
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#endif
+ BID_RETURN (res);
+}
+
+
+// bid128_mul stands for bid128qq_mul
+#if DECIMAL_CALL_BY_REFERENCE
+void
+bid128_mul (UINT128 * pres, UINT128 * px,
+ UINT128 *
+ py _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+ UINT128 x = *px, y = *py;
+
+#if !DECIMAL_GLOBAL_ROUNDING
+ unsigned int rnd_mode = *prnd_mode;
+
+#endif
+#else
+UINT128
+bid128_mul (UINT128 x,
+ UINT128 y _RND_MODE_PARAM _EXC_FLAGS_PARAM _EXC_MASKS_PARAM
+ _EXC_INFO_PARAM) {
+
+#endif
+ UINT128 z = { {0x0000000000000000ull, 0x5ffe000000000000ull}
+ };
+ UINT128 res = { {0xbaddbaddbaddbaddull, 0xbaddbaddbaddbaddull}
+ };
+ UINT64 x_sign, y_sign, p_sign;
+ UINT64 x_exp, y_exp, p_exp;
+ int true_p_exp;
+ UINT128 C1, C2;
+
+ BID_SWAP128 (x);
+ BID_SWAP128 (y);
+ // skip cases where at least one operand is NaN or infinity
+ if (!(((x.w[1] & MASK_NAN) == MASK_NAN) ||
+ ((y.w[1] & MASK_NAN) == MASK_NAN) ||
+ ((x.w[1] & MASK_ANY_INF) == MASK_INF) ||
+ ((y.w[1] & MASK_ANY_INF) == MASK_INF))) {
+ // x, y are 0 or f but not inf or NaN => unpack the arguments and check
+ // for non-canonical values
+
+ x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
+ C1.w[1] = x.w[1] & MASK_COEFF;
+ C1.w[0] = x.w[0];
+ // check for non-canonical values - treated as zero
+ if ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) {
+ // G0_G1=11 => non-canonical
+ x_exp = (x.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits
+ C1.w[1] = 0; // significand high
+ C1.w[0] = 0; // significand low
+ } else { // G0_G1 != 11
+ x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bits
+ if (C1.w[1] > 0x0001ed09bead87c0ull ||
+ (C1.w[1] == 0x0001ed09bead87c0ull &&
+ C1.w[0] > 0x378d8e63ffffffffull)) {
+ // x is non-canonical if coefficient is larger than 10^34 -1
+ C1.w[1] = 0;
+ C1.w[0] = 0;
+ } else { // canonical
+ ;
+ }
+ }
+ y_sign = y.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative
+ C2.w[1] = y.w[1] & MASK_COEFF;
+ C2.w[0] = y.w[0];
+ // check for non-canonical values - treated as zero
+ if ((y.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull) {
+ // G0_G1=11 => non-canonical
+ y_exp = (y.w[1] << 2) & MASK_EXP; // biased and shifted left 49 bits
+ C2.w[1] = 0; // significand high
+ C2.w[0] = 0; // significand low
+ } else { // G0_G1 != 11
+ y_exp = y.w[1] & MASK_EXP; // biased and shifted left 49 bits
+ if (C2.w[1] > 0x0001ed09bead87c0ull ||
+ (C2.w[1] == 0x0001ed09bead87c0ull &&
+ C2.w[0] > 0x378d8e63ffffffffull)) {
+ // y is non-canonical if coefficient is larger than 10^34 -1
+ C2.w[1] = 0;
+ C2.w[0] = 0;
+ } else { // canonical
+ ;
+ }
+ }
+ p_sign = x_sign ^ y_sign; // sign of the product
+
+ true_p_exp = (x_exp >> 49) - 6176 + (y_exp >> 49) - 6176;
+ // true_p_exp, p_exp are used only for 0 * 0, 0 * f, or f * 0
+ if (true_p_exp < -6176)
+ p_exp = 0; // cannot be less than EXP_MIN
+ else if (true_p_exp > 6111)
+ p_exp = (UINT64) (6111 + 6176) << 49; // cannot be more than EXP_MAX
+ else
+ p_exp = (UINT64) (true_p_exp + 6176) << 49;
+
+ if ((C1.w[1] == 0x0 && C1.w[0] == 0x0) ||
+ (C2.w[1] == 0x0 && C2.w[0] == 0x0)) {
+ // x = 0 or y = 0
+ // the result is 0
+ res.w[1] = p_sign | p_exp; // preferred exponent in [EXP_MIN, EXP_MAX]
+ res.w[0] = 0x0;
+ BID_SWAP128 (res);
+ BID_RETURN (res)
+ } // else continue
+ }
+
+ BID_SWAP128 (x);
+ BID_SWAP128 (y);
+ BID_SWAP128 (z);
+ // swap x and y - ensure that a NaN in x has 'higher precedence' than one in y
+#if DECIMAL_CALL_BY_REFERENCE
+ bid128_fma (&res, &y, &x, &z
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#else
+ res = bid128_fma (y, x, z
+ _RND_MODE_ARG _EXC_FLAGS_ARG _EXC_MASKS_ARG
+ _EXC_INFO_ARG);
+#endif
+ BID_RETURN (res);
+}
projects / msp430-gcc.git / blobdiff