about summary refs log tree commit diff
path: root/misc/efgcvt_r-template.c
diff options
context:
space:
mode:
authorGabriel F. T. Gomes <gabrielftg@linux.ibm.com>2019-07-11 11:48:08 -0300
committerGabriel F. T. Gomes <gabrielftg@linux.ibm.com>2019-12-23 16:30:24 -0300
commite18a305777adf60c2378ac864a350319269a29fa (patch)
treebfcc2067d12d938016ef7545faa52bcb24310400 /misc/efgcvt_r-template.c
parent57e687c6d459edba77efe360014d4adec97d1a5c (diff)
downloadglibc-e18a305777adf60c2378ac864a350319269a29fa.tar.gz
glibc-e18a305777adf60c2378ac864a350319269a29fa.tar.xz
glibc-e18a305777adf60c2378ac864a350319269a29fa.zip
Refactor *cvt functions implementation (1/2)
This patch refactors the *cvt functions implementation in a way that
makes it easier to re-use them for implementing the IEEE long double on
powerpc64le.  By splitting the implementation per se in one file
(efgcvt-template.c) and the alias definitions in others (e.g. efgcvt.c),
the new code makes it easier to define new function names, such as
__qecvtieee128.

Tested that installed stripped binaries for all build-many-glibcs
targets remain identical before and after this patch.  Also tested for
powerpc64le and x86_64.

Reviewed-by: Paul E. Murphy <murphyp@linux.ibm.com>
Diffstat (limited to 'misc/efgcvt_r-template.c')
-rw-r--r--misc/efgcvt_r-template.c196
1 files changed, 196 insertions, 0 deletions
diff --git a/misc/efgcvt_r-template.c b/misc/efgcvt_r-template.c
new file mode 100644
index 0000000000..1cd335afe7
--- /dev/null
+++ b/misc/efgcvt_r-template.c
@@ -0,0 +1,196 @@
+/* Compatibility functions for floating point formatting, reentrant versions.
+   Copyright (C) 1995-2019 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
+   <https://www.gnu.org/licenses/>.  */
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <stdlib.h>
+#include <sys/param.h>
+#include <math_ldbl_opt.h>
+
+
+#define APPEND(a, b) APPEND2 (a, b)
+#define APPEND2(a, b) a##b
+#define __APPEND(a, b) __APPEND2 (a, b)
+#define __APPEND2(a, b) __##a##b
+
+int
+__APPEND (FUNC_PREFIX, fcvt_r) (FLOAT_TYPE value, int ndigit, int *decpt,
+				int *sign, char *buf, size_t len)
+{
+  ssize_t n;
+  ssize_t i;
+  int left;
+
+  if (buf == NULL)
+    {
+      __set_errno (EINVAL);
+      return -1;
+    }
+
+  left = 0;
+  if (isfinite (value))
+    {
+      *sign = signbit (value) != 0;
+      if (*sign)
+	value = -value;
+
+      if (ndigit < 0)
+	{
+	  /* Rounding to the left of the decimal point.  */
+	  while (ndigit < 0)
+	    {
+	      FLOAT_TYPE new_value = value * 0.1;
+
+	      if (new_value < 1.0)
+		{
+		  ndigit = 0;
+		  break;
+		}
+
+	      value = new_value;
+	      ++left;
+	      ++ndigit;
+	    }
+	}
+    }
+  else
+    /* Value is Inf or NaN.  */
+    *sign = 0;
+
+  n = __snprintf (buf, len, "%.*" FLOAT_FMT_FLAG "f", MIN (ndigit, NDIGIT_MAX),
+		  value);
+  /* Check for a too small buffer.  */
+  if (n >= (ssize_t) len)
+    return -1;
+
+  i = 0;
+  while (i < n && isdigit (buf[i]))
+    ++i;
+  *decpt = i;
+
+  if (i == 0)
+    /* Value is Inf or NaN.  */
+    return 0;
+
+  if (i < n)
+    {
+      do
+	++i;
+      while (i < n && !isdigit (buf[i]));
+
+      if (*decpt == 1 && buf[0] == '0' && value != 0.0)
+	{
+	  /* We must not have leading zeroes.  Strip them all out and
+	     adjust *DECPT if necessary.  */
+	  --*decpt;
+	  while (i < n && buf[i] == '0')
+	    {
+	      --*decpt;
+	      ++i;
+	    }
+	}
+
+      memmove (&buf[MAX (*decpt, 0)], &buf[i], n - i);
+      buf[n - (i - MAX (*decpt, 0))] = '\0';
+    }
+
+  if (left)
+    {
+      *decpt += left;
+      if ((ssize_t) --len > n)
+	{
+	  while (left-- > 0 && n < (ssize_t) len)
+	    buf[n++] = '0';
+	  buf[n] = '\0';
+	}
+    }
+
+  return 0;
+}
+
+int
+__APPEND (FUNC_PREFIX, ecvt_r) (FLOAT_TYPE value, int ndigit, int *decpt,
+				int *sign, char *buf, size_t len)
+{
+  int exponent = 0;
+
+  if (isfinite (value) && value != 0.0)
+    {
+      /* Slow code that doesn't require -lm functions.  */
+      FLOAT_TYPE d;
+      FLOAT_TYPE f = 1.0;
+      if (value < 0.0)
+	d = -value;
+      else
+	d = value;
+      /* For denormalized numbers the d < 1.0 case below won't work,
+	 as f can overflow to +Inf.  */
+      if (d < FLOAT_MIN_10_NORM)
+	{
+	  value /= FLOAT_MIN_10_NORM;
+	  if (value < 0.0)
+	    d = -value;
+	  else
+	    d = value;
+	  exponent += FLOAT_MIN_10_EXP;
+	}
+      if (d < 1.0)
+	{
+	  do
+	    {
+	      f *= 10.0;
+	      --exponent;
+	    }
+	  while (d * f < 1.0);
+
+	  value *= f;
+	}
+      else if (d >= 10.0)
+	{
+	  do
+	    {
+	      f *= 10;
+	      ++exponent;
+	    }
+	  while (d >= f * 10.0);
+
+	  value /= f;
+	}
+    }
+  else if (value == 0.0)
+    /* SUSv2 leaves it unspecified whether *DECPT is 0 or 1 for 0.0.
+       This could be changed to -1 if we want to return 0.  */
+    exponent = 0;
+
+  if (ndigit <= 0 && len > 0)
+    {
+      buf[0] = '\0';
+      *decpt = 1;
+      *sign = isfinite (value) ? signbit (value) != 0 : 0;
+    }
+  else
+    if (__APPEND (FUNC_PREFIX, fcvt_r) (value, MIN (ndigit, NDIGIT_MAX) - 1,
+					decpt, sign, buf, len))
+      return -1;
+
+  *decpt += exponent;
+  return 0;
+}