[v3] Prepare vfprintf to use __printf_fp/__printf_fphex with float128 arg
Commit Message
Changes since v2:
- Fixed style error in `do { ... } while (0)' blocks.
- Zero-initialize args_value[cnt] with memset, rather than relying on
the `.pa_long_double' member being the largest of the members.
Changes since v1:
- Updated to the revised and integrated patches for __ldbl_is_dbl
removal, i.e.: the patches in the following thread:
<https://sourceware.org/ml/libc-alpha/2018-12/msg00186.html>.
- Added description for the PRINTF_LDBL_USES_FLOAT128 macro.
- Removed the LDBL_USES_FLOAT128 macro.
- Added `do { } while (0)' to the PARSE_FLOAT_VA_ARG_EXTENDED,
PARSE_FLOAT_VA_ARG, and SETUP_FLOAT128_INFO macros. Appended
expansions with `;', accordingly.
-- 8< --
On powerpc64le, long double can currently take two formats: the same as
double (-mlong-double-64) or IBM Extended Precision (default with
-mlong-double-128 or explicitly with -mabi=ibmlongdouble). The internal
implementation of printf-like functions is aware of these possibilities
and properly parses floating-point values from the variable arguments,
before making calls to __printf_fp and __printf_fphex. These functions
are also aware of the format possibilities and know how to convert both
formats to string.
When library support for TS 18661-3 was added to glibc, __printf_fp and
__printf_fphex were extended with support for an additional type
(__float128/_Float128) with a different format (binary128). Now that
powerpc64le is getting support for its third long double format, and
taking into account that this format is the same as the format of
__float128/_Float128, this patch extends __vfprintf_internal to properly
call __printf_fp and __printf_fphex with this new format.
Tested for powerpc64le (with additional patches to actually enable the
use of these preparations) and for x86_64.
* libio/libioP.h (PRINTF_LDBL_USES_FLOAT128): New macro to be
used as a mask for the mode argument of __vfprintf_internal.
* stdio-common/printf-parse.h (printf_arg): New union member:
pa_float128.
* stdio-common/vfprintf-internal.c
(PARSE_FLOAT_VA_ARG_EXTENDED): New macro.
(PARSE_FLOAT_VA_ARG): Likewise.
(SETUP_FLOAT128_INFO): Likewise.
(process_arg): Use PARSE_FLOAT_VA_ARG_EXTENDED and
SETUP_FLOAT128_INFO.
[__HAVE_FLOAT128_UNLIKE_LDBL] (printf_positional): Write
floating-point value to the new union member, pa_float128.
(printf_positional): Zero-initialize args_value[cnt] with memset.
---
libio/libioP.h | 18 ++++++++--
stdio-common/printf-parse.h | 3 ++
stdio-common/vfprintf-internal.c | 73 +++++++++++++++++++++++++++++++++-------
3 files changed, 78 insertions(+), 16 deletions(-)
@@ -705,9 +705,21 @@ extern int __vswprintf_internal (wchar_t *string, size_t maxlen,
PRINTF_FORTIFY, when set to one, indicates that fortification checks
are to be performed in input parameters. This is used by the
__*printf_chk functions, which are used when _FORTIFY_SOURCE is
- defined to 1 or 2. Otherwise, such checks are ignored. */
-#define PRINTF_LDBL_IS_DBL 0x0001
-#define PRINTF_FORTIFY 0x0002
+ defined to 1 or 2. Otherwise, such checks are ignored.
+
+ PRINTF_LDBL_USES_FLOAT128 is used on platforms where the long double
+ format used to be different from the IEC 60559 double format *and*
+ also different from the Quadruple 128-bits IEC 60559 format (such as
+ the IBM Extended Precision format on powerpc or the 80-bits IEC 60559
+ format on x86), but was later converted to the Quadruple 128-bits IEC
+ 60559 format, which is the same format that the _Float128 always has
+ (hence the `USES_FLOAT128' suffix in the name of the flag). When set
+ to one, this macros indicates that long double values are to be
+ handled as having this new format. Otherwise, they should be handled
+ as the previous format on that platform. */
+#define PRINTF_LDBL_IS_DBL 0x0001
+#define PRINTF_FORTIFY 0x0002
+#define PRINTF_LDBL_USES_FLOAT128 0x0004
extern size_t _IO_getline (FILE *,char *, size_t, int, int);
libc_hidden_proto (_IO_getline)
@@ -57,6 +57,9 @@ union printf_arg
unsigned long long int pa_u_long_long_int;
double pa_double;
long double pa_long_double;
+#if __HAVE_FLOAT128_UNLIKE_LDBL
+ _Float128 pa_float128;
+#endif
const char *pa_string;
const wchar_t *pa_wstring;
void *pa_pointer;
@@ -68,6 +68,57 @@
} while (0)
#define UNBUFFERED_P(S) ((S)->_flags & _IO_UNBUFFERED)
+#if __HAVE_FLOAT128_UNLIKE_LDBL
+# define PARSE_FLOAT_VA_ARG_EXTENDED(INFO) \
+ do \
+ { \
+ if (is_long_double \
+ && (mode_flags & PRINTF_LDBL_USES_FLOAT128) != 0) \
+ { \
+ INFO.is_binary128 = 1; \
+ the_arg.pa_float128 = va_arg (ap, _Float128); \
+ } \
+ else \
+ { \
+ PARSE_FLOAT_VA_ARG (INFO); \
+ } \
+ } \
+ while (0)
+#else
+# define PARSE_FLOAT_VA_ARG_EXTENDED(INFO) \
+ PARSE_FLOAT_VA_ARG (INFO);
+#endif
+
+#define PARSE_FLOAT_VA_ARG(INFO) \
+ do \
+ { \
+ INFO.is_binary128 = 0; \
+ if (is_long_double) \
+ the_arg.pa_long_double = va_arg (ap, long double); \
+ else \
+ the_arg.pa_double = va_arg (ap, double); \
+ } \
+ while (0)
+
+#if __HAVE_FLOAT128_UNLIKE_LDBL
+# define SETUP_FLOAT128_INFO(INFO) \
+ do \
+ { \
+ if ((mode_flags & PRINTF_LDBL_USES_FLOAT128) != 0) \
+ INFO.is_binary128 = is_long_double; \
+ else \
+ INFO.is_binary128 = 0; \
+ } \
+ while (0)
+#else
+# define SETUP_FLOAT128_INFO(INFO) \
+ do \
+ { \
+ INFO.is_binary128 = 0; \
+ } \
+ while (0)
+#endif
+
#define done_add(val) \
do { \
unsigned int _val = val; \
@@ -771,10 +822,7 @@ static const uint8_t jump_table[] =
.wide = sizeof (CHAR_T) != 1, \
.is_binary128 = 0}; \
\
- if (is_long_double) \
- the_arg.pa_long_double = va_arg (ap, long double); \
- else \
- the_arg.pa_double = va_arg (ap, double); \
+ PARSE_FLOAT_VA_ARG_EXTENDED (info); \
ptr = (const void *) &the_arg; \
\
function_done = __printf_fp (s, &info, &ptr); \
@@ -787,8 +835,7 @@ static const uint8_t jump_table[] =
fspec->data_arg_type = PA_DOUBLE; \
fspec->info.is_long_double = 0; \
} \
- /* Not supported by *printf functions. */ \
- fspec->info.is_binary128 = 0; \
+ SETUP_FLOAT128_INFO (fspec->info); \
\
function_done = __printf_fp (s, &fspec->info, &ptr); \
} \
@@ -831,10 +878,7 @@ static const uint8_t jump_table[] =
.wide = sizeof (CHAR_T) != 1, \
.is_binary128 = 0}; \
\
- if (is_long_double) \
- the_arg.pa_long_double = va_arg (ap, long double); \
- else \
- the_arg.pa_double = va_arg (ap, double); \
+ PARSE_FLOAT_VA_ARG_EXTENDED (info); \
ptr = (const void *) &the_arg; \
\
function_done = __printf_fphex (s, &info, &ptr); \
@@ -844,8 +888,7 @@ static const uint8_t jump_table[] =
ptr = (const void *) &args_value[fspec->data_arg]; \
if (__glibc_unlikely ((mode_flags & PRINTF_LDBL_IS_DBL) != 0)) \
fspec->info.is_long_double = 0; \
- /* Not supported by *printf functions. */ \
- fspec->info.is_binary128 = 0; \
+ SETUP_FLOAT128_INFO (fspec->info); \
\
function_done = __printf_fphex (s, &fspec->info, &ptr); \
} \
@@ -1869,6 +1912,10 @@ printf_positional (FILE *s, const CHAR_T *format, int readonly_format,
args_value[cnt].pa_double = va_arg (*ap_savep, double);
args_type[cnt] &= ~PA_FLAG_LONG_DOUBLE;
}
+#if __HAVE_FLOAT128_UNLIKE_LDBL
+ else if ((mode_flags & PRINTF_LDBL_USES_FLOAT128) != 0)
+ args_value[cnt].pa_float128 = va_arg (*ap_savep, _Float128);
+#endif
else
args_value[cnt].pa_long_double = va_arg (*ap_savep, long double);
break;
@@ -1887,7 +1934,7 @@ printf_positional (FILE *s, const CHAR_T *format, int readonly_format,
(args_value[cnt].pa_user, ap_savep);
}
else
- args_value[cnt].pa_long_double = 0.0;
+ memset (&args_value[cnt], 0, sizeof (args_value[cnt]));
break;
case -1:
/* Error case. Not all parameters appear in N$ format