]> git.ipfire.org Git - thirdparty/glibc.git/commitdiff
Refactor PRINT_FPHEX_LONG_DOUBLE into a reusable macro
authorGabriel F. T. Gomes <gftg@linux.vnet.ibm.com>
Fri, 2 Jun 2017 19:03:40 +0000 (16:03 -0300)
committerGabriel F. T. Gomes <gftg@linux.vnet.ibm.com>
Wed, 7 Jun 2017 20:06:31 +0000 (17:06 -0300)
This patch refactors the macro PRINT_FPHEX_LONG_DOUBLE from the file
sysdeps/ieee754/ldbl-128/printf_fphex.c into a function-like macro to
enable its use for both long double and _Float128, when they are
ABI-distinct.

* sysdeps/ieee754/ldbl-128/printf_fphex.c: Include
ldbl-128/printf_fphex_macros.h for the definition of PRINT_FPHEX.
(PRINT_FPHEX_LONG_DOUBLE): Define based on PRINT_FPHEX.
* sysdeps/ieee754/ldbl-128/printf_fphex_macros.h
(PRINT_FPHEX): New function-like macro that can be used for long
double, as well as for _Float128

ChangeLog
sysdeps/ieee754/ldbl-128/printf_fphex.c
sysdeps/ieee754/ldbl-128/printf_fphex_macros.h [new file with mode: 0644]

index 429fe418da4bf76c8802119466dbd57f13f4afb6..9d033b5aabd284adeb6c74fac014b0ab85d7f246 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2017-06-07  Gabriel F. T. Gomes  <gftg@linux.vnet.ibm.com>
+
+       * sysdeps/ieee754/ldbl-128/printf_fphex.c: Include
+       ldbl-128/printf_fphex_macros.h for the definition of PRINT_FPHEX.
+       (PRINT_FPHEX_LONG_DOUBLE): Define based on PRINT_FPHEX.
+       * sysdeps/ieee754/ldbl-128/printf_fphex_macros.h
+       (PRINT_FPHEX): New function-like macro that can be used for long
+       double, as well as for _Float128
+
 2017-06-07  Gabriel F. T. Gomes  <gftg@linux.vnet.ibm.com>
 
        * stdio-common/printf_fp.c (PRINTF_FP_FETCH): New macro.
index d9eaf8d3ff19bd064624a6714a170327f19b4b3e..294464ecffbaa4f779937ffd3c9d784d70577db7 100644 (file)
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
+#include <ldbl-128/printf_fphex_macros.h>
 #define PRINT_FPHEX_LONG_DOUBLE \
-do {                                                                         \
-      /* We have 112 bits of mantissa plus one implicit digit.  Since        \
-        112 bits are representable without rest using hexadecimal            \
-        digits we use only the implicit digits for the number before         \
-        the decimal point.  */                                               \
-      unsigned long long int num0, num1;                                     \
-      union ieee854_long_double u;                                           \
-      u.d = fpnum.ldbl;                                                              \
-                                                                             \
-      assert (sizeof (long double) == 16);                                   \
-                                                                             \
-      num0 = (((unsigned long long int) u.ieee.mantissa0) << 32                      \
-            | u.ieee.mantissa1);                                             \
-      num1 = (((unsigned long long int) u.ieee.mantissa2) << 32                      \
-            | u.ieee.mantissa3);                                             \
-                                                                             \
-      zero_mantissa = (num0|num1) == 0;                                              \
-                                                                             \
-      if (sizeof (unsigned long int) > 6)                                    \
-       {                                                                     \
-         numstr = _itoa_word (num1, numbuf + sizeof numbuf, 16,              \
-                              info->spec == 'A');                            \
-         wnumstr = _itowa_word (num1,                                        \
-                                wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),\
-                                16, info->spec == 'A');                      \
-       }                                                                     \
-      else                                                                   \
-       {                                                                     \
-         numstr = _itoa (num1, numbuf + sizeof numbuf, 16,                   \
-                         info->spec == 'A');                                 \
-         wnumstr = _itowa (num1,                                             \
-                           wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),    \
-                           16, info->spec == 'A');                           \
-       }                                                                     \
-                                                                             \
-      while (numstr > numbuf + (sizeof numbuf - 64 / 4))                     \
-       {                                                                     \
-         *--numstr = '0';                                                    \
-         *--wnumstr = L'0';                                                  \
-       }                                                                     \
-                                                                             \
-      if (sizeof (unsigned long int) > 6)                                    \
-       {                                                                     \
-         numstr = _itoa_word (num0, numstr, 16, info->spec == 'A');          \
-         wnumstr = _itowa_word (num0, wnumstr, 16, info->spec == 'A');       \
-       }                                                                     \
-      else                                                                   \
-       {                                                                     \
-         numstr = _itoa (num0, numstr, 16, info->spec == 'A');               \
-         wnumstr = _itowa (num0, wnumstr, 16, info->spec == 'A');            \
-       }                                                                     \
-                                                                             \
-      /* Fill with zeroes.  */                                               \
-      while (numstr > numbuf + (sizeof numbuf - 112 / 4))                    \
-       {                                                                     \
-         *--numstr = '0';                                                    \
-         *--wnumstr = L'0';                                                  \
-       }                                                                     \
-                                                                             \
-      leading = u.ieee.exponent == 0 ? '0' : '1';                            \
-                                                                             \
-      exponent = u.ieee.exponent;                                            \
-                                                                             \
-      if (exponent == 0)                                                     \
-       {                                                                     \
-         if (zero_mantissa)                                                  \
-           expnegative = 0;                                                  \
-         else                                                                \
-           {                                                                 \
-             /* This is a denormalized number.  */                           \
-             expnegative = 1;                                                \
-             exponent = IEEE854_LONG_DOUBLE_BIAS - 1;                        \
-           }                                                                 \
-       }                                                                     \
-      else if (exponent >= IEEE854_LONG_DOUBLE_BIAS)                         \
-       {                                                                     \
-         expnegative = 0;                                                    \
-         exponent -= IEEE854_LONG_DOUBLE_BIAS;                               \
-       }                                                                     \
-      else                                                                   \
-       {                                                                     \
-         expnegative = 1;                                                    \
-         exponent = -(exponent - IEEE854_LONG_DOUBLE_BIAS);                  \
-       }                                                                     \
-} while (0)
+  PRINT_FPHEX (long double, fpnum.ldbl, ieee854_long_double, \
+              IEEE854_LONG_DOUBLE_BIAS)
 
 #include <stdio-common/printf_fphex.c>
