From: Dhruv Chawla <[email protected]>
Signed-off-by: Dhruv Chawla <[email protected]>
libgcc/config/libbid/ChangeLog:
* bid128.c: Fix typos.
* bid128_compare.c (if): Likewise.
(__mul_64x128_to_192): Likewise.
(__mul_64x128_to192): Likewise.
* bid128_fma.c: Likewise.
* bid128_minmax.c (bid128_minnum): Likewise.
(bid128_maxnum): Likewise.
(bid128_maxnum_mag): Likewise.
* bid128_round_integral.c (if): Likewise.
* bid128_string.c (bid128_to_string): Likewise.
* bid64_compare.c (bid64_quiet_greater): Likewise.
(bid64_quiet_greater_equal): Likewise.
(bid64_quiet_greater_unordered): Likewise.
(bid64_quiet_less): Likewise.
(bid64_quiet_less_equal): Likewise.
(bid64_quiet_less_unordered): Likewise.
(bid64_quiet_not_greater): Likewise.
(bid64_quiet_not_less): Likewise.
(bid64_signaling_greater): Likewise.
(bid64_signaling_greater_equal): Likewise.
(bid64_signaling_greater_unordered): Likewise.
(bid64_signaling_less): Likewise.
(bid64_signaling_less_equal): Likewise.
(bid64_signaling_less_unordered): Likewise.
(bid64_signaling_not_greater): Likewise.
(bid64_signaling_not_less): Likewise.
* bid64_fma.c: Likewise.
* bid64_minmax.c (bid64_minnum): Likewise.
(bid64_maxnum): Likewise.
* bid64_noncomp.c (bid64_totalOrder): Likewise.
* bid64_string.c (bid64_to_string): Likewise.
* bid_binarydecimal.c (bid32_to_binary32): Likewise.
(bid32_to_binary64): Likewise.
(bid64_to_binary64): Likewise.
* bid_dpd.c (D61): Likewise.
* bid_flag_operations.c (restoreFlags): Likewise.
(saveFlags): Likewise.
* bid_from_int.c (bid64_from_int64): Likewise.
(bid64_from_uint64): Likewise.
* bid_gcc_intrinsics.h: Likewise.
* bid_internal.h (get_BID64_UF): Likewise.
(unpack_BID128_value): Likewise.
* bid_round.c (round64_2_18): Likewise.
(round128_19_38): Likewise.
(round192_39_57): Likewise.
(round256_58_76): Likewise.
---
libgcc/config/libbid/bid128.c | 4 +-
libgcc/config/libbid/bid128_compare.c | 128 +++++++++----------
libgcc/config/libbid/bid128_fma.c | 4 +-
libgcc/config/libbid/bid128_minmax.c | 24 ++--
libgcc/config/libbid/bid128_round_integral.c | 12 +-
libgcc/config/libbid/bid128_string.c | 2 +-
libgcc/config/libbid/bid64_compare.c | 40 +++---
libgcc/config/libbid/bid64_fma.c | 6 +-
libgcc/config/libbid/bid64_minmax.c | 8 +-
libgcc/config/libbid/bid64_noncomp.c | 2 +-
libgcc/config/libbid/bid64_string.c | 2 +-
libgcc/config/libbid/bid_binarydecimal.c | 6 +-
libgcc/config/libbid/bid_dpd.c | 2 +-
libgcc/config/libbid/bid_flag_operations.c | 8 +-
libgcc/config/libbid/bid_from_int.c | 4 +-
libgcc/config/libbid/bid_gcc_intrinsics.h | 2 +-
libgcc/config/libbid/bid_internal.h | 4 +-
libgcc/config/libbid/bid_round.c | 10 +-
18 files changed, 134 insertions(+), 134 deletions(-)
diff --git a/libgcc/config/libbid/bid128.c b/libgcc/config/libbid/bid128.c
index 0e53e409e55..35e07a40386 100644
--- a/libgcc/config/libbid/bid128.c
+++ b/libgcc/config/libbid/bid128.c
@@ -2662,7 +2662,7 @@ UINT64 mask64[] = {
0x00ffffffffffffffULL // mask / 2^64
};
-// Values of 10^(-x) trancated to Ex bits beyond the binary point, and
+// Values of 10^(-x) truncated to Ex bits beyond the binary point, and
// in the right position to be compared with the fraction from C * kx,
// 1 <= x <= 17; the fraction consists of the low Ex bits in C * kx
// (these values are aligned with the low 64 bits of the fraction)
@@ -2894,7 +2894,7 @@ UINT64 mask128[] = {
0x03ffffffffffffffULL // mask / 2^192
};
-// Values of 10^(-x) trancated to Ex bits beyond the binary point, and
+// Values of 10^(-x) truncated to Ex bits beyond the binary point, and
// in the right position to be compared with the fraction from C * kx,
// 1 <= x <= 37; the fraction consists of the low Ex bits in C * kx
// (these values are aligned with the low 128 bits of the fraction)
diff --git a/libgcc/config/libbid/bid128_compare.c
b/libgcc/config/libbid/bid128_compare.c
index 235c3d57fa5..3fd8b4dc1af 100644
--- a/libgcc/config/libbid/bid128_compare.c
+++ b/libgcc/config/libbid/bid128_compare.c
@@ -328,7 +328,7 @@ if (diff > 0) { // to simplify the loop below,
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -348,7 +348,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -377,7 +377,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -398,7 +398,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -577,7 +577,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -597,7 +597,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -627,7 +627,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -649,7 +649,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -828,7 +828,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -848,7 +848,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -878,7 +878,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -900,7 +900,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -1079,7 +1079,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -1099,7 +1099,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -1128,7 +1128,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -1150,7 +1150,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -1331,7 +1331,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -1351,7 +1351,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -1381,7 +1381,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -1403,7 +1403,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -1583,7 +1583,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -1603,7 +1603,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -1633,7 +1633,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -1655,7 +1655,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -1974,7 +1974,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -1994,7 +1994,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -2024,7 +2024,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -2046,7 +2046,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -2225,7 +2225,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -2245,7 +2245,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -2275,7 +2275,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -2297,7 +2297,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -2523,7 +2523,7 @@ if (diff > 0) { // to simplify the loop below,
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -2543,7 +2543,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -2572,7 +2572,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -2594,7 +2594,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -2770,7 +2770,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -2790,7 +2790,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -2820,7 +2820,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -2842,7 +2842,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -3016,7 +3016,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -3036,7 +3036,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -3066,7 +3066,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -3088,7 +3088,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -3265,7 +3265,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -3285,7 +3285,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -3315,7 +3315,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -3337,7 +3337,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -3513,7 +3513,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -3533,7 +3533,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -3563,7 +3563,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -3585,7 +3585,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -3762,7 +3762,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -3782,7 +3782,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -3812,7 +3812,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -3834,7 +3834,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
res = 0;
@@ -4009,7 +4009,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -4029,7 +4029,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -4058,7 +4058,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -4080,7 +4080,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
@@ -4257,7 +4257,7 @@ if (diff > 0) { // to simplify the loop below,
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -4277,7 +4277,7 @@ if (diff > 0) { // to simplify the loop below,
//else { //128 by 64 bit multiply -> 192 bits
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
@@ -4307,7 +4307,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -4329,7 +4329,7 @@ if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_64x128_to192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
res = 1;
diff --git a/libgcc/config/libbid/bid128_fma.c
b/libgcc/config/libbid/bid128_fma.c
index 542faaabbb8..206f2986f70 100644
--- a/libgcc/config/libbid/bid128_fma.c
+++ b/libgcc/config/libbid/bid128_fma.c
@@ -2838,7 +2838,7 @@ delta_ge_zero:
// to perform the subtraction before rounding; rounding is performed
// next, depending on the number of decimal digits in the result and on
// the exponent value
- // Note: overlow is not possible in this case
+ // Note: overflow is not possible in this case
// this is similar to Cases (15), (16), and (17)
if (delta + q4 < q3) { // from Case (6)
@@ -2976,7 +2976,7 @@ delta_ge_zero:
res.w[0] = res.w[0] - 1;
if (res.w[0] == 0xffffffffffffffffull)
res.w[1]--;
- // if it is (10^33-1)*10^e4 then the corect result is
+ // if it is (10^33-1)*10^e4 then the correct result is
// (10^34-1)*10(e4-1)
if (res.w[1] == 0x0000314dc6448d93ull &&
res.w[0] == 0x38c15b09ffffffffull) {
diff --git a/libgcc/config/libbid/bid128_minmax.c
b/libgcc/config/libbid/bid128_minmax.c
index 224d4ec9696..b0b611c14f1 100644
--- a/libgcc/config/libbid/bid128_minmax.c
+++ b/libgcc/config/libbid/bid128_minmax.c
@@ -236,7 +236,7 @@ bid128_minnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
}
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
|| (sig_n_prime256.w[1] > sig_y.w[1])
@@ -247,7 +247,7 @@ bid128_minnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
BID_RETURN (res);
}
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
res =
(((sig_n_prime192.w[2] > 0) || (sig_n_prime192.w[1] > sig_y.w[1])
@@ -265,7 +265,7 @@ bid128_minnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
res =
((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
@@ -278,7 +278,7 @@ bid128_minnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
}
// adjust the y significand upwards
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
res =
((sig_n_prime192.w[2] != 0
|| (sig_n_prime192.w[1] > sig_x.w[1]
@@ -770,7 +770,7 @@ bid128_maxnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
}
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
res = ((((sig_n_prime256.w[3] > 0) || sig_n_prime256.w[2] > 0)
|| (sig_n_prime256.w[1] > sig_y.w[1])
@@ -781,7 +781,7 @@ bid128_maxnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
BID_RETURN (res);
}
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
res =
(((sig_n_prime192.w[2] > 0) || (sig_n_prime192.w[1] > sig_y.w[1])
@@ -799,7 +799,7 @@ bid128_maxnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
res =
((sig_n_prime256.w[3] != 0 || sig_n_prime256.w[2] != 0
@@ -812,7 +812,7 @@ bid128_maxnum (UINT128 x, UINT128 y _EXC_FLAGS_PARAM) {
}
// adjust the y significand upwards
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
res =
((sig_n_prime192.w[2] != 0
|| (sig_n_prime192.w[1] > sig_x.w[1]
@@ -1026,7 +1026,7 @@ bid128_maxnum_mag (UINT128 x, UINT128 y _EXC_FLAGS_PARAM)
{
}
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
__mul_128x128_to_256 (sig_n_prime256, sig_x, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_y.w[1]
@@ -1041,7 +1041,7 @@ bid128_maxnum_mag (UINT128 x, UINT128 y _EXC_FLAGS_PARAM)
{
BID_RETURN (res);
}
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_x);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if
negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_y.w[1]
&& (sig_n_prime192.w[0] == sig_y.w[0])) {
// if equal, return positive magnitude
@@ -1063,7 +1063,7 @@ bid128_maxnum_mag (UINT128 x, UINT128 y _EXC_FLAGS_PARAM)
{
if (diff > 19) { //128 by 128 bit multiply -> 256 bits
// adjust the y significand upwards
__mul_128x128_to_256 (sig_n_prime256, sig_y, ten2k128[diff - 20]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime256.w[3] == 0 && (sig_n_prime256.w[2] == 0)
&& sig_n_prime256.w[1] == sig_x.w[1]
@@ -1080,7 +1080,7 @@ bid128_maxnum_mag (UINT128 x, UINT128 y _EXC_FLAGS_PARAM)
{
}
// adjust the y significand upwards
__mul_64x128_to_192 (sig_n_prime192, ten2k64[diff], sig_y);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
if ((sig_n_prime192.w[2] == 0) && sig_n_prime192.w[1] == sig_x.w[1]
&& (sig_n_prime192.w[0] == sig_x.w[0])) {
// if equal, return positive (if possible)
diff --git a/libgcc/config/libbid/bid128_round_integral.c
b/libgcc/config/libbid/bid128_round_integral.c
index 34e9f9945e2..47ef24be6c9 100644
--- a/libgcc/config/libbid/bid128_round_integral.c
+++ b/libgcc/config/libbid/bid128_round_integral.c
@@ -271,7 +271,7 @@ case ROUNDING_TO_NEAREST:
((fstar.w[1] < (ten2mk128[ind - 1].w[1]))
|| ((fstar.w[1] == ten2mk128[ind - 1].w[1])
&& (fstar.w[0] < ten2mk128[ind - 1].w[0])))) {
- // subract 1 to make even
+ // subtract 1 to make even
if (res.w[0]-- == 0) {
res.w[1]--;
}
@@ -306,7 +306,7 @@ case ROUNDING_TO_NEAREST:
fstar.w[2] == 0 && (fstar.w[1] < ten2mk128[ind - 1].w[1] ||
(fstar.w[1] == ten2mk128[ind - 1].w[1] &&
fstar.w[0] < ten2mk128[ind - 1].w[0]))) {
- // subract 1 to make even
+ // subtract 1 to make even
if (res.w[0]-- == 0) {
res.w[1]--;
}
@@ -343,7 +343,7 @@ case ROUNDING_TO_NEAREST:
(fstar.w[1] < ten2mk128[ind - 1].w[1] ||
(fstar.w[1] == ten2mk128[ind - 1].w[1] &&
fstar.w[0] < ten2mk128[ind - 1].w[0]))) {
- // subract 1 to make even
+ // subtract 1 to make even
if (res.w[0]-- == 0) {
res.w[1]--;
}
@@ -992,7 +992,7 @@ if (exp >= 0) { // -exp <= 0
((P256.w[1] < (ten2mk128[ind - 1].w[1]))
|| ((P256.w[1] == ten2mk128[ind - 1].w[1])
&& (P256.w[0] < ten2mk128[ind - 1].w[0])))) {
- // subract 1 to make even
+ // subtract 1 to make even
if (res.w[0]-- == 0) {
res.w[1]--;
}
@@ -1012,7 +1012,7 @@ if (exp >= 0) { // -exp <= 0
fstar.w[2] == 0 && (fstar.w[1] < ten2mk128[ind - 1].w[1] ||
(fstar.w[1] == ten2mk128[ind - 1].w[1] &&
fstar.w[0] < ten2mk128[ind - 1].w[0]))) {
- // subract 1 to make even
+ // subtract 1 to make even
if (res.w[0]-- == 0) {
res.w[1]--;
}
@@ -1033,7 +1033,7 @@ if (exp >= 0) { // -exp <= 0
&& (fstar.w[1] < ten2mk128[ind - 1].w[1]
|| (fstar.w[1] == ten2mk128[ind - 1].w[1]
&& fstar.w[0] < ten2mk128[ind - 1].w[0]))) {
- // subract 1 to make even
+ // subtract 1 to make even
if (res.w[0]-- == 0) {
res.w[1]--;
}
diff --git a/libgcc/config/libbid/bid128_string.c
b/libgcc/config/libbid/bid128_string.c
index f65701f63cb..bb3cf2ba780 100755
--- a/libgcc/config/libbid/bid128_string.c
+++ b/libgcc/config/libbid/bid128_string.c
@@ -166,7 +166,7 @@ bid128_to_string (char *str, UINT128 x
of MiDi returned. Note that the character sequence
does not have leading zeros EXCEPT when the input is of
zero value. It will then output 1 character '0'
- The algorithm essentailly tries first to get a sequence of
+ The algorithm essentially tries first to get a sequence of
Millenial Digits "MiDi" and then uses table lookup to get the
character strings of these MiDis.
**************************************************** */
diff --git a/libgcc/config/libbid/bid64_compare.c
b/libgcc/config/libbid/bid64_compare.c
index 6e1be8b7b89..aa645120887 100644
--- a/libgcc/config/libbid/bid64_compare.c
+++ b/libgcc/config/libbid/bid64_compare.c
@@ -296,7 +296,7 @@ bid64_quiet_greater (UINT64 x,
// otherwise adjust the x significand upwards
__mul_64x64_to_128MACH (sig_n_prime, sig_x,
mult_factor[exp_x - exp_y]);
- // if postitive, return whichever significand is larger (converse if neg.)
+ // if positive, return whichever significand is larger (converse if neg.)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
res = 0;
BID_RETURN (res);
@@ -309,7 +309,7 @@ bid64_quiet_greater (UINT64 x,
// adjust the y significand upwards
__mul_64x64_to_128MACH (sig_n_prime, sig_y,
mult_factor[exp_y - exp_x]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
res = 0;
@@ -465,7 +465,7 @@ bid64_quiet_greater_equal (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
res = (((sig_n_prime.w[1] == 0)
&& sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) !=
@@ -628,7 +628,7 @@ bid64_quiet_greater_unordered (UINT64 x,
// otherwise adjust the x significand upwards
__mul_64x64_to_128MACH (sig_n_prime, sig_x,
mult_factor[exp_x - exp_y]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
res = 0;
@@ -642,7 +642,7 @@ bid64_quiet_greater_unordered (UINT64 x,
// adjust the y significand upwards
__mul_64x64_to_128MACH (sig_n_prime, sig_y,
mult_factor[exp_y - exp_x]);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
res = 0;
BID_RETURN (res);
@@ -799,7 +799,7 @@ bid64_quiet_less (UINT64 x,
res = 0;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
res = (((sig_n_prime.w[1] == 0)
&& sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
@@ -967,7 +967,7 @@ bid64_quiet_less_equal (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
res = (((sig_n_prime.w[1] == 0)
&& sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
@@ -1135,7 +1135,7 @@ bid64_quiet_less_unordered (UINT64 x,
res = 0;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
res = (((sig_n_prime.w[1] == 0)
&& sig_n_prime.w[0] < sig_y) ^ ((x & MASK_SIGN) ==
@@ -1444,7 +1444,7 @@ bid64_quiet_not_greater (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
@@ -1629,7 +1629,7 @@ bid64_quiet_not_less (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
@@ -1868,7 +1868,7 @@ bid64_signaling_greater (UINT64 x,
mult_factor[exp_x - exp_y]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
res = 0;
@@ -1886,7 +1886,7 @@ bid64_signaling_greater (UINT64 x,
__mul_64x64_to_128MACH (sig_n_prime, sig_y,
mult_factor[exp_y - exp_x]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
res = 0;
@@ -2054,7 +2054,7 @@ bid64_signaling_greater_equal (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
@@ -2231,7 +2231,7 @@ bid64_signaling_greater_unordered (UINT64 x,
__mul_64x64_to_128MACH (sig_n_prime, sig_x,
mult_factor[exp_x - exp_y]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
res = 0;
@@ -2249,7 +2249,7 @@ bid64_signaling_greater_unordered (UINT64 x,
__mul_64x64_to_128MACH (sig_n_prime, sig_y,
mult_factor[exp_y - exp_x]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
res = 0;
@@ -2417,7 +2417,7 @@ bid64_signaling_less (UINT64 x,
res = 0;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
@@ -2598,7 +2598,7 @@ bid64_signaling_less_equal (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
@@ -2780,7 +2780,7 @@ bid64_signaling_less_unordered (UINT64 x,
res = 0;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
@@ -2961,7 +2961,7 @@ bid64_signaling_not_greater (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
@@ -3143,7 +3143,7 @@ bid64_signaling_not_less (UINT64 x,
res = 1;
BID_RETURN (res);
}
- // if postitive, return whichever significand abs is smaller
+ // if positive, return whichever significand abs is smaller
// (converse if negative)
{
res = (((sig_n_prime.w[1] == 0)
diff --git a/libgcc/config/libbid/bid64_fma.c b/libgcc/config/libbid/bid64_fma.c
index 552d2b94137..b15bebeeb49 100644
--- a/libgcc/config/libbid/bid64_fma.c
+++ b/libgcc/config/libbid/bid64_fma.c
@@ -27,7 +27,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If
not, see
*
* Algorithm description:
*
- * if multiplication is guranteed exact (short coefficients)
+ * if multiplication is guaranteed exact (short coefficients)
* call the unpacked arg. equivalent of bid64_add(x*y, z)
* else
* get full coefficient_x*coefficient_y product
@@ -171,7 +171,7 @@ bid64_fma (UINT64 x, UINT64 y,
#endif
BID_RETURN (0x7c00000000000000ull);
}
- // test if z is Inf of oposite sign
+ // test if z is Inf of opposite sign
if (((z & 0x7c00000000000000ull) == 0x7800000000000000ull)
&& (((x ^ y) ^ z) & 0x8000000000000000ull)) {
// return NaN
@@ -215,7 +215,7 @@ bid64_fma (UINT64 x, UINT64 y,
#endif
BID_RETURN (0x7c00000000000000ull);
}
- // test if z is Inf of oposite sign
+ // test if z is Inf of opposite sign
if (((z & 0x7c00000000000000ull) == 0x7800000000000000ull)
&& (((x ^ y) ^ z) & 0x8000000000000000ull)) {
#ifdef SET_STATUS_FLAGS
diff --git a/libgcc/config/libbid/bid64_minmax.c
b/libgcc/config/libbid/bid64_minmax.c
index c90b628ee1d..4caaa6cc32b 100644
--- a/libgcc/config/libbid/bid64_minmax.c
+++ b/libgcc/config/libbid/bid64_minmax.c
@@ -223,7 +223,7 @@ bid64_minnum (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
// otherwise adjust the x significand upwards
__mul_64x64_to_128MACH (sig_n_prime, sig_x,
mult_factor[exp_x - exp_y]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
res = y;
@@ -239,7 +239,7 @@ bid64_minnum (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
__mul_64x64_to_128MACH (sig_n_prime, sig_y,
mult_factor[exp_y - exp_x]);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
res = y;
BID_RETURN (res);
@@ -635,7 +635,7 @@ bid64_maxnum (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
// otherwise adjust the x significand upwards
__mul_64x64_to_128MACH (sig_n_prime, sig_x,
mult_factor[exp_x - exp_y]);
- // if postitive, return whichever significand is larger
+ // if positive, return whichever significand is larger
// (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
res = y;
@@ -650,7 +650,7 @@ bid64_maxnum (UINT64 x, UINT64 y _EXC_FLAGS_PARAM) {
__mul_64x64_to_128MACH (sig_n_prime, sig_y,
mult_factor[exp_y - exp_x]);
- // if postitive, return whichever significand is larger (converse if
negative)
+ // if positive, return whichever significand is larger (converse if negative)
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_x)) {
res = y;
BID_RETURN (res);
diff --git a/libgcc/config/libbid/bid64_noncomp.c
b/libgcc/config/libbid/bid64_noncomp.c
index 2eb78ee4af6..0c1e9e9c072 100644
--- a/libgcc/config/libbid/bid64_noncomp.c
+++ b/libgcc/config/libbid/bid64_noncomp.c
@@ -703,7 +703,7 @@ bid64_totalOrder (UINT64 x, UINT64 y _EXC_MASKS_PARAM
_EXC_INFO_PARAM) {
// if x and y represent the same entities,
// and both are negative, return true iff exp_x <= exp_y
if (sig_n_prime.w[1] == 0 && (sig_n_prime.w[0] == sig_y)) {
- // case cannot occure, because all bits must
+ // case cannot occur, because all bits must
// be the same - would have been caught if (x==y)
res = (exp_x <= exp_y) ^ ((x & MASK_SIGN) == MASK_SIGN);
BID_RETURN (res);
diff --git a/libgcc/config/libbid/bid64_string.c
b/libgcc/config/libbid/bid64_string.c
index 4bff3d9308c..5e3bd7faf6a 100644
--- a/libgcc/config/libbid/bid64_string.c
+++ b/libgcc/config/libbid/bid64_string.c
@@ -150,7 +150,7 @@ bid64_to_string (char *ps, UINT64 x
of MiDi returned. Note that the character sequence
does not have leading zeros EXCEPT when the input is of
zero value. It will then output 1 character '0'
- The algorithm essentailly tries first to get a sequence of
+ The algorithm essentially tries first to get a sequence of
Millenial Digits "MiDi" and then uses table lookup to get the
character strings of these MiDis.
**************************************************** */
diff --git a/libgcc/config/libbid/bid_binarydecimal.c
b/libgcc/config/libbid/bid_binarydecimal.c
index b4b0e1028f0..16f4ff98429 100644
--- a/libgcc/config/libbid/bid_binarydecimal.c
+++ b/libgcc/config/libbid/bid_binarydecimal.c
@@ -143892,7 +143892,7 @@ bid32_to_binary32 (UINT32 x
return_binary32_inf (s), return_binary32_nan);
// Correct to 2^112 <= c < 2^113 with corresponding exponent adding 113-24=89
-// Thus a shift of 25 given that we've already upacked in c.w[1]
+// Thus a shift of 25 given that we've already unpacked in c.w[1]
c.w[1] = c.w[1] << 25;
c.w[0] = 0;
@@ -144287,7 +144287,7 @@ bid32_to_binary64 (UINT32 x
// Correct to 2^112 <= c < 2^113 with corresponding exponent adding 113-24=89
// In fact shift a further 6 places ready for reciprocal multiplication
-// Thus (113-24)+6=95, a shift of 31 given that we've already upacked in c.w[1]
+// Thus (113-24)+6=95, a shift of 31 given that we've already unpacked in
c.w[1]
c.w[1] = c.w[1] << 31;
c.w[0] = 0;
@@ -144379,7 +144379,7 @@ bid64_to_binary64 (UINT64 x
// Correct to 2^112 <= c < 2^113 with corresponding exponent adding 113-54=59
// In fact shift a further 6 places ready for reciprocal multiplication
-// Thus (113-54)+6=65, a shift of 1 given that we've already upacked in c.w[1]
+// Thus (113-54)+6=65, a shift of 1 given that we've already unpacked in c.w[1]
c.w[1] = c.w[1] << 1;
c.w[0] = 0;
diff --git a/libgcc/config/libbid/bid_dpd.c b/libgcc/config/libbid/bid_dpd.c
index 65b54e8d3fb..979fe8ab715 100644
--- a/libgcc/config/libbid/bid_dpd.c
+++ b/libgcc/config/libbid/bid_dpd.c
@@ -198,7 +198,7 @@ bid_to_dpd64 (UINT64 ba) {
// Floor(2^61 / 10^9)
#define D61 (2305843009ull)
-// Multipy the binary coefficient by ceil(2^64 / 1000), and take the upper
+// Multiply the binary coefficient by ceil(2^64 / 1000), and take the upper
// 64-bits in order to compute a division by 1000.
#if 1
diff --git a/libgcc/config/libbid/bid_flag_operations.c
b/libgcc/config/libbid/bid_flag_operations.c
index d9309135bca..df732fca619 100644
--- a/libgcc/config/libbid/bid_flag_operations.c
+++ b/libgcc/config/libbid/bid_flag_operations.c
@@ -31,7 +31,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If
not, see
// global, they have a fixed name recognized by the library functions:
// _IDEC_glbflags; pfpsf, defined as &_IDEC_glbflags, can be used instead; no
// argument is passed for the status flags to the library functions; if the
-// status flags are local then they are passed as an arument, always by
+// status flags are local then they are passed as an argument, always by
// reference, to the library functions
//
// #if !DECIMAL_GLOBAL_EXCEPTION_FLAGS
@@ -140,7 +140,7 @@ testSavedFlags (_IDEC_flags savedflags, _IDEC_flags
flagsmask) {
void
restoreFlags (_IDEC_flags * pflagsvalues,
_IDEC_flags * pflagsmask _EXC_FLAGS_PARAM) {
- // restore the status flags selected by *pflagsmask to the values speciafied
+ // restore the status flags selected by *pflagsmask to the values specified
// (as a logical OR) in *pflagsvalues; e.g. if
// *pflagsmask = INVALID_EXCEPTION | UNDERFLOW_EXCEPTION | INEXACT_EXCEPTION
// and only the invalid and inexact flags are raised (set) in *pflagsvalues
@@ -155,7 +155,7 @@ restoreFlags (_IDEC_flags * pflagsvalues,
void
restoreFlags (_IDEC_flags flagsvalues,
_IDEC_flags flagsmask _EXC_FLAGS_PARAM) {
- // restore the status flags selected by flagsmask to the values speciafied
+ // restore the status flags selected by flagsmask to the values specified
// (as a logical OR) in flagsvalues; e.g. if
// flagsmask = INVALID_EXCEPTION | UNDERFLOW_EXCEPTION | INEXACT_EXCEPTION
// and only the invalid and inexact flags are raised (set) in flagsvalues
@@ -198,7 +198,7 @@ saveFlags (_IDEC_flags flagsmask _EXC_FLAGS_PARAM) {
// mode is global, it has a fixed name recognized by the library functions:
// _IDEC_glbround; rnd_mode, defined as &_IDEC_glbround, can be used instead;
no
// argument is passed for the rounding mode to the library functions; if the
-// rounding mode is local then it is passed as an arument, by reference or by
+// rounding mode is local then it is passed as an argument, by reference or by
// value, to the library functions
//
// #if DECIMAL_CALL_BY_REFERENCE
diff --git a/libgcc/config/libbid/bid_from_int.c
b/libgcc/config/libbid/bid_from_int.c
index 97ec5d63d86..ec4bd694630 100644
--- a/libgcc/config/libbid/bid_from_int.c
+++ b/libgcc/config/libbid/bid_from_int.c
@@ -116,7 +116,7 @@ bid64_from_int64 (SINT64 x
ind = 3; // number of digits to remove for q = 19
}
// overflow and underflow are not possible
- // Note: performace can be improved by inlining this call
+ // Note: performance can be improved by inlining this call
round64_2_18 ( // will work for 19 digits too if C fits in 64 bits
q, ind, C, &res, &incr_exp,
&is_midpoint_lt_even, &is_midpoint_gt_even,
@@ -217,7 +217,7 @@ bid64_from_uint64 (UINT64 x
ind = 4; // number of digits to remove for q = 20
}
// overflow and underflow are not possible
- // Note: performace can be improved by inlining this call
+ // Note: performance can be improved by inlining this call
if (q <= 19) {
round64_2_18 ( // will work for 20 digits too if x fits in 64 bits
q, ind, x, &res, &incr_exp,
diff --git a/libgcc/config/libbid/bid_gcc_intrinsics.h
b/libgcc/config/libbid/bid_gcc_intrinsics.h
index f55bbe9ceaf..8afb5ff45ae 100644
--- a/libgcc/config/libbid/bid_gcc_intrinsics.h
+++ b/libgcc/config/libbid/bid_gcc_intrinsics.h
@@ -159,7 +159,7 @@ typedef __attribute__ ((aligned(16))) struct
#endif /* IN_LIBGCC2 */
#if BID_HAS_GCC_DECIMAL_INTRINSICS
-/* Prototypes for gcc instrinsics */
+/* Prototypes for gcc intrinsics */
extern _Decimal64 __bid_adddd3 (_Decimal64, _Decimal64);
extern _Decimal64 __bid_subdd3 (_Decimal64, _Decimal64);
diff --git a/libgcc/config/libbid/bid_internal.h
b/libgcc/config/libbid/bid_internal.h
index 498c47a8a4e..eb8226e6176 100644
--- a/libgcc/config/libbid/bid_internal.h
+++ b/libgcc/config/libbid/bid_internal.h
@@ -1301,7 +1301,7 @@ get_BID64_UF (UINT64 sgn, int expon, UINT64 coeff, UINT64
R, int rmode,
//
-// This pack macro doesnot check for coefficients above 2^53
+// This pack macro does not check for coefficients above 2^53
//
__BID_INLINE__ UINT64
get_BID64_small_mantissa (UINT64 sgn, int expon, UINT64 coeff,
@@ -1822,7 +1822,7 @@ unpack_BID128_value (UINT64 * psign_x, int *pexponent_x,
//
-// BID128 unpack, input pased by reference
+// BID128 unpack, input passed by reference
//
__BID_INLINE__ UINT64
unpack_BID128 (UINT64 * psign_x, int *pexponent_x,
diff --git a/libgcc/config/libbid/bid_round.c b/libgcc/config/libbid/bid_round.c
index 68fb4a6ac0d..419ad34c74c 100644
--- a/libgcc/config/libbid/bid_round.c
+++ b/libgcc/config/libbid/bid_round.c
@@ -165,7 +165,7 @@ round64_2_18 (int q,
// else
// C* = floor(C*) (logical right shift; C has q - x decimal digits,
// correct by Property 1)
- // in the caling function n = C* * 10^(e+x)
+ // in the calling function n = C* * 10^(e+x)
// determine inexactness of the rounding of C*
// if (0 < f* - 1/2 < 10^(-x)) then
@@ -300,7 +300,7 @@ round128_19_38 (int q,
// else
// C* = floor(C*) (logical right shift; C has q - x decimal digits,
// correct by Property 1)
- // in the caling function n = C* * 10^(e+x)
+ // in the calling function n = C* * 10^(e+x)
// determine inexactness of the rounding of C*
// if (0 < f* - 1/2 < 10^(-x)) then
@@ -520,7 +520,7 @@ round192_39_57 (int q,
// else
// C* = floor(C*) (logical right shift; C has q - x decimal digits,
// correct by Property 1)
- // in the caling function n = C* * 10^(e+x)
+ // in the calling function n = C* * 10^(e+x)
// determine inexactness of the rounding of C*
// if (0 < f* - 1/2 < 10^(-x)) then
@@ -868,7 +868,7 @@ round256_58_76 (int q,
// else
// C* = floor(C*) (logical right shift; C has q - x decimal digits,
// correct by Property 1)
- // in the caling function n = C* * 10^(e+x)
+ // in the calling function n = C* * 10^(e+x)
// determine inexactness of the rounding of C*
// if (0 < f* - 1/2 < 10^(-x)) then
@@ -1025,7 +1025,7 @@ round256_58_76 (int q,
} else {
*incr_exp = 0;
}
- // else if (ind == 58) is not needed becauae we do not have ten2k192[] yet
+ // else if (ind == 58) is not needed because we do not have ten2k192[] yet
} else { // if 58 <= ind <= 77 (actually 58 <= ind <= 74)
if (Cstar.w[3] == ten2k256[ind - 39].w[3] &&
Cstar.w[2] == ten2k256[ind - 39].w[2] &&
--
2.43.0
