From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 26119 invoked by alias); 26 Oct 2007 00:13:36 -0000 Received: (qmail 26100 invoked by uid 22791); 26 Oct 2007 00:13:32 -0000 X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (65.74.133.4) by sourceware.org (qpsmtpd/0.31) with ESMTP; Fri, 26 Oct 2007 00:13:25 +0000 Received: (qmail 3710 invoked from network); 26 Oct 2007 00:13:22 -0000 Received: from unknown (HELO digraph.polyomino.org.uk) (joseph@127.0.0.2) by mail.codesourcery.com with ESMTPA; 26 Oct 2007 00:13:22 -0000 Received: from jsm28 (helo=localhost) by digraph.polyomino.org.uk with local-esmtp (Exim 4.63) (envelope-from ) id 1IlCpE-0004tb-N3; Fri, 26 Oct 2007 00:13:20 +0000 Date: Fri, 26 Oct 2007 00:25:00 -0000 From: "Joseph S. Myers" To: gdb-patches@sourceware.org cc: gcc-patches@gcc.gnu.org Subject: GDB/libiberty support for IBM long double Message-ID: MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2007-10/txt/msg00688.txt.bz2 [gcc-patches included because of the libiberty patch; note this part of libiberty isn't used by GCC. If approved I'll commit just the libiberty and include parts to GCC then the whole patch to src.] This patch adds 128-bit IBM long double support for Power GNU/Linux to GDB. It's based on a tree with Daniel's ABI detection patch applied. The approach taken by this patch is described in my message . The IBM long double format is the same format as used on IRIX so the mips-tdep.c kludge to use just the high part of a long double there is replaced by a use of floatformats_ibm_long_double. Tested with cross to powerpc-linux-gnu, hard-float, soft-float and -m64. OK to commit once Daniel's patch is in? include: 2007-10-25 Joseph Myers Daniel Jacobowitz * floatformat.h (struct floatformat): Add split_half field. (floatformat_ibm_long_double): New. libiberty: 2007-10-25 Joseph Myers Daniel Jacobowitz * floatformat.c (mant_bits_set): New. (floatformat_to_double): Use it. Note no special handling of split formats. (floatformat_from_double): Note no special handing of split formats. (floatformat_ibm_long_double_is_valid, floatformat_ibm_long_double): New. (floatformat_ieee_single_big, floatformat_ieee_single_little, floatformat_ieee_double_big, floatformat_ieee_double_little, floatformat_ieee_double_littlebyte_bigword, floatformat_vax_f, floatformat_vax_d, floatformat_vax_g, floatformat_i387_ext, floatformat_m68881_ext, floatformat_i960_ext, floatformat_m88110_ext, floatformat_m88110_harris_ext, floatformat_arm_ext_big, floatformat_arm_ext_littlebyte_bigword, floatformat_ia64_spill_big, floatformat_ia64_spill_little, floatformat_ia64_quad_big, floatformat_ia64_quad_little): Update for addition of split_half field. gdb: 2007-10-25 Joseph Myers Daniel Jacobowitz * gdbtypes.c (floatformats_ibm_long_double): New. * gdbtypes.h (floatformats_ibm_long_double): Declare. * ia64-tdep.c (floatformat_ia64_ext): Update for addition of split_half field. * mips-tdep.c (n32n64_floatformat_always_valid, floatformat_n32n64_long_double_big, floatformats_n32n64_long): Remove. (mips_gdbarch_init): Use floatformats_ibm_long_double instead of floatformats_n32n64_long. * ppc-linux-tdep.c (ppc_linux_init_abi): Use 128-bit IBM long double. * doublest.c (convert_floatformat_to_doublest, convert_doublest_to_floatformat): Handle split floating-point formats. * ppc-sysv-tdep.c (ppc_sysv_abi_push_dummy_call): Handle IBM long double arguments. (ppc64_sysv_abi_push_dummy_call): Likewise. (do_ppc_sysv_return_value): Handle IBM long double return. diff -rupN gdb-mainline.orig/gdb/doublest.c gdb-mainline/gdb/doublest.c --- gdb-mainline.orig/gdb/doublest.c 2007-08-23 11:08:28.000000000 -0700 +++ gdb-mainline/gdb/doublest.c 2007-10-25 15:08:22.000000000 -0700 @@ -200,6 +200,24 @@ convert_floatformat_to_doublest (const s if (order != fmt->byteorder) ufrom = newfrom; + if (fmt->split_half) + { + double dtop, dbot; + floatformat_to_double (fmt->split_half, ufrom, &dtop); + /* Preserve the sign of 0, which is the sign of the top + half. */ + if (dtop == 0.0) + { + *to = (DOUBLEST) dtop; + return; + } + floatformat_to_double (fmt->split_half, + ufrom + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2, + &dbot); + *to = (DOUBLEST) dtop + (DOUBLEST) dbot; + return; + } + exponent = get_field (ufrom, order, fmt->totalsize, fmt->exp_start, fmt->exp_len); /* Note that if exponent indicates a NaN, we can't really do anything useful @@ -392,6 +410,30 @@ convert_doublest_to_floatformat (CONST s memcpy (&dfrom, from, sizeof (dfrom)); memset (uto, 0, (fmt->totalsize + FLOATFORMAT_CHAR_BIT - 1) / FLOATFORMAT_CHAR_BIT); + + if (fmt->split_half) + { + /* Use static volatile to ensure that any excess precision is + removed via storing in memory, and so the top half really is + the result of converting to double. */ + static volatile double dtop, dbot; + double dtopnv, dbotnv; + dtop = (double) dfrom; + /* If the rounded top half is Inf, the bottom must be 0 not NaN + or Inf. */ + if (dtop + dtop == dtop && dtop != 0.0) + dbot = 0.0; + else + dbot = (double) (dfrom - (DOUBLEST) dtop); + dtopnv = dtop; + dbotnv = dbot; + floatformat_from_double (fmt->split_half, &dtopnv, uto); + floatformat_from_double (fmt->split_half, &dbotnv, + (uto + + fmt->totalsize / FLOATFORMAT_CHAR_BIT / 2)); + return; + } + if (dfrom == 0) return; /* Result is zero */ if (dfrom != dfrom) /* Result is NaN */ diff -rupN gdb-mainline.orig/gdb/gdbtypes.c gdb-mainline/gdb/gdbtypes.c --- gdb-mainline.orig/gdb/gdbtypes.c 2007-10-25 10:57:34.000000000 -0700 +++ gdb-mainline/gdb/gdbtypes.c 2007-10-25 15:08:22.000000000 -0700 @@ -95,6 +95,10 @@ const struct floatformat *floatformats_v &floatformat_vax_d, &floatformat_vax_d }; +const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN] = { + &floatformat_ibm_long_double, + &floatformat_ibm_long_double +}; struct type *builtin_type_ieee_single; struct type *builtin_type_ieee_double; diff -rupN gdb-mainline.orig/gdb/gdbtypes.h gdb-mainline/gdb/gdbtypes.h --- gdb-mainline.orig/gdb/gdbtypes.h 2007-10-25 10:57:34.000000000 -0700 +++ gdb-mainline/gdb/gdbtypes.h 2007-10-25 15:08:22.000000000 -0700 @@ -1131,6 +1131,7 @@ extern const struct floatformat *floatfo extern const struct floatformat *floatformats_ia64_quad[BFD_ENDIAN_UNKNOWN]; extern const struct floatformat *floatformats_vax_f[BFD_ENDIAN_UNKNOWN]; extern const struct floatformat *floatformats_vax_d[BFD_ENDIAN_UNKNOWN]; +extern const struct floatformat *floatformats_ibm_long_double[BFD_ENDIAN_UNKNOWN]; extern struct type *builtin_type_ieee_single; extern struct type *builtin_type_ieee_double; diff -rupN gdb-mainline.orig/gdb/ia64-tdep.c gdb-mainline/gdb/ia64-tdep.c --- gdb-mainline.orig/gdb/ia64-tdep.c 2007-10-24 13:29:14.000000000 -0700 +++ gdb-mainline/gdb/ia64-tdep.c 2007-10-25 15:08:22.000000000 -0700 @@ -329,7 +329,7 @@ floatformat_valid (const struct floatfor const struct floatformat floatformat_ia64_ext = { floatformat_little, 82, 0, 1, 17, 65535, 0x1ffff, 18, 64, - floatformat_intbit_yes, "floatformat_ia64_ext", floatformat_valid + floatformat_intbit_yes, NULL, "floatformat_ia64_ext", floatformat_valid }; const struct floatformat *floatformats_ia64_ext[2] = diff -rupN gdb-mainline.orig/gdb/mips-tdep.c gdb-mainline/gdb/mips-tdep.c --- gdb-mainline.orig/gdb/mips-tdep.c 2007-10-23 06:11:47.000000000 -0700 +++ gdb-mainline/gdb/mips-tdep.c 2007-10-25 15:08:22.000000000 -0700 @@ -199,38 +199,6 @@ struct gdbarch_tdep int register_size; }; -static int -n32n64_floatformat_always_valid (const struct floatformat *fmt, - const void *from) -{ - return 1; -} - -/* FIXME: brobecker/2004-08-08: Long Double values are 128 bit long. - They are implemented as a pair of 64bit doubles where the high - part holds the result of the operation rounded to double, and - the low double holds the difference between the exact result and - the rounded result. So "high" + "low" contains the result with - added precision. Unfortunately, the floatformat structure used - by GDB is not powerful enough to describe this format. As a temporary - measure, we define a 128bit floatformat that only uses the high part. - We lose a bit of precision but that's probably the best we can do - for now with the current infrastructure. */ - -static const struct floatformat floatformat_n32n64_long_double_big = -{ - floatformat_big, 128, 0, 1, 11, 1023, 2047, 12, 52, - floatformat_intbit_no, - "floatformat_n32n64_long_double_big", - n32n64_floatformat_always_valid -}; - -static const struct floatformat *floatformats_n32n64_long[BFD_ENDIAN_UNKNOWN] = -{ - &floatformat_n32n64_long_double_big, - &floatformat_n32n64_long_double_big -}; - const struct mips_regnum * mips_regnum (struct gdbarch *gdbarch) { @@ -5584,7 +5552,7 @@ mips_gdbarch_init (struct gdbarch_info i set_gdbarch_ptr_bit (gdbarch, 32); set_gdbarch_long_long_bit (gdbarch, 64); set_gdbarch_long_double_bit (gdbarch, 128); - set_gdbarch_long_double_format (gdbarch, floatformats_n32n64_long); + set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double); break; case MIPS_ABI_N64: set_gdbarch_push_dummy_call (gdbarch, mips_n32n64_push_dummy_call); @@ -5596,7 +5564,7 @@ mips_gdbarch_init (struct gdbarch_info i set_gdbarch_ptr_bit (gdbarch, 64); set_gdbarch_long_long_bit (gdbarch, 64); set_gdbarch_long_double_bit (gdbarch, 128); - set_gdbarch_long_double_format (gdbarch, floatformats_n32n64_long); + set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double); break; default: internal_error (__FILE__, __LINE__, _("unknown ABI in switch")); diff -rupN gdb-mainline.orig/gdb/ppc-linux-tdep.c gdb-mainline/gdb/ppc-linux-tdep.c --- gdb-mainline.orig/gdb/ppc-linux-tdep.c 2007-08-30 06:13:59.000000000 -0700 +++ gdb-mainline/gdb/ppc-linux-tdep.c 2007-10-25 15:08:22.000000000 -0700 @@ -887,15 +887,13 @@ ppc_linux_init_abi (struct gdbarch_info { struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); - /* NOTE: jimb/2004-03-26: The System V ABI PowerPC Processor - Supplement says that long doubles are sixteen bytes long. - However, as one of the known warts of its ABI, PPC GNU/Linux uses - eight-byte long doubles. GCC only recently got 128-bit long - double support on PPC, so it may be changing soon. The - Linux[sic] Standards Base says that programs that use 'long - double' on PPC GNU/Linux are non-conformant. */ - /* NOTE: cagney/2005-01-25: True for both 32- and 64-bit. */ - set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT); + /* PPC GNU/Linux uses either 64-bit or 128-bit long doubles; where + 128-bit, they are IBM long double, not IEEE quad long double as + in the System V ABI PowerPC Processor Supplement. We can safely + let them default to 128-bit, since the debug info will give the + size of type actually used in each case. */ + set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT); + set_gdbarch_long_double_format (gdbarch, floatformats_ibm_long_double); /* Handle PPC GNU/Linux 64-bit function pointers (which are really function descriptors) and 32-bit secure PLT entries. */ diff -rupN gdb-mainline.orig/gdb/ppc-sysv-tdep.c gdb-mainline/gdb/ppc-sysv-tdep.c --- gdb-mainline.orig/gdb/ppc-sysv-tdep.c 2007-10-25 14:57:44.000000000 -0700 +++ gdb-mainline/gdb/ppc-sysv-tdep.c 2007-10-25 15:08:22.000000000 -0700 @@ -53,6 +53,8 @@ ppc_sysv_abi_push_dummy_call (struct gdb int argspace = 0; /* 0 is an initial wrong guess. */ int write_pass; + gdb_assert (tdep->wordsize == 4); + regcache_cooked_read_unsigned (regcache, gdbarch_sp_regnum (current_gdbarch), &saved_sp); @@ -141,6 +143,35 @@ ppc_sysv_abi_push_dummy_call (struct gdb argoffset += 8; } } + else if (TYPE_CODE (type) == TYPE_CODE_FLT + && len == 16 + && !tdep->soft_float + && (gdbarch_long_double_format (current_gdbarch) + == floatformats_ibm_long_double)) + { + /* IBM long double passed in two FP registers if + available, otherwise 8-byte aligned stack. */ + if (freg <= 7) + { + if (write_pass) + { + regcache_cooked_write (regcache, + tdep->ppc_fp0_regnum + freg, + val); + regcache_cooked_write (regcache, + tdep->ppc_fp0_regnum + freg + 1, + val + 8); + } + freg += 2; + } + else + { + argoffset = align_up (argoffset, 8); + if (write_pass) + write_memory (sp + argoffset, val, len); + argoffset += 16; + } + } else if (len == 8 && (TYPE_CODE (type) == TYPE_CODE_INT /* long long */ || TYPE_CODE (type) == TYPE_CODE_FLT)) /* double */ @@ -159,13 +190,6 @@ ppc_sysv_abi_push_dummy_call (struct gdb write_memory (sp + argoffset, val, len); argoffset += 8; } - else if (tdep->wordsize == 8) - { - if (write_pass) - regcache_cooked_write (regcache, - tdep->ppc_gp0_regnum + greg, val); - greg += 1; - } else { /* Must start on an odd register - r3/r4 etc. */ @@ -183,6 +207,41 @@ ppc_sysv_abi_push_dummy_call (struct gdb greg += 2; } } + else if (len == 16 && TYPE_CODE (type) == TYPE_CODE_FLT + && (gdbarch_long_double_format (current_gdbarch) + == floatformats_ibm_long_double)) + { + /* Soft-float IBM long double passed in four consecutive + registers, or on the stack. The registers are not + necessarily odd/even pairs. */ + if (greg > 7) + { + greg = 11; + argoffset = align_up (argoffset, 8); + if (write_pass) + write_memory (sp + argoffset, val, len); + argoffset += 16; + } + else + { + if (write_pass) + { + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg + 0, + val + 0); + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg + 1, + val + 4); + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg + 2, + val + 8); + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg + 3, + val + 12); + } + greg += 4; + } + } else if (len == 16 && TYPE_CODE (type) == TYPE_CODE_ARRAY && TYPE_VECTOR (type) @@ -370,6 +429,55 @@ do_ppc_sysv_return_value (struct gdbarch } return RETURN_VALUE_REGISTER_CONVENTION; } + if (TYPE_CODE (type) == TYPE_CODE_FLT + && TYPE_LENGTH (type) == 16 + && !tdep->soft_float + && (gdbarch_long_double_format (current_gdbarch) + == floatformats_ibm_long_double)) + { + /* IBM long double stored in f1 and f2. */ + if (readbuf) + { + regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 1, readbuf); + regcache_cooked_read (regcache, tdep->ppc_fp0_regnum + 2, + readbuf + 8); + } + if (writebuf) + { + regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 1, writebuf); + regcache_cooked_write (regcache, tdep->ppc_fp0_regnum + 2, + writebuf + 8); + } + return RETURN_VALUE_REGISTER_CONVENTION; + } + if (TYPE_CODE (type) == TYPE_CODE_FLT + && TYPE_LENGTH (type) == 16 + && (gdbarch_long_double_format (current_gdbarch) + == floatformats_ibm_long_double)) + { + /* Soft-float IBM long double stored in r3, r4, r5, r6. */ + if (readbuf) + { + regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 3, readbuf); + regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 4, + readbuf + 4); + regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 5, + readbuf + 8); + regcache_cooked_read (regcache, tdep->ppc_gp0_regnum + 6, + readbuf + 12); + } + if (writebuf) + { + regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 3, writebuf); + regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 4, + writebuf + 4); + regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 5, + writebuf + 8); + regcache_cooked_write (regcache, tdep->ppc_gp0_regnum + 6, + writebuf + 12); + } + return RETURN_VALUE_REGISTER_CONVENTION; + } if ((TYPE_CODE (type) == TYPE_CODE_INT && TYPE_LENGTH (type) == 8) || (TYPE_CODE (type) == TYPE_CODE_FLT && TYPE_LENGTH (type) == 8)) { @@ -730,6 +838,41 @@ ppc64_sysv_abi_push_dummy_call (struct g greg++; gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize); } + else if (TYPE_CODE (type) == TYPE_CODE_FLT + && TYPE_LENGTH (type) == 16 + && (gdbarch_long_double_format (current_gdbarch) + == floatformats_ibm_long_double)) + { + /* IBM long double stored in two doublewords of the + parameter save area and corresponding registers. */ + if (write_pass) + { + if (!tdep->soft_float && freg <= 13) + { + regcache_cooked_write (regcache, + tdep->ppc_fp0_regnum + freg, + val); + if (freg <= 12) + regcache_cooked_write (regcache, + tdep->ppc_fp0_regnum + freg + 1, + val + 8); + } + if (greg <= 10) + { + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg, + val); + if (greg <= 9) + regcache_cooked_write (regcache, + tdep->ppc_gp0_regnum + greg + 1, + val + 8); + } + write_memory (gparam, val, TYPE_LENGTH (type)); + } + freg += 2; + greg += 2; + gparam = align_up (gparam + TYPE_LENGTH (type), tdep->wordsize); + } else if (TYPE_LENGTH (type) == 16 && TYPE_VECTOR (type) && TYPE_CODE (type) == TYPE_CODE_ARRAY && tdep->ppc_vr0_regnum >= 0) diff -rupN gdb-mainline.orig/include/floatformat.h gdb-mainline/include/floatformat.h --- gdb-mainline.orig/include/floatformat.h 2005-10-31 10:01:16.000000000 -0800 +++ gdb-mainline/include/floatformat.h 2007-10-25 15:08:22.000000000 -0700 @@ -80,6 +80,13 @@ struct floatformat /* Is the integer bit explicit or implicit? */ enum floatformat_intbit intbit; + /* Is the format actually the sum of two smaller floating point + formats (IBM long double, as described in + gcc/config/rs6000/darwin-ldouble-format)? If so, this is the + smaller format in question, and the fields sign_start through + intbit describe the first half. If not, this is NULL. */ + const struct floatformat *split_half; + /* Internal name for debugging. */ const char *name; @@ -118,6 +125,8 @@ extern const struct floatformat floatfor extern const struct floatformat floatformat_ia64_spill_little; extern const struct floatformat floatformat_ia64_quad_big; extern const struct floatformat floatformat_ia64_quad_little; +/* IBM long double (double+double). */ +extern const struct floatformat floatformat_ibm_long_double; /* Convert from FMT to a double. FROM is the address of the extended float. diff -rupN gdb-mainline.orig/libiberty/floatformat.c gdb-mainline/libiberty/floatformat.c --- gdb-mainline.orig/libiberty/floatformat.c 2006-11-07 07:17:40.000000000 -0800 +++ gdb-mainline/libiberty/floatformat.c 2007-10-25 15:08:22.000000000 -0700 @@ -56,6 +56,7 @@ Foundation, Inc., 51 Franklin Street - F #endif #endif +static int mant_bits_set (const struct floatformat *, const unsigned char *); static unsigned long get_field (const unsigned char *, enum floatformat_byteorders, unsigned int, @@ -81,6 +82,7 @@ const struct floatformat floatformat_iee { floatformat_big, 32, 0, 1, 8, 127, 255, 9, 23, floatformat_intbit_no, + NULL, "floatformat_ieee_single_big", floatformat_always_valid }; @@ -88,6 +90,7 @@ const struct floatformat floatformat_iee { floatformat_little, 32, 0, 1, 8, 127, 255, 9, 23, floatformat_intbit_no, + NULL, "floatformat_ieee_single_little", floatformat_always_valid }; @@ -95,6 +98,7 @@ const struct floatformat floatformat_iee { floatformat_big, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no, + NULL, "floatformat_ieee_double_big", floatformat_always_valid }; @@ -102,6 +106,7 @@ const struct floatformat floatformat_iee { floatformat_little, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no, + NULL, "floatformat_ieee_double_little", floatformat_always_valid }; @@ -113,6 +118,7 @@ const struct floatformat floatformat_iee { floatformat_littlebyte_bigword, 64, 0, 1, 11, 1023, 2047, 12, 52, floatformat_intbit_no, + NULL, "floatformat_ieee_double_littlebyte_bigword", floatformat_always_valid }; @@ -123,6 +129,7 @@ const struct floatformat floatformat_vax { floatformat_vax, 32, 0, 1, 8, 129, 0, 9, 23, floatformat_intbit_no, + NULL, "floatformat_vax_f", floatformat_always_valid }; @@ -130,6 +137,7 @@ const struct floatformat floatformat_vax { floatformat_vax, 64, 0, 1, 8, 129, 0, 9, 55, floatformat_intbit_no, + NULL, "floatformat_vax_d", floatformat_always_valid }; @@ -137,6 +145,7 @@ const struct floatformat floatformat_vax { floatformat_vax, 64, 0, 1, 11, 1025, 0, 12, 52, floatformat_intbit_no, + NULL, "floatformat_vax_g", floatformat_always_valid }; @@ -169,6 +178,7 @@ const struct floatformat floatformat_i38 { floatformat_little, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, floatformat_intbit_yes, + NULL, "floatformat_i387_ext", floatformat_i387_ext_is_valid }; @@ -177,6 +187,7 @@ const struct floatformat floatformat_m68 /* Note that the bits from 16 to 31 are unused. */ floatformat_big, 96, 0, 1, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, + NULL, "floatformat_m68881_ext", floatformat_always_valid }; @@ -185,6 +196,7 @@ const struct floatformat floatformat_i96 /* Note that the bits from 0 to 15 are unused. */ floatformat_little, 96, 16, 17, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, + NULL, "floatformat_i960_ext", floatformat_always_valid }; @@ -192,6 +204,7 @@ const struct floatformat floatformat_m88 { floatformat_big, 80, 0, 1, 15, 0x3fff, 0x7fff, 16, 64, floatformat_intbit_yes, + NULL, "floatformat_m88110_ext", floatformat_always_valid }; @@ -201,6 +214,7 @@ const struct floatformat floatformat_m88 double, and the last 64 bits are wasted. */ floatformat_big,128, 0, 1, 11, 0x3ff, 0x7ff, 12, 52, floatformat_intbit_no, + NULL, "floatformat_m88110_ext_harris", floatformat_always_valid }; @@ -209,6 +223,7 @@ const struct floatformat floatformat_arm /* Bits 1 to 16 are unused. */ floatformat_big, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, + NULL, "floatformat_arm_ext_big", floatformat_always_valid }; @@ -217,6 +232,7 @@ const struct floatformat floatformat_arm /* Bits 1 to 16 are unused. */ floatformat_littlebyte_bigword, 96, 0, 17, 15, 0x3fff, 0x7fff, 32, 64, floatformat_intbit_yes, + NULL, "floatformat_arm_ext_littlebyte_bigword", floatformat_always_valid }; @@ -224,6 +240,7 @@ const struct floatformat floatformat_ia6 { floatformat_big, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, floatformat_intbit_yes, + NULL, "floatformat_ia64_spill_big", floatformat_always_valid }; @@ -231,6 +248,7 @@ const struct floatformat floatformat_ia6 { floatformat_little, 128, 0, 1, 17, 65535, 0x1ffff, 18, 64, floatformat_intbit_yes, + NULL, "floatformat_ia64_spill_little", floatformat_always_valid }; @@ -238,6 +256,7 @@ const struct floatformat floatformat_ia6 { floatformat_big, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, floatformat_intbit_no, + NULL, "floatformat_ia64_quad_big", floatformat_always_valid }; @@ -245,15 +264,138 @@ const struct floatformat floatformat_ia6 { floatformat_little, 128, 0, 1, 15, 16383, 0x7fff, 16, 112, floatformat_intbit_no, + NULL, "floatformat_ia64_quad_little", floatformat_always_valid }; + +static int +floatformat_ibm_long_double_is_valid (const struct floatformat *fmt, + const void *from) +{ + const unsigned char *ufrom = (const unsigned char *) from; + const struct floatformat *hfmt = fmt->split_half; + long top_exp, bot_exp; + int top_nan = 0; + + top_exp = get_field (ufrom, hfmt->byteorder, hfmt->totalsize, + hfmt->exp_start, hfmt->exp_len); + bot_exp = get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize, + hfmt->exp_start, hfmt->exp_len); + + if (top_exp == hfmt->exp_nan) + top_nan = mant_bits_set (hfmt, ufrom); + + /* A NaN is valid with any low part. */ + if (top_nan) + return 1; + + /* An infinity, zero or denormal requires low part 0 (positive or + negative). */ + if (top_exp == hfmt->exp_nan || top_exp == 0) + { + unsigned int mant_bits, mant_off; + int mant_bits_left; + + if (bot_exp != 0) + return 0; + + return !mant_bits_set (hfmt, ufrom + 8); + } + + /* The top part is now a finite normal value. The long double value + is the sum of the two parts, and the top part must equal the + result of rounding the long double value to nearest double. Thus + the bottom part must be <= 0.5ulp of the top part in absolute + value, and if it is < 0.5ulp then the long double is definitely + valid. */ + if (bot_exp < top_exp - 53) + return 1; + if (bot_exp > top_exp - 53 && bot_exp != 0) + return 0; + if (bot_exp == 0) + { + /* The bottom part is 0 or denormal. Determine which, and if + denormal the first two set bits. */ + int first_bit = -1, second_bit = -1, cur_bit; + for (cur_bit = 0; cur_bit < hfmt->man_len; cur_bit++) + if (get_field (ufrom + 8, hfmt->byteorder, hfmt->totalsize, + hfmt->man_start + cur_bit, 1)) + { + if (first_bit == -1) + first_bit = cur_bit; + else + { + second_bit = cur_bit; + break; + } + } + /* Bottom part 0 is OK. */ + if (first_bit == -1) + return 1; + /* The real exponent of the bottom part is -first_bit. */ + if (-first_bit < top_exp - 53) + return 1; + if (-first_bit > top_exp - 53) + return 0; + /* The bottom part is at least 0.5ulp of the top part. For this + to be OK, the bottom part must be exactly 0.5ulp (i.e. no + more bits set) and the top part must have last bit 0. */ + if (second_bit != -1) + return 0; + return !get_field (ufrom, hfmt->byteorder, hfmt->totalsize, + hfmt->man_start + hfmt->man_len - 1, 1); + } + else + { + /* The bottom part is at least 0.5ulp of the top part. For this + to be OK, it must be exactly 0.5ulp (i.e. no explicit bits + set) and the top part must have last bit 0. */ + if (get_field (ufrom, hfmt->byteorder, hfmt->totalsize, + hfmt->man_start + hfmt->man_len - 1, 1)) + return 0; + return !mant_bits_set (hfmt, ufrom + 8); + } +} + +const struct floatformat floatformat_ibm_long_double = +{ + floatformat_big, 128, 0, 1, 11, 1023, 2047, 12, 52, + floatformat_intbit_no, + &floatformat_ieee_double_big, + "floatformat_ibm_long_double", + floatformat_always_valid +}; #ifndef min #define min(a, b) ((a) < (b) ? (a) : (b)) #endif +/* Return 1 if any bits are explicitly set in the mantissa of UFROM, + format FMT, 0 otherwise. */ +static int +mant_bits_set (const struct floatformat *fmt, const unsigned char *ufrom) +{ + unsigned int mant_bits, mant_off; + int mant_bits_left; + + mant_off = fmt->man_start; + mant_bits_left = fmt->man_len; + while (mant_bits_left > 0) + { + mant_bits = min (mant_bits_left, 32); + + if (get_field (ufrom, fmt->byteorder, fmt->totalsize, + mant_off, mant_bits) != 0) + return 1; + + mant_off += mant_bits; + mant_bits_left -= mant_bits; + } + return 0; +} + /* Extract a field which starts at START and is LEN bits long. DATA and TOTAL_LEN are the thing we are extracting it from, in byteorder ORDER. */ static unsigned long @@ -310,6 +452,10 @@ floatformat_to_double (const struct floa int mant_bits_left; int special_exponent; /* It's a NaN, denorm or zero */ + /* Split values are not handled specially, since the top half has + the correctly rounded double value (in the only supported case of + split values). */ + exponent = get_field (ufrom, fmt->byteorder, fmt->totalsize, fmt->exp_start, fmt->exp_len); @@ -318,26 +464,7 @@ floatformat_to_double (const struct floa don't try to preserve the type of NaN. FIXME. */ if ((unsigned long) exponent == fmt->exp_nan) { - int nan; - - mant_off = fmt->man_start; - mant_bits_left = fmt->man_len; - nan = 0; - while (mant_bits_left > 0) - { - mant_bits = min (mant_bits_left, 32); - - if (get_field (ufrom, fmt->byteorder, fmt->totalsize, - mant_off, mant_bits) != 0) - { - /* This is a NaN. */ - nan = 1; - break; - } - - mant_off += mant_bits; - mant_bits_left -= mant_bits; - } + int nan = mant_bits_set (fmt, ufrom); /* On certain systems (such as GNU/Linux), the use of the INFINITY macro below may generate a warning that can not be @@ -474,6 +601,10 @@ floatformat_from_double (const struct fl dfrom = *from; memset (uto, 0, fmt->totalsize / FLOATFORMAT_CHAR_BIT); + /* Split values are not handled specially, since a bottom half of + zero is correct for any value representable as double (in the + only supported case of split values). */ + /* If negative, set the sign bit. */ if (dfrom < 0) { -- Joseph S. Myers joseph@codesourcery.com