diff --git a/sysdeps/ieee754/ldbl-128/printf_fphex_macros.h b/sysdeps/ieee754/ldbl-128/printf_fphex_macros.h
new file mode 100644 (file)
index 0000000..86681c4
--- /dev/null
@@ -0,0 +1,104 @@
+/* Macro to print floating point numbers in hexadecimal notation.
+   Copyright (C) 2017 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#define PRINT_FPHEX(FLOAT, VAR, IEEE854_UNION, IEEE854_BIAS)                 \
+do {                                                                         \
+      /* We have 112 bits of mantissa plus one implicit digit.  Since        \
+        112 bits are representable without rest using hexadecimal            \
+        digits we use only the implicit digits for the number before         \
+        the decimal point.  */                                               \
+      unsigned long long int num0, num1;                                     \
+      union IEEE854_UNION u;                                                 \
+      u.d = VAR;                                                             \
+                                                                             \
+      assert (sizeof (FLOAT) == 16);                                         \
+                                                                             \
+      num0 = (((unsigned long long int) u.ieee.mantissa0) << 32                      \
+            | u.ieee.mantissa1);                                             \
+      num1 = (((unsigned long long int) u.ieee.mantissa2) << 32                      \
+            | u.ieee.mantissa3);                                             \
+                                                                             \
+      zero_mantissa = (num0|num1) == 0;                                              \
+                                                                             \
+      if (sizeof (unsigned long int) > 6)                                    \
+       {                                                                     \
+         numstr = _itoa_word (num1, numbuf + sizeof numbuf, 16,              \
+                              info->spec == 'A');                            \
+         wnumstr = _itowa_word (num1,                                        \
+                                wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),\
+                                16, info->spec == 'A');                      \
+       }                                                                     \
+      else                                                                   \
+       {                                                                     \
+         numstr = _itoa (num1, numbuf + sizeof numbuf, 16,                   \
+                         info->spec == 'A');                                 \
+         wnumstr = _itowa (num1,                                             \
+                           wnumbuf + sizeof (wnumbuf) / sizeof (wchar_t),    \
+                           16, info->spec == 'A');                           \
+       }                                                                     \
+                                                                             \
+      while (numstr > numbuf + (sizeof numbuf - 64 / 4))                     \
+       {                                                                     \
+         *--numstr = '0';                                                    \
+         *--wnumstr = L'0';                                                  \
+       }                                                                     \
+                                                                             \
+      if (sizeof (unsigned long int) > 6)                                    \
+       {                                                                     \
+         numstr = _itoa_word (num0, numstr, 16, info->spec == 'A');          \
+         wnumstr = _itowa_word (num0, wnumstr, 16, info->spec == 'A');       \
+       }                                                                     \
+      else                                                                   \
+       {                                                                     \
+         numstr = _itoa (num0, numstr, 16, info->spec == 'A');               \
+         wnumstr = _itowa (num0, wnumstr, 16, info->spec == 'A');            \
+       }                                                                     \
+                                                                             \
+      /* Fill with zeroes.  */                                               \
+      while (numstr > numbuf + (sizeof numbuf - 112 / 4))                    \
+       {                                                                     \
+         *--numstr = '0';                                                    \
+         *--wnumstr = L'0';                                                  \
+       }                                                                     \
+                                                                             \
+      leading = u.ieee.exponent == 0 ? '0' : '1';                            \
+                                                                             \
+      exponent = u.ieee.exponent;                                            \
+                                                                             \
+      if (exponent == 0)                                                     \
+       {                                                                     \
+         if (zero_mantissa)                                                  \
+           expnegative = 0;                                                  \
+         else                                                                \
+           {                                                                 \
+             /* This is a denormalized number.  */                           \
+             expnegative = 1;                                                \
+             exponent = IEEE854_BIAS - 1;                                    \
+           }                                                                 \
+       }                                                                     \
+      else if (exponent >= IEEE854_BIAS)                                     \
+       {                                                                     \
+         expnegative = 0;                                                    \
+         exponent -= IEEE854_BIAS;                                           \
+       }                                                                     \
+      else                                                                   \
+       {                                                                     \
+         expnegative = 1;                                                    \
+         exponent = -(exponent - IEEE854_BIAS);                              \
+       }                                                                     \
+} while (0)