configure.in (ia64-*): Set float_format for i386 long double.

	* configure.in (ia64-*): Set float_format for i386 long double.

	* real.c (GET_REAL): Treat 128-bit INTEL_EXTENDED_IEEE_FORMAT
	as we would for i386 XFmode.
	(PUT_REAL): Likewise.
	(endian, ereal_atof, real_value_truncate): Likewise.
	(ereal_isneg, toe64, etens, make_nan): Likewise.
	* real.h (REAL_VALUE_TO_TARGET_LONG_DOUBLE): Likewise.

	* config/ia64/ia64-protos.h: Update.
	* config/ia64/ia64.c (general_tfmode_operand): New.
	(destination_tfmode_operand): New.
	(tfreg_or_fp01_operand): New.
	(ia64_split_timode): New.
	(spill_tfmode_operand): New.
	(ia64_expand_prologue): Use TFmode not XFmode.
	(ia64_expand_epilogue): Likewise.
	(ia64_function_arg): Likewise.
	(ia64_function_arg_advance): Likewise.
	(ia64_return_in_memory): Likewise.
	(ia64_function_value): Likewise.
	(ia64_print_operand): Likewise.
	(ia64_register_move_cost): Set GR<->FR to 5.
	(ia64_secondary_reload_class): Get GR for TImode memory op.
	* config/ia64/ia64.h (ROUND_TYPE_SIZE): Remove.
	(ROUND_TYPE_ALIGN): Remove.
	(LONG_DOUBLE_TYPE_SIZE): Set to 128.
	(INTEL_EXTENDED_IEEE_FORMAT): Define.
	(HARD_REGNO_NREGS): Use TFmode, not XFmode.
	(HARD_REGNO_MODE_OK): Likewise.  Disallow TImode in FRs.
	(MODES_TIEABLE_P): Use TFmode, not XFmode.
	(CLASS_MAX_NREGS): Likewise.
	(ASM_OUTPUT_LONG_DOUBLE): Output by 4 byte hunks.
	(PREDICATE_CODES): Update.
	* config/ia64/ia64.md (movti): New.
	(movti_internal): Use a clobber for memory alternatives.
	(reload_inti, reload_outti): New.
	(movsfcc_astep): Predicate properly.
	(movdfcc_astep): Likewise.
	(movxf): Remove.
	(movtf): New.
	(extendsftf2, extenddftf2): New.
	(trunctfsf2, trunctfdf2): New.
	(floatditf2, fix_trunctfdi2): New.
	(floatunsditf2, fixuns_trunctfdi2): New.
	(addtf3, subtf3, multf3, abstf2): New.
	(negtf2, nabstf2, mintf3, maxtf3): New.
	(maddtf3, msubtf3, nmultf3, nmaddtf3): New.
	(cmptf): New.
	(fr_spill): Use TFmode, not XFmode.
	(fr_restore): Likewise.
	* config/ia64/lib1funcs.asm (__divtf3): New.
	* config/ia64/t-ia64 (LIB1ASMFUNCS): Add it.

From-SVN: r35689

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6490782e2eab813b7b041b320fb6968728037bfc..854912c06b2a77697c7dca993900e7ed0eef0f7d 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,59 @@
+2000-08-14  Richard Henderson  <rth@cygnus.com>
+
+       * configure.in (ia64-*): Set float_format for i386 long double.
+
+       * real.c (GET_REAL): Treat 128-bit INTEL_EXTENDED_IEEE_FORMAT
+       as we would for i386 XFmode.
+       (PUT_REAL): Likewise.
+       (endian, ereal_atof, real_value_truncate): Likewise.
+       (ereal_isneg, toe64, etens, make_nan): Likewise.
+       * real.h (REAL_VALUE_TO_TARGET_LONG_DOUBLE): Likewise.
+
+       * config/ia64/ia64-protos.h: Update.
+       * config/ia64/ia64.c (general_tfmode_operand): New.
+       (destination_tfmode_operand): New.
+       (tfreg_or_fp01_operand): New.
+       (ia64_split_timode): New.
+       (spill_tfmode_operand): New.
+       (ia64_expand_prologue): Use TFmode not XFmode.
+       (ia64_expand_epilogue): Likewise.
+       (ia64_function_arg): Likewise.
+       (ia64_function_arg_advance): Likewise.
+       (ia64_return_in_memory): Likewise.
+       (ia64_function_value): Likewise.
+       (ia64_print_operand): Likewise.
+       (ia64_register_move_cost): Set GR<->FR to 5.
+       (ia64_secondary_reload_class): Get GR for TImode memory op.
+       * config/ia64/ia64.h (ROUND_TYPE_SIZE): Remove.
+       (ROUND_TYPE_ALIGN): Remove.
+       (LONG_DOUBLE_TYPE_SIZE): Set to 128.
+       (INTEL_EXTENDED_IEEE_FORMAT): Define.
+       (HARD_REGNO_NREGS): Use TFmode, not XFmode.
+       (HARD_REGNO_MODE_OK): Likewise.  Disallow TImode in FRs.
+       (MODES_TIEABLE_P): Use TFmode, not XFmode.
+       (CLASS_MAX_NREGS): Likewise.
+       (ASM_OUTPUT_LONG_DOUBLE): Output by 4 byte hunks.
+       (PREDICATE_CODES): Update.
+       * config/ia64/ia64.md (movti): New.
+       (movti_internal): Use a clobber for memory alternatives.
+       (reload_inti, reload_outti): New.
+       (movsfcc_astep): Predicate properly.
+       (movdfcc_astep): Likewise.
+       (movxf): Remove.
+       (movtf): New.
+       (extendsftf2, extenddftf2): New.
+       (trunctfsf2, trunctfdf2): New.
+       (floatditf2, fix_trunctfdi2): New.
+       (floatunsditf2, fixuns_trunctfdi2): New.
+       (addtf3, subtf3, multf3, abstf2): New.
+       (negtf2, nabstf2, mintf3, maxtf3): New.
+       (maddtf3, msubtf3, nmultf3, nmaddtf3): New.
+       (cmptf): New.
+       (fr_spill): Use TFmode, not XFmode.
+       (fr_restore): Likewise.
+       * config/ia64/lib1funcs.asm (__divtf3): New.
+       * config/ia64/t-ia64 (LIB1ASMFUNCS): Add it.
+
 2000-08-14  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
        * cse.c (fold_rtx): Avoid empty body in an if-statement.

diff --git a/gcc/config/ia64/ia64-protos.h b/gcc/config/ia64/ia64-protos.h
index 30f1d61089a1c28894f31bf62c90d6f7b4bad58a..af120609ca86391c0f881b1e9d1b349dd69e73e5 100644 (file)
--- a/gcc/config/ia64/ia64-protos.h
+++ b/gcc/config/ia64/ia64-protos.h
@@ -59,9 +59,14 @@ extern int ia64_direct_return PARAMS((void));
 extern int predicate_operator PARAMS((rtx, enum machine_mode));
 extern int ar_lc_reg_operand PARAMS((rtx, enum machine_mode));
 extern int ar_ccv_reg_operand PARAMS((rtx, enum machine_mode));
+extern int general_tfmode_operand PARAMS((rtx, enum machine_mode));
+extern int destination_tfmode_operand PARAMS((rtx, enum machine_mode));
+extern int tfreg_or_fp01_operand PARAMS((rtx, enum machine_mode));
 
 extern int ia64_move_ok PARAMS((rtx, rtx));
 extern rtx ia64_gp_save_reg PARAMS((int));
+extern rtx ia64_split_timode PARAMS((rtx[], rtx, rtx));
+extern rtx spill_tfmode_operand PARAMS((rtx, int));
 
 extern void ia64_expand_load_address PARAMS((rtx, rtx));
 extern void ia64_expand_fetch_and_op PARAMS ((enum fetchop_code,
@@ -112,6 +117,3 @@ extern void ia64_output_end_prologue PARAMS((FILE *));
 extern void ia64_init_builtins PARAMS((void));
 extern void ia64_override_options PARAMS((void));
 extern int ia64_dbx_register_number PARAMS((int));
-
-/* ??? Flag defined in toplev.c, for ia64.md -fssa hack.  */
-extern int flag_ssa;

diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c
index f090402eda43ffa108b18ceed5e504d95351e4f4..44bc8d86dee7c555c2507ff2d5306df6cda33393 100644 (file)
--- a/gcc/config/ia64/ia64.c
+++ b/gcc/config/ia64/ia64.c
@@ -570,6 +570,46 @@ ar_ccv_reg_operand (op, mode)
          && GET_CODE (op) == REG
          && REGNO (op) == AR_CCV_REGNUM);
 }
+
+/* Like general_operand, but don't allow (mem (addressof)).  */
+
+int
+general_tfmode_operand (op, mode)
+     rtx op;
+     enum machine_mode mode;
+{
+  if (! general_operand (op, mode))
+    return 0;
+  if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == ADDRESSOF)
+    return 0;
+  return 1;
+}
+
+/* Similarly.  */
+
+int
+destination_tfmode_operand (op, mode)
+     rtx op;
+     enum machine_mode mode;
+{
+  if (! destination_operand (op, mode))
+    return 0;
+  if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == ADDRESSOF)
+    return 0;
+  return 1;
+}
+
+/* Similarly.  */
+
+int
+tfreg_or_fp01_operand (op, mode)
+     rtx op;
+     enum machine_mode mode;
+{
+  if (GET_CODE (op) == SUBREG)
+    return 0;
+  return reg_or_fp01_operand (op, mode);
+}
 \f
 /* Return 1 if the operands of a move are ok.  */
 
@@ -681,6 +721,106 @@ ia64_gp_save_reg (setjmp_p)
 
   return save;
 }
+
+/* Split a post-reload TImode reference into two DImode components.  */
+
+rtx
+ia64_split_timode (out, in, scratch)
+     rtx out[2];
+     rtx in, scratch;
+{
+  switch (GET_CODE (in))
+    {
+    case REG:
+      out[0] = gen_rtx_REG (DImode, REGNO (in));
+      out[1] = gen_rtx_REG (DImode, REGNO (in) + 1);
+      return NULL_RTX;
+
+    case MEM:
+      {
+       HOST_WIDE_INT offset;
+       rtx base = XEXP (in, 0);
+       rtx offset_rtx;
+
+       switch (GET_CODE (base))
+         {
+         case REG:
+           out[0] = change_address (in, DImode, NULL_RTX);
+           break;
+         case POST_MODIFY:
+           base = XEXP (base, 0);
+           out[0] = change_address (in, DImode, NULL_RTX);
+           break;
+
+         /* Since we're changing the mode, we need to change to POST_MODIFY
+            as well to preserve the size of the increment.  Either that or
+            do the update in two steps, but we've already got this scratch
+            register handy so let's use it.  */
+         case POST_INC:
+           base = XEXP (base, 0);
+           out[0] = change_address (in, DImode,
+             gen_rtx_POST_MODIFY (Pmode, base,plus_constant (base, 16)));
+           break;
+         case POST_DEC:
+           base = XEXP (base, 0);
+           out[0] = change_address (in, DImode,
+             gen_rtx_POST_MODIFY (Pmode, base,plus_constant (base, -16)));
+           break;
+         default:
+           abort ();
+         }
+
+       if (scratch == NULL_RTX)
+         abort ();
+       out[1] = change_address (in, DImode, scratch);
+       return gen_adddi3 (scratch, base, GEN_INT (8));
+      }
+
+    case CONST_INT:
+    case CONST_DOUBLE:
+      split_double (in, &out[0], &out[1]);
+      return NULL_RTX;
+
+    default:
+      abort ();
+    }
+}
+
+/* ??? Fixing GR->FR TFmode moves during reload is hard.  You need to go
+   through memory plus an extra GR scratch register.  Except that you can
+   either get the first from SECONDARY_MEMORY_NEEDED or the second from
+   SECONDARY_RELOAD_CLASS, but not both.
+
+   We got into problems in the first place by allowing a construct like
+   (subreg:TF (reg:TI)), which we got from a union containing a long double.  
+   This solution attempts to prevent this situation from ocurring.  When
+   we see something like the above, we spill the inner register to memory.  */
+
+rtx
+spill_tfmode_operand (in, force)
+     rtx in;
+     int force;
+{
+  if (GET_CODE (in) == SUBREG
+      && GET_MODE (SUBREG_REG (in)) == TImode
+      && GET_CODE (SUBREG_REG (in)) == REG)
+    {
+      rtx mem = gen_mem_addressof (SUBREG_REG (in), NULL_TREE);
+      return gen_rtx_MEM (TFmode, copy_to_reg (XEXP (mem, 0)));
+    }
+  else if (force && GET_CODE (in) == REG)
+    {
+      rtx mem = gen_mem_addressof (in, NULL_TREE);
+      return gen_rtx_MEM (TFmode, copy_to_reg (XEXP (mem, 0)));
+    }
+  else if (GET_CODE (in) == MEM
+          && GET_CODE (XEXP (in, 0)) == ADDRESSOF)
+    {
+      return change_address (in, TFmode, copy_to_reg (XEXP (in, 0)));
+    }
+  else
+    return in;
+}
 \f
 /* Begin the assembly file.  */
 
@@ -1702,7 +1842,7 @@ ia64_expand_prologue ()
       {
         if (cfa_off & 15)
          abort ();
-       reg = gen_rtx_REG (XFmode, regno);
+       reg = gen_rtx_REG (TFmode, regno);
        do_spill (gen_fr_spill_x, reg, cfa_off, reg);
        cfa_off -= 16;
       }
@@ -1867,7 +2007,7 @@ ia64_expand_epilogue ()
       {
         if (cfa_off & 15)
          abort ();
-       reg = gen_rtx_REG (XFmode, regno);
+       reg = gen_rtx_REG (TFmode, regno);
        do_restore (gen_fr_restore_x, reg, cfa_off);
        cfa_off -= 16;
       }
@@ -2304,7 +2444,6 @@ ia64_function_arg (cum, mode, type, named, incoming)
                                      gen_rtx_REG (hfa_mode, (FR_ARG_FIRST
                                                              + fp_regs)),
                                      GEN_INT (offset));
-         /* ??? Padding for XFmode type?  */
          offset += hfa_size;
          args_byte_size += hfa_size;
          fp_regs++;
@@ -2484,7 +2623,6 @@ ia64_function_arg_advance (cum, mode, type, named)
       for (; (offset < byte_size && fp_regs < MAX_ARGUMENT_SLOTS
              && args_byte_size < (MAX_ARGUMENT_SLOTS * UNITS_PER_WORD));)
        {
-         /* ??? Padding for XFmode type?  */
          offset += hfa_size;
          args_byte_size += hfa_size;
          fp_regs++;
@@ -2586,7 +2724,6 @@ ia64_return_in_memory (valtype)
     {
       int hfa_size = GET_MODE_SIZE (hfa_mode);
 
-      /* ??? Padding for XFmode type?  */
       if (byte_size / hfa_size > MAX_ARGUMENT_SLOTS)
        return 1;
       else
@@ -2629,7 +2766,6 @@ ia64_function_value (valtype, func)
          loc[i] = gen_rtx_EXPR_LIST (VOIDmode,
                                      gen_rtx_REG (hfa_mode, FR_ARG_FIRST + i),
                                      GEN_INT (offset));
-         /* ??? Padding for XFmode type?  */
          offset += hfa_size;
        }
 
@@ -2782,19 +2918,10 @@ ia64_print_operand (file, x, code)
 
          case POST_INC:
            value = GET_MODE_SIZE (GET_MODE (x));
-
-           /* ??? This is for ldf.fill and stf.spill which use XFmode,
-              but which actually need 16 bytes increments.  Perhaps we
-              can change them to use TFmode instead.  Or don't use
-              POST_DEC/POST_INC for them.  */
-           if (value == 12)
-             value = 16;
            break;
 
          case POST_DEC:
            value = - (HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (x));
-           if (value == -12)
-             value = -16;
            break;
          }
 
@@ -2930,17 +3057,28 @@ ia64_register_move_cost (from, to)
 {
   int from_hard, to_hard;
   int from_gr, to_gr;
+  int from_fr, to_fr;
 
   from_hard = (from == BR_REGS || from == AR_M_REGS || from == AR_I_REGS);
   to_hard = (to == BR_REGS || to == AR_M_REGS || to == AR_I_REGS);
   from_gr = (from == GENERAL_REGS);
   to_gr = (to == GENERAL_REGS);
+  from_fr = (from == FR_REGS);
+  to_fr = (to == FR_REGS);
 
   if (from_hard && to_hard)
     return 8;
   else if ((from_hard && !to_gr) || (!from_gr && to_hard))
     return 6;
 
+  /* ??? Moving from FR<->GR must be more expensive than 2, so that we get
+     secondary memory reloads for TFmode moves.  Unfortunately, we don't
+     have the mode here, so we can't check that.  */
+  /* Moreover, we have to make this at least as high as MEMORY_MOVE_COST
+     to avoid spectacularly poor register class preferencing for TFmode.  */
+  else if (from_fr != to_fr)
+    return 5;
+
   return 2;
 }
 
@@ -3018,6 +3156,13 @@ ia64_secondary_reload_class (class, mode, x)
        return GR_REGS;
       break;
 
+    case GR_REGS:
+      /* Since we have no offsettable memory addresses, we need a temporary
+        to hold the address of the second word.  */
+      if (mode == TImode)
+       return GR_REGS;
+      break;
+
     default:
       break;
     }

diff --git a/gcc/config/ia64/ia64.h b/gcc/config/ia64/ia64.h
index bb1e038cdb48b40587ca1bac9a337e692d44bd6a..90717b8a14d0835033e78aeca47da42dbe5f4b73 100644 (file)
--- a/gcc/config/ia64/ia64.h
+++ b/gcc/config/ia64/ia64.h
@@ -383,23 +383,6 @@ while (0)
    a field, not crossing a boundary for it.  */
 #define PCC_BITFIELD_TYPE_MATTERS 1
 
-/* Define this macro as an expression for the overall size of a structure
-   (given by STRUCT as a tree node) when the size computed from the fields is
-   SIZE and the alignment is ALIGN.
-
-   The default is to round SIZE up to a multiple of ALIGN.  */
-/* ??? Might need this for 80-bit double-extended floats.  */
-/* #define ROUND_TYPE_SIZE(STRUCT, SIZE, ALIGN) */
-
-/* Define this macro as an expression for the alignment of a structure (given
-   by STRUCT as a tree node) if the alignment computed in the usual way is
-   COMPUTED and the alignment explicitly specified was SPECIFIED.
-
-   The default is to use SPECIFIED if it is larger; otherwise, use the smaller
-   of COMPUTED and `BIGGEST_ALIGNMENT' */
-/* ??? Might need this for 80-bit double-extended floats.  */
-/* #define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED) */
-
 /* An integer expression for the size in bits of the largest integer machine
    mode that should actually be used.  */
 
@@ -465,8 +448,11 @@ while (0)
 
 /* A C expression for the size in bits of the type `long double' on the target
    machine.  If you don't define this, the default is two words.  */
-/* ??? We have an 80 bit extended double format.  */
-#define LONG_DOUBLE_TYPE_SIZE 64
+#define LONG_DOUBLE_TYPE_SIZE 128
+
+/* Tell real.c that this is the 80-bit Intel extended float format
+   packaged in a 128-bit entity.  */
+#define INTEL_EXTENDED_IEEE_FORMAT
 
 /* An expression whose value is 1 or 0, according to whether the type `char'
    should be signed or unsigned by default.  The user can always override this
@@ -812,7 +798,6 @@ while (0)
 /* A C expression for the number of consecutive hard registers, starting at
    register number REGNO, required to hold a value of mode MODE.  */
 
-/* ??? x86 80-bit FP values only require 1 register.  */
 /* ??? We say that CCmode values require two registers.  This allows us to
    easily store the normal and inverted values.  We use CCImode to indicate
    a single predicate register.  */
@@ -821,19 +806,20 @@ while (0)
   ((REGNO) == PR_REG (0) && (MODE) == DImode ? 64                      \
    : PR_REGNO_P (REGNO) && (MODE) == CCmode ? 2                                \
    : PR_REGNO_P (REGNO) && (MODE) == CCImode ? 1                       \
-   : FR_REGNO_P (REGNO) && (MODE) == XFmode ? 1                                \
+   : FR_REGNO_P (REGNO) && (MODE) == TFmode ? 1                                \
    : (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 
 /* A C expression that is nonzero if it is permissible to store a value of mode
    MODE in hard register number REGNO (or in several registers starting with
    that one).  */
 
-#define HARD_REGNO_MODE_OK(REGNO, MODE) \
-  (FR_REGNO_P (REGNO) ? GET_MODE_CLASS (MODE) != MODE_CC               \
+#define HARD_REGNO_MODE_OK(REGNO, MODE)                                        \
+  (FR_REGNO_P (REGNO) ? GET_MODE_CLASS (MODE) != MODE_CC && (MODE) != TImode \
    : PR_REGNO_P (REGNO) ? GET_MODE_CLASS (MODE) == MODE_CC             \
-   : GR_REGNO_P (REGNO) ? (MODE) != XFmode && (MODE) != CCImode                \
+   : GR_REGNO_P (REGNO) ? (MODE) != CCImode && (MODE) != TFmode                \
    : AR_REGNO_P (REGNO) ? (MODE) == DImode                             \
-   : 1)
+   : BR_REGNO_P (REGNO) ? (MODE) == DImode                             \
+   : 0)
 
 /* A C expression that is nonzero if it is desirable to choose register
    allocation so as to avoid move instructions between a value of mode MODE1
@@ -846,11 +832,11 @@ while (0)
    INTEGRAL_MODE_P or FLOAT_MODE_P and the other is not.  Otherwise, it is
    true.  */
 /* Don't tie integer and FP modes, as that causes us to get integer registers
-   allocated for FP instructions.  XFmode only supported in FP registers at
-   the moment, so we can't tie it with any other modes.  */
+   allocated for FP instructions.  TFmode only supported in FP registers so
+   we can't tie it with any other modes.  */
 #define MODES_TIEABLE_P(MODE1, MODE2) \
   ((GET_MODE_CLASS (MODE1) == GET_MODE_CLASS (MODE2)) \
-   && (((MODE1) == XFmode) == ((MODE2) == XFmode)))
+   && (((MODE1) == TFmode) == ((MODE2) == TFmode)))
 
 /* Define this macro if the compiler should avoid copies to/from CCmode
    registers.  You should only define this macro if support fo copying to/from
@@ -1044,10 +1030,16 @@ enum reg_class
    registers of CLASS1 can only be copied to registers of class CLASS2 by
    storing a register of CLASS1 into memory and loading that memory location
    into a register of CLASS2.  */
-/* ??? We may need this for XFmode moves between FR and GR regs.  Using
-   getf.sig/getf.exp almost works, but the result in the GR regs is not
-   properly formatted and has two extra bits.  */
-/* #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, M) */
+
+#if 0
+/* ??? May need this, but since we've disallowed TFmode in GR_REGS,
+   I'm not quite sure how it could be invoked.  The normal problems
+   with unions should be solved with the addressof fiddling done by
+   movtf and friends.  */
+#define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE)                  \
+  ((MODE) == TFmode && (((CLASS1) == GR_REGS && (CLASS2) == FR_REGS)   \
+                       || ((CLASS1) == FR_REGS && (CLASS2) == GR_REGS)))
+#endif
 
 /* A C expression for the maximum number of consecutive registers of
    class CLASS needed to hold a value of mode MODE.
@@ -1055,7 +1047,7 @@ enum reg_class
 
 #define CLASS_MAX_NREGS(CLASS, MODE) \
   ((MODE) == CCmode && (CLASS) == PR_REGS ? 2                  \
-   : ((CLASS) == FR_REGS && (MODE) == XFmode) ? 1              \
+   : ((CLASS) == FR_REGS && (MODE) == TFmode) ? 1              \
    : (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
 
 /* If defined, gives a class of registers that cannot be used as the
@@ -1786,11 +1778,7 @@ do {                                                                     \
    on the machine mode of the memory reference it is used for or if the address
    is valid for some modes but not others.  */
 
-/* ??? Strictly speaking this isn't true, because we can use any increment with
-   any mode.  Unfortunately, the RTL implies that the increment depends on the
-   mode, so we need this for now.  */
-
-#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL) \
+#define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR, LABEL)                      \
   if (GET_CODE (ADDR) == POST_DEC || GET_CODE (ADDR) == POST_INC)      \
     goto LABEL;
 
@@ -1996,20 +1984,17 @@ do {                                                                    \
 /* Output of Data.  */
 
 /* A C statement to output to the stdio stream STREAM an assembler instruction
-   to assemble a floating-point constant of `XFmode', `DFmode', `SFmode',
+   to assemble a floating-point constant of `TFmode', `DFmode', `SFmode',
    respectively, whose value is VALUE.  */
 
-/* ??? This has not been tested.  Long doubles are really 10 bytes not 12
-   bytes on ia64.  */
-
 /* ??? Must reverse the word order for big-endian code?  */
 
 #define ASM_OUTPUT_LONG_DOUBLE(FILE, VALUE) \
 do {                                                                   \
   long t[3];                                                           \
   REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, t);                         \
-  fprintf (FILE, "\tdata8 0x%08lx, 0x%08lx, 0x%08lx\n",                        \
-          t[0] & 0xffffffff, t[1] & 0xffffffff, t[2] & 0xffffffff);    \
+  fprintf (FILE, "\tdata4 0x%08lx, 0x%08lx, 0x%08lx, 0x%08lx\n",       \
+          t[0] & 0xffffffff, t[1] & 0xffffffff, t[2] & 0xffffffff, 0); \
 } while (0)
 
 /* ??? Must reverse the word order for big-endian code?  */
@@ -2667,13 +2652,16 @@ do {                                                                    \
                                  CONSTANT_P_RTX}},                     \
 { "shladd_operand", {CONST_INT}},                                      \
 { "fetchadd_operand", {CONST_INT}},                                    \
-{ "reg_or_fp01_operand", {SUBREG, REG, CONST_DOUBLE, CONSTANT_P_RTX}}, \
+{ "reg_or_fp01_operand", {SUBREG, REG, CONST_DOUBLE}},                 \
 { "normal_comparison_operator", {EQ, NE, GT, LE, GTU, LEU}},           \
 { "adjusted_comparison_operator", {LT, GE, LTU, GEU}},                 \
 { "call_multiple_values_operation", {PARALLEL}},                       \
 { "predicate_operator", {NE, EQ}},                                     \
 { "ar_lc_reg_operand", {REG}},                                         \
-{ "ar_ccv_reg_operand", {REG}},
+{ "ar_ccv_reg_operand", {REG}},                                                \
+{ "general_tfmode_operand", {SUBREG, REG, CONST_DOUBLE, MEM}},         \
+{ "destination_tfmode_operand", {SUBREG, REG, MEM}},                   \
+{ "tfreg_or_fp01_operand", {REG, CONST_DOUBLE}},
 
 /* An alias for a machine mode name.  This is the machine mode that elements of
    a jump-table should have.  */

diff --git a/gcc/config/ia64/ia64.md b/gcc/config/ia64/ia64.md
index 4a68623c13c1106a7d2751b7394f6ae99f8c3bf9..0734936d1e9c01cbf906d4dc8958a36adc3cbb70 100644 (file)
--- a/gcc/config/ia64/ia64.md
+++ b/gcc/config/ia64/ia64.md
@@ -22,8 +22,6 @@
 
 ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al.
 
-;; ??? Add support for long double XFmode patterns.
-
 ;; ??? register_operand accepts (subreg:DI (mem:SI X)) which forces later
 ;; reload.  This will be fixed once scheduling support is turned on.
 
@@ -575,25 +573,115 @@
   "addl %0 = @ltoff(%1), gp"
   [(set_attr "type" "A")])
 
-;; ??? These patterns exist to make SSA happy.  We can get TImode values
-;; because of structure moves generated for parameter and return value
-;; loads and stores.
+;; With no offsettable memory references, we've got to have a scratch
+;; around to play with the second word.
+(define_expand "movti"
+  [(parallel [(set (match_operand:TI 0 "general_operand" "")
+                  (match_operand:TI 1 "general_operand" ""))
+             (clobber (match_scratch:DI 2 ""))])]
+  ""
+  "
+{
+  if (! reload_in_progress && ! reload_completed
+      && ! ia64_move_ok (operands[0], operands[1]))
+    operands[1] = force_reg (TImode, operands[1]);
+}")
+
+(define_insn_and_split "*movti_internal"
+  [(set (match_operand:TI 0 "nonimmediate_operand" "=r,r,m")
+       (match_operand:TI 1 "general_operand"      "ri,m,r"))
+   (clobber (match_scratch:DI 2 "=X,&r,&r"))]
+  "ia64_move_ok (operands[0], operands[1])"
+  "#"
+  "reload_completed"
+  [(const_int 0)]
+  "
+{
+  rtx adj1, adj2, in[2], out[2];
+  int first;
+
+  adj1 = ia64_split_timode (in, operands[1], operands[2]);
+  adj2 = ia64_split_timode (out, operands[0], operands[2]);
+
+  first = 0;
+  if (reg_overlap_mentioned_p (out[0], in[1]))
+    {
+      if (reg_overlap_mentioned_p (out[1], in[0]))
+       abort ();
+      first = 1;
+    }
+
+  if (adj1 && adj2)
+    abort ();
+  if (adj1)
+    emit_insn (adj1);
+  if (adj2)
+    emit_insn (adj2);
+  emit_insn (gen_rtx_SET (VOIDmode, out[first], in[first]));
+  emit_insn (gen_rtx_SET (VOIDmode, out[!first], in[!first]));
+  DONE;
+}"
+  [(set_attr "type" "unknown")
+   (set_attr "predicable" "no")])
 
-(define_insn "*movti_internal"
-  [(set (match_operand:TI 0 "register_operand" "=r")
-       (match_operand:TI 1 "register_operand" "r"))]
-  "flag_ssa"
+;; ??? SSA creates these.  Can't allow memories since we don't have
+;; the scratch register.  Fortunately combine will know how to add
+;; the clobber and scratch.
+(define_insn_and_split "*movti_internal_reg"
+  [(set (match_operand:TI 0 "register_operand"  "=r")
+       (match_operand:TI 1 "nonmemory_operand" "ri"))]
+  ""
   "#"
+  "reload_completed"
+  [(const_int 0)]
+  "
+{
+  rtx in[2], out[2];
+  int first;
+
+  ia64_split_timode (in, operands[1], NULL_RTX);
+  ia64_split_timode (out, operands[0], NULL_RTX);
+
+  first = 0;
+  if (reg_overlap_mentioned_p (out[0], in[1]))
+    {
+      if (reg_overlap_mentioned_p (out[1], in[0]))
+       abort ();
+      first = 1;
+    }
+
+  emit_insn (gen_rtx_SET (VOIDmode, out[first], in[first]));
+  emit_insn (gen_rtx_SET (VOIDmode, out[!first], in[!first]));
+  DONE;
+}"
   [(set_attr "type" "unknown")
    (set_attr "predicable" "no")])
 
-(define_split
-  [(set (match_operand:TI 0 "register_operand" "")
-       (match_operand:TI 1 "register_operand" ""))]
-  "flag_ssa && reload_completed"
-  [(set (subreg:DI (match_dup 0) 0) (subreg:DI (match_dup 1) 0))
-   (set (subreg:DI (match_dup 0) 1) (subreg:DI (match_dup 1) 1))]
-  "")
+(define_expand "reload_inti"
+  [(parallel [(set (match_operand:TI 0 "register_operand" "=r")
+                  (match_operand:TI 1 "" "m"))
+             (clobber (match_operand:DI 2 "register_operand" "=&r"))])]
+  ""
+  "
+{
+  /* ??? Should now be enforced by tweeks to push_secondary_reload.  */
+  if (reg_overlap_mentioned_p (operands[2], operands[0])
+      || reg_overlap_mentioned_p (operands[2], operands[1]))
+    abort ();
+}")
+
+(define_expand "reload_outti"
+  [(parallel [(set (match_operand:TI 0 "" "=m")
+                  (match_operand:TI 1 "register_operand" "r"))
+             (clobber (match_operand:DI 2 "register_operand" "=&r"))])]
+  ""
+  "
+{
+  /* ??? Should now be enforced by tweeks to push_secondary_reload.  */
+  if (reg_overlap_mentioned_p (operands[2], operands[0])
+      || reg_overlap_mentioned_p (operands[2], operands[1]))
+    abort ();
+}")
 
 ;; Floating Point Moves
 ;;
@@ -621,10 +709,10 @@
          (match_operand:SF 1 "nonmemory_operand" "fG,fG,*r,*r")))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "@
-  mov %0 = %F1
-  getf.s %0 = %F1
-  setf.s %0 = %1
-  mov %0 = %1"
+  (%J2) mov %0 = %F1
+  (%J2) getf.s %0 = %F1
+  (%J2) setf.s %0 = %1
+  (%J2) mov %0 = %1"
   [(set_attr "type" "F,M,M,A")
    (set_attr "predicable" "no")])
 
@@ -680,10 +768,10 @@
          (match_operand:DF 1 "nonmemory_operand" "fG,fG,*r,*r")))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "@
-  mov %0 = %F1
-  getf.d %0 = %F1
-  setf.d %0 = %1
-  mov %0 = %1"
+  (%J2) mov %0 = %F1
+  (%J2) getf.d %0 = %F1
+  (%J2) setf.d %0 = %1
+  (%J2) mov %0 = %1"
   [(set_attr "type" "F,M,M,A")
    (set_attr "predicable" "no")])
 
@@ -718,35 +806,96 @@
   st8%Q0 %0 = %1%P0"
   [(set_attr "type" "F,M,M,M,M,A,M,M")])
 
-(define_expand "movxf"
-  [(set (match_operand:XF 0 "general_operand" "")
-       (match_operand:XF 1 "general_operand" ""))]
+;; With no offsettable memory references, we've got to have a scratch
+;; around to play with the second word if the variable winds up in GRs.
+(define_expand "movtf"
+  [(set (match_operand:TF 0 "general_operand" "")
+       (match_operand:TF 1 "general_operand" ""))]
   ""
   "
 {
-  if (! reload_in_progress && ! reload_completed
-      && ! ia64_move_ok (operands[0], operands[1]))
-    operands[1] = force_reg (XFmode, operands[1]);
+  /* We must support TFmode loads into general registers for stdarg/vararg
+     and unprototyped calls.  We split them into DImode loads for convenience.
+     We don't need TFmode stores from general regs, because a stdarg/vararg
+     routine does a block store to memory of unnamed arguments.  */
+  if (GET_CODE (operands[0]) == REG
+      && GR_REGNO_P (REGNO (operands[0])))
+    {
+      /* We're hoping to transform everything that deals with TFmode
+        quantities and GR registers early in the compiler.  */
+      if (no_new_pseudos)
+       abort ();
+
+      /* Struct to register can just use TImode instead.  */
+      if ((GET_CODE (operands[1]) == SUBREG
+          && GET_MODE (SUBREG_REG (operands[1])) == TImode)
+         || (GET_CODE (operands[1]) == REG
+             && GR_REGNO_P (REGNO (operands[1]))))
+       {
+         emit_move_insn (gen_rtx_REG (TImode, REGNO (operands[0])),
+                         SUBREG_REG (operands[1]));
+         DONE;
+       }
+
+      if (GET_CODE (operands[1]) == CONST_DOUBLE)
+       {
+         emit_move_insn (gen_rtx_REG (DImode, REGNO (operands[0])),
+                         operand_subword (operands[1], 0, 0, DImode));
+         emit_move_insn (gen_rtx_REG (DImode, REGNO (operands[0]) + 1),
+                         operand_subword (operands[1], 1, 0, DImode));
+         DONE;
+       }
+
+      /* If the quantity is in a register not known to be GR, spill it.  */
+      if (register_operand (operands[1], TFmode))
+       operands[1] = spill_tfmode_operand (operands[1], 1);
+
+      if (GET_CODE (operands[1]) == MEM)
+       {
+         rtx out[2];
+
+         out[WORDS_BIG_ENDIAN] = gen_rtx_REG (DImode, REGNO (operands[0]));
+         out[!WORDS_BIG_ENDIAN] = gen_rtx_REG (DImode, REGNO (operands[0])+1);
+
+         emit_move_insn (out[0], change_address (operands[1], DImode, NULL));
+         emit_move_insn (out[1],
+                         change_address (operands[1], DImode,
+                                         plus_constant (XEXP (operands[1], 0),
+                                                        8)));
+         DONE;
+       }
+
+      abort ();
+    }
+
+  if (! reload_in_progress && ! reload_completed)
+    {
+      operands[0] = spill_tfmode_operand (operands[0], 0);
+      operands[1] = spill_tfmode_operand (operands[1], 0);
+
+      if (! ia64_move_ok (operands[0], operands[1]))
+       operands[1] = force_reg (TFmode, operands[1]);
+    }
 }")
 
 ;; ??? There's no easy way to mind volatile acquire/release semantics.
 
 ;; Errata 72 workaround.
-(define_insn "*movxfcc_astep"
+(define_insn "*movtfcc_astep"
   [(cond_exec
      (match_operator 2 "predicate_operator"
        [(match_operand:CC 3 "register_operand" "c")
         (const_int 0)])
-     (set (match_operand:XF 0 "register_operand"  "=f")
-         (match_operand:XF 1 "nonmemory_operand" "fG")))]
+     (set (match_operand:TF 0 "register_operand"  "=f")
+         (match_operand:TF 1 "nonmemory_operand" "fG")))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
-  "mov %0 = %F1"
+  "(%J2) mov %0 = %F1"
   [(set_attr "type" "F")
    (set_attr "predicable" "no")])
 
-(define_insn "*movxf_internal_astep"
-  [(set (match_operand:XF 0 "destination_operand" "=f,f, m")
-       (match_operand:XF 1 "general_operand"     "fG,m,fG"))]
+(define_insn "*movtf_internal_astep"
+  [(set (match_operand:TF 0 "destination_tfmode_operand" "=f,f, m")
+       (match_operand:TF 1 "general_tfmode_operand"     "fG,m,fG"))]
   "TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "@
   mov %0 = %F1
@@ -755,9 +904,9 @@
   [(set_attr "type" "F,M,M")
    (set_attr "predicable" "no")])
 
-(define_insn "*movxf_internal"
-  [(set (match_operand:XF 0 "destination_operand" "=f,f, m")
-       (match_operand:XF 1 "general_operand"     "fG,m,fG"))]
+(define_insn "*movtf_internal"
+  [(set (match_operand:TF 0 "destination_tfmode_operand" "=f,f, m")
+       (match_operand:TF 1 "general_tfmode_operand"     "fG,m,fG"))]
   "! TARGET_A_STEP && ia64_move_ok (operands[0], operands[1])"
   "@
   mov %0 = %F1
@@ -843,6 +992,26 @@
   "if (true_regnum (operands[0]) == true_regnum (operands[1])) DONE;"
   [(set_attr "type" "F")])
 
+(define_insn_and_split "extendsftf2"
+  [(set (match_operand:TF 0 "register_operand" "=f,f")
+       (float_extend:TF (match_operand:SF 1 "register_operand" "0,f")))]
+  ""
+  "mov %0 = %1"
+  "reload_completed"
+  [(set (match_dup 0) (float_extend:TF (match_dup 1)))]
+  "if (true_regnum (operands[0]) == true_regnum (operands[1])) DONE;"
+  [(set_attr "type" "F")])
+
+(define_insn_and_split "extenddftf2"
+  [(set (match_operand:TF 0 "register_operand" "=f,f")
+       (float_extend:TF (match_operand:DF 1 "register_operand" "0,f")))]
+  ""
+  "mov %0 = %1"
+  "reload_completed"
+  [(set (match_dup 0) (float_extend:TF (match_dup 1)))]
+  "if (true_regnum (operands[0]) == true_regnum (operands[1])) DONE;"
+  [(set_attr "type" "F")])
+
 (define_insn "truncdfsf2"
   [(set (match_operand:SF 0 "register_operand" "=f")
        (float_truncate:SF (match_operand:DF 1 "register_operand" "f")))]
@@ -850,25 +1019,25 @@
   "fnorm.s %0 = %1%B0"
   [(set_attr "type" "F")])
 
-(define_insn "truncxfsf2"
+(define_insn "trunctfsf2"
   [(set (match_operand:SF 0 "register_operand" "=f")
-       (float_truncate:SF (match_operand:XF 1 "register_operand" "f")))]
+       (float_truncate:SF (match_operand:TF 1 "register_operand" "f")))]
   ""
   "fnorm.s %0 = %1%B0"
   [(set_attr "type" "F")])
 
-(define_insn "truncxfdf2"
+(define_insn "trunctfdf2"
   [(set (match_operand:DF 0 "register_operand" "=f")
-       (float_truncate:DF (match_operand:XF 1 "register_operand" "f")))]
+       (float_truncate:DF (match_operand:TF 1 "register_operand" "f")))]
   ""
   "fnorm.d %0 = %1%B0"
   [(set_attr "type" "F")])
 
 ;; Convert between signed integer types and floating point.
 
-(define_insn "floatdixf2"
-  [(set (match_operand:XF 0 "register_operand" "=f")
-       (float:XF (match_operand:DI 1 "register_operand" "f")))]
+(define_insn "floatditf2"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (float:TF (match_operand:DI 1 "register_operand" "f")))]
   ""
   "fcvt.xf %0 = %1"
   [(set_attr "type" "F")])
@@ -887,6 +1056,13 @@
   "fcvt.fx.trunc %0 = %1%B0"
   [(set_attr "type" "F")])
 
+(define_insn "fix_trunctfdi2"
+  [(set (match_operand:DI 0 "register_operand" "=f")
+       (fix:DI (match_operand:TF 1 "register_operand" "f")))]
+  ""
+  "fcvt.fx.trunc %0 = %1%B0"
+  [(set_attr "type" "F")])
+
 ;; Convert between unsigned integer types and floating point.
 
 (define_insn "floatunsdisf2"
@@ -903,6 +1079,13 @@
   "fcvt.xuf.d %0 = %1%B0"
   [(set_attr "type" "F")])
 
+(define_insn "floatunsditf2"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (unsigned_float:TF (match_operand:DI 1 "register_operand" "f")))]
+  ""
+  "fcvt.xuf %0 = %1%B0"
+  [(set_attr "type" "F")])
+
 (define_insn "fixuns_truncsfdi2"
   [(set (match_operand:DI 0 "register_operand" "=f")
        (unsigned_fix:DI (match_operand:SF 1 "register_operand" "f")))]
@@ -917,6 +1100,12 @@
   "fcvt.fxu.trunc %0 = %1%B0"
   [(set_attr "type" "F")])
 
+(define_insn "fixuns_trunctfdi2"
+  [(set (match_operand:DI 0 "register_operand" "=f")
+       (unsigned_fix:DI (match_operand:TF 1 "register_operand" "f")))]
+  ""
+  "fcvt.fxu.trunc %0 = %1%B0"
+  [(set_attr "type" "F")])
 \f
 ;; ::::::::::::::::::::
 ;; ::
@@ -1702,7 +1891,111 @@
   ""
   "fnma.d %0 = %1, %2, %F3%B0"
   [(set_attr "type" "F")])
+\f
+;; ::::::::::::::::::::
+;; ::
+;; :: 80 bit floating point arithmetic
+;; ::
+;; ::::::::::::::::::::
+
+(define_insn "addtf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (plus:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                (match_operand:TF 2 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fadd %0 = %F1, %F2%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "subtf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (minus:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                 (match_operand:TF 2 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fsub %0 = %F1, %F2%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "multf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (mult:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                (match_operand:TF 2 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fmpy %0 = %F1, %F2%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "abstf2"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (abs:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fabs %0 = %F1%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "negtf2"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (neg:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fneg %0 = %F1%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "*nabstf2"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (neg:TF (abs:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG"))))]
+  ""
+  "fnegabs %0 = %F1%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "mintf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (smin:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                (match_operand:TF 2 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fmin %0 = %F1, %F2%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "maxtf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (smax:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                (match_operand:TF 2 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fmax %0 = %F1, %F2%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "*maddtf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (plus:TF (mult:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                         (match_operand:TF 2 "tfreg_or_fp01_operand" "fG"))
+                (match_operand:TF 3 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fma %0 = %F1, %F2, %F3%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "*msubtf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (minus:TF (mult:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                          (match_operand:TF 2 "tfreg_or_fp01_operand" "fG"))
+                 (match_operand:TF 3 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fms %0 = %F1, %F2, %F3%B0"
+  [(set_attr "type" "F")])
+
+(define_insn "*nmultf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (neg:TF (mult:TF (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                        (match_operand:TF 2 "tfreg_or_fp01_operand" "fG"))))]
+  ""
+  "fnmpy %0 = %F1, %F2%B0"
+  [(set_attr "type" "F")])
 
+;; ??? Is it possible to canonicalize this as (minus (reg) (mult))?
+
+(define_insn "*nmaddtf3"
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (plus:TF (neg:TF (mult:TF
+                         (match_operand:TF 1 "tfreg_or_fp01_operand" "fG")
+                         (match_operand:TF 2 "tfreg_or_fp01_operand" "fG")))
+                (match_operand:TF 3 "tfreg_or_fp01_operand" "fG")))]
+  ""
+  "fnma %0 = %F1, %F2, %F3%B0"
+  [(set_attr "type" "F")])
 \f
 ;; ::::::::::::::::::::
 ;; ::
@@ -2038,13 +2331,11 @@
   DONE;
 }")
 
-;; ??? Enable this for XFmode support.
-
-(define_expand "cmpxf"
+(define_expand "cmptf"
   [(set (cc0)
-        (compare (match_operand:XF 0 "reg_or_fp01_operand" "")
-                (match_operand:XF 1 "reg_or_fp01_operand" "")))]
-  "0"
+        (compare (match_operand:TF 0 "tfreg_or_fp01_operand" "")
+                (match_operand:TF 1 "tfreg_or_fp01_operand" "")))]
+  ""
   "
 {
   ia64_compare_op0 = operands[0];
@@ -2108,6 +2399,15 @@
   "fcmp.%D1 %0, %I0 = %F2, %F3"
   [(set_attr "type" "F")])
 
+(define_insn "*cmptf_internal"
+  [(set (match_operand:CC 0 "register_operand" "=c")
+       (match_operator:CC 1 "comparison_operator"
+                  [(match_operand:TF 2 "tfreg_or_fp01_operand" "fG")
+                   (match_operand:TF 3 "tfreg_or_fp01_operand" "fG")]))]
+  ""
+  "fcmp.%D1 %0, %I0 = %F2, %F3"
+  [(set_attr "type" "F")])
+
 ;; ??? Can this pattern be generated?
 
 (define_insn "*bit_zero"
@@ -3383,15 +3683,15 @@
   [(set_attr "type" "M")])
 
 (define_insn "fr_spill"
-  [(set (match_operand:XF 0 "memory_operand" "=m")
-       (unspec:XF [(match_operand:XF 1 "register_operand" "f")] 3))]
+  [(set (match_operand:TF 0 "memory_operand" "=m")
+       (unspec:TF [(match_operand:TF 1 "register_operand" "f")] 3))]
   ""
   "stf.spill %0 = %1%P0"
   [(set_attr "type" "M")])
 
 (define_insn "fr_restore"
-  [(set (match_operand:XF 0 "register_operand" "=f")
-       (unspec:XF [(match_operand:XF 1 "memory_operand" "m")] 4))]
+  [(set (match_operand:TF 0 "register_operand" "=f")
+       (unspec:TF [(match_operand:TF 1 "memory_operand" "m")] 4))]
   ""
   "ldf.fill %0 = %1%P1"
   [(set_attr "type" "M")])

diff --git a/gcc/config/ia64/lib1funcs.asm b/gcc/config/ia64/lib1funcs.asm
index e5fb7d7c76ffcdca84ce7cbf19c8a39887951819..76e37e9a6051ff7ccfbc9b1561a1a0d4c689e623 100644 (file)
--- a/gcc/config/ia64/lib1funcs.asm
+++ b/gcc/config/ia64/lib1funcs.asm
@@ -1,3 +1,45 @@
+#ifdef L__divtf3
+// Compute a 80-bit IEEE double-extended quotient.
+//
+// From the Intel IA-64 Optimization Guide, choose the minimum latency
+// alternative.
+//
+// farg0 holds the dividend.  farg1 holds the divisor.
+
+       .text
+       .align 16
+       .global __divtf3
+       .proc __divtf3
+__divtf3:
+       frcpa f10, p6 = farg0, farg1
+       ;;
+(p6)   fnma.s1 f11 = farg1, f10, f1
+       ;;
+(p6)   fma.s1 f12 = f11, f10, f10
+(p6)   fma.s1 f11 = f11, f11, f0
+       ;;
+(p6)   fma.s1 f11 = f11, f12, f12
+       ;;
+(p6)   fnma.s1 f12 = farg1, f11, f1
+(p6)   fma.s1 f10 = farg0, f10, f0
+       ;;
+(p6)   fma.s1 f11 = f12, f11, f11
+(p6)   fnma.s1 f12 = farg1, f10, farg0
+       ;;
+(p6)   fma.s1 f10 = f12, f11, f10
+(p6)   fnma.s1 f12 = farg1, f11, f1
+       ;;
+(p6)   fnma.s1 f8 = farg1, f10, farg0
+(p6)   fma.s1 f9 = f12, f11, f11
+       ;;
+(p6)   fma f10 = f8, f9, f10
+       ;;
+       mov fret0 = f10
+       br.ret.sptk rp
+       ;;
+       .endp __divtf3
+#endif
+
 #ifdef L__divdf3
 // Compute a 64-bit IEEE double quotient.
 //

diff --git a/gcc/config/ia64/t-ia64 b/gcc/config/ia64/t-ia64
index 5f59c5bb500d3f020a026c7689fd68e84640f3ac..1f1e61af5c985a16fe02b977f08deca5bc73128c 100644 (file)
--- a/gcc/config/ia64/t-ia64
+++ b/gcc/config/ia64/t-ia64
@@ -8,7 +8,7 @@ LIB1ASMSRC    = ia64/lib1funcs.asm
 # ??? We change the names of the DImode div/mod files so that they won't
 # accidentally be overridden by libgcc2.c files.  We used to use __ia64 as
 # a prefix, now we use __ as the prefix.
-LIB1ASMFUNCS  = __divdf3 __divsf3 \
+LIB1ASMFUNCS  = __divtf3 __divdf3 __divsf3 \
        __divdi3 __moddi3 __udivdi3 __umoddi3 \
        __divsi3 __modsi3 __udivsi3 __umodsi3 __save_stack_nonlocal \
        __nonlocal_goto __restore_stack_nonlocal __trampoline

diff --git a/gcc/configure b/gcc/configure
index fe38ab5b4b83da35e6f5bade4f5f71f90ee7222f..b7dc17b9754afc3f1d539d22eff2e0dfafebd9e7 100755 (executable)
--- a/gcc/configure
+++ b/gcc/configure
@@ -100,6 +100,7 @@ program_suffix=NONE
 program_transform_name=s,x,x,
 silent=
 site=
+sitefile=
 srcdir=
 target=NONE
 verbose=
@@ -214,6 +215,7 @@ Configuration:
   --help                  print this message
   --no-create             do not create output files
   --quiet, --silent       do not print \`checking...' messages
+  --site-file=FILE        use FILE as the site file
   --version               print the version of autoconf that created configure
 Directory and file names:
   --prefix=PREFIX         install architecture-independent files in PREFIX
@@ -384,6 +386,11 @@ EOF
   -site=* | --site=* | --sit=*)
     site="$ac_optarg" ;;
 
+  -site-file | --site-file | --site-fil | --site-fi | --site-f)
+    ac_prev=sitefile ;;
+  -site-file=* | --site-file=* | --site-fil=* | --site-fi=* | --site-f=*)
+    sitefile="$ac_optarg" ;;
+
   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
     ac_prev=srcdir ;;
   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
@@ -549,12 +556,16 @@ fi
 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 
 # Prefer explicitly selected file to automatically selected ones.
-if test -z "$CONFIG_SITE"; then
-  if test "x$prefix" != xNONE; then
-    CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
-  else
-    CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+if test -z "$sitefile"; then
+  if test -z "$CONFIG_SITE"; then
+    if test "x$prefix" != xNONE; then
+      CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
+    else
+      CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+    fi
   fi
+else
+  CONFIG_SITE="$sitefile"
 fi
 for ac_site_file in $CONFIG_SITE; do
   if test -r "$ac_site_file"; then
@@ -609,7 +620,7 @@ copy=cp
 # - two terminals occur directly after each other
 # - the path contains an element with a dot in it
 echo $ac_n "checking LIBRARY_PATH variable""... $ac_c" 1>&6
-echo "configure:613: checking LIBRARY_PATH variable" >&5
+echo "configure:624: checking LIBRARY_PATH variable" >&5
 case ${LIBRARY_PATH} in
   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
     library_path_setting="contains current directory"
@@ -634,7 +645,7 @@ fi
 # - two terminals occur directly after each other
 # - the path contains an element with a dot in it
 echo $ac_n "checking GCC_EXEC_PREFIX variable""... $ac_c" 1>&6
-echo "configure:638: checking GCC_EXEC_PREFIX variable" >&5
+echo "configure:649: checking GCC_EXEC_PREFIX variable" >&5
 case ${GCC_EXEC_PREFIX} in
   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
     gcc_exec_prefix_setting="contains current directory"
@@ -992,7 +1003,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:996: checking host system type" >&5
+echo "configure:1007: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -1013,7 +1024,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:1017: checking target system type" >&5
+echo "configure:1028: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -1031,7 +1042,7 @@ target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$target" 1>&6
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:1035: checking build system type" >&5
+echo "configure:1046: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -1058,7 +1069,7 @@ test "$host_alias" != "$target_alias" &&
 # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1062: checking for $ac_word" >&5
+echo "configure:1073: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1088,7 +1099,7 @@ if test -z "$CC"; then
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1092: checking for $ac_word" >&5
+echo "configure:1103: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1139,7 +1150,7 @@ fi
       # Extract the first word of "cl", so it can be a program name with args.
 set dummy cl; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1143: checking for $ac_word" >&5
+echo "configure:1154: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1171,7 +1182,7 @@ fi
 fi
 
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:1175: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:1186: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
 
 ac_ext=c
 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
@@ -1182,12 +1193,12 @@ cross_compiling=$ac_cv_prog_cc_cross
 
 cat > conftest.$ac_ext << EOF
 
-#line 1186 "configure"
+#line 1197 "configure"
 #include "confdefs.h"
 
 main(){return(0);}
 EOF
-if { (eval echo configure:1191: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1202: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   ac_cv_prog_cc_works=yes
   # If we can't run a trivial program, we are probably using a cross compiler.
   if (./conftest; exit) 2>/dev/null; then
@@ -1213,12 +1224,12 @@ if test $ac_cv_prog_cc_works = no; then
   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
 fi
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:1217: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:1228: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
 cross_compiling=$ac_cv_prog_cc_cross
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:1222: checking whether we are using GNU C" >&5
+echo "configure:1233: checking whether we are using GNU C" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1227,7 +1238,7 @@ else
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1231: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1242: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -1246,7 +1257,7 @@ ac_test_CFLAGS="${CFLAGS+set}"
 ac_save_CFLAGS="$CFLAGS"
 CFLAGS=
 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:1250: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:1261: checking whether ${CC-cc} accepts -g" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1279,10 +1290,10 @@ fi
 
 if test "x$CC" != xcc; then
   echo $ac_n "checking whether $CC and cc understand -c and -o together""... $ac_c" 1>&6
-echo "configure:1283: checking whether $CC and cc understand -c and -o together" >&5
+echo "configure:1294: checking whether $CC and cc understand -c and -o together" >&5
 else
   echo $ac_n "checking whether cc understands -c and -o together""... $ac_c" 1>&6
-echo "configure:1286: checking whether cc understands -c and -o together" >&5
+echo "configure:1297: checking whether cc understands -c and -o together" >&5
 fi
 set dummy $CC; ac_cc="`echo $2 |
                       sed -e 's/[^a-zA-Z0-9_]/_/g' -e 's/^[0-9]/_/'`"
@@ -1294,16 +1305,16 @@ else
 # We do the test twice because some compilers refuse to overwrite an
 # existing .o file with -o, though they will create one.
 ac_try='${CC-cc} -c conftest.c -o conftest.o 1>&5'
-if { (eval echo configure:1298: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } &&
-   test -f conftest.o && { (eval echo configure:1299: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; };
+if { (eval echo configure:1309: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } &&
+   test -f conftest.o && { (eval echo configure:1310: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; };
 then
   eval ac_cv_prog_cc_${ac_cc}_c_o=yes
   if test "x$CC" != xcc; then
     # Test first that cc exists at all.
-    if { ac_try='cc -c conftest.c 1>&5'; { (eval echo configure:1304: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; }; then
+    if { ac_try='cc -c conftest.c 1>&5'; { (eval echo configure:1315: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; }; then
       ac_try='cc -c conftest.c -o conftest.o 1>&5'
-      if { (eval echo configure:1306: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } &&
-        test -f conftest.o && { (eval echo configure:1307: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; };
+      if { (eval echo configure:1317: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; } &&
+        test -f conftest.o && { (eval echo configure:1318: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; };
       then
         # cc works too.
         :
@@ -1335,7 +1346,7 @@ fi
 
 
 echo $ac_n "checking for long double""... $ac_c" 1>&6
-echo "configure:1339: checking for long double" >&5
+echo "configure:1350: checking for long double" >&5
 if eval "test \"`echo '$''{'gcc_cv_c_long_double'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1343,7 +1354,7 @@ else
   gcc_cv_c_long_double=yes
 else
 cat > conftest.$ac_ext <<EOF
-#line 1347 "configure"
+#line 1358 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -1353,7 +1364,7 @@ long double foo = 0.0;
 switch (0) case 0: case (sizeof(long double) >= sizeof(double)):;
 ; return 0; }
 EOF
-if { (eval echo configure:1357: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1368: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gcc_cv_c_long_double=yes
 else
@@ -1376,21 +1387,21 @@ fi
 
 
 echo $ac_n "checking whether ${CC-cc} accepts -Wno-long-long""... $ac_c" 1>&6
-echo "configure:1380: checking whether ${CC-cc} accepts -Wno-long-long" >&5
+echo "configure:1391: checking whether ${CC-cc} accepts -Wno-long-long" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_cc_no_long_long'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   save_CFLAGS="$CFLAGS"
 CFLAGS="-Wno-long-long"
 cat > conftest.$ac_ext <<EOF
-#line 1387 "configure"
+#line 1398 "configure"
 #include "confdefs.h"
 
 int main() {
 
 ; return 0; }
 EOF
-if { (eval echo configure:1394: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1405: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_prog_cc_no_long_long=yes
 else
@@ -1421,7 +1432,7 @@ fi
 
 
 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
-echo "configure:1425: checking whether ${MAKE-make} sets \${MAKE}" >&5
+echo "configure:1436: checking whether ${MAKE-make} sets \${MAKE}" >&5
 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1449,7 +1460,7 @@ fi
 
 
 echo $ac_n "checking whether a default assembler was specified""... $ac_c" 1>&6
-echo "configure:1453: checking whether a default assembler was specified" >&5
+echo "configure:1464: checking whether a default assembler was specified" >&5
 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
     if test x"$gas_flag" = x"no"; then
        echo "$ac_t""yes ($DEFAULT_ASSEMBLER)" 1>&6
@@ -1461,7 +1472,7 @@ else
 fi
 
 echo $ac_n "checking whether a default linker was specified""... $ac_c" 1>&6
-echo "configure:1465: checking whether a default linker was specified" >&5
+echo "configure:1476: checking whether a default linker was specified" >&5
 if test x"${DEFAULT_LINKER+set}" = x"set"; then
     if test x"$gnu_ld_flag" = x"no"; then
        echo "$ac_t""yes ($DEFAULT_LINKER)" 1>&6
@@ -1473,21 +1484,21 @@ else
 fi
 
 echo $ac_n "checking for inline""... $ac_c" 1>&6
-echo "configure:1477: checking for inline" >&5
+echo "configure:1488: checking for inline" >&5
 if eval "test \"`echo '$''{'ac_cv_c_inline'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   ac_cv_c_inline=no
 for ac_kw in inline __inline__ __inline; do
   cat > conftest.$ac_ext <<EOF
-#line 1484 "configure"
+#line 1495 "configure"
 #include "confdefs.h"
 
 int main() {
-} int $ac_kw foo() {
+} $ac_kw foo() {
 ; return 0; }
 EOF
-if { (eval echo configure:1491: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1502: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_inline=$ac_kw; break
 else
@@ -1519,7 +1530,7 @@ do
 # Extract the first word of "$ac_prog", so it can be a program name with args.
 set dummy $ac_prog; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1523: checking for $ac_word" >&5
+echo "configure:1534: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_AWK'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1551,7 +1562,7 @@ done
 # Extract the first word of "flex", so it can be a program name with args.
 set dummy flex; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1555: checking for $ac_word" >&5
+echo "configure:1566: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_LEX'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1585,7 +1596,7 @@ then
   *) ac_lib=l ;;
   esac
   echo $ac_n "checking for yywrap in -l$ac_lib""... $ac_c" 1>&6
-echo "configure:1589: checking for yywrap in -l$ac_lib" >&5
+echo "configure:1600: checking for yywrap in -l$ac_lib" >&5
 ac_lib_var=`echo $ac_lib'_'yywrap | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1593,7 +1604,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-l$ac_lib  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 1597 "configure"
+#line 1608 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -1604,7 +1615,7 @@ int main() {
 yywrap()
 ; return 0; }
 EOF
-if { (eval echo configure:1608: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1619: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -1627,7 +1638,7 @@ fi
 fi
 
 echo $ac_n "checking whether ln works""... $ac_c" 1>&6
-echo "configure:1631: checking whether ln works" >&5
+echo "configure:1642: checking whether ln works" >&5
 if eval "test \"`echo '$''{'gcc_cv_prog_LN'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1659,7 +1670,7 @@ else
 fi
 
 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
-echo "configure:1663: checking whether ln -s works" >&5
+echo "configure:1674: checking whether ln -s works" >&5
 if eval "test \"`echo '$''{'gcc_cv_prog_LN_S'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1691,19 +1702,19 @@ else
 fi
 
 echo $ac_n "checking for volatile""... $ac_c" 1>&6
-echo "configure:1695: checking for volatile" >&5
+echo "configure:1706: checking for volatile" >&5
 if eval "test \"`echo '$''{'gcc_cv_c_volatile'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1700 "configure"
+#line 1711 "configure"
 #include "confdefs.h"
 
 int main() {
 volatile int foo;
 ; return 0; }
 EOF
-if { (eval echo configure:1707: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1718: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gcc_cv_c_volatile=yes
 else
@@ -1726,7 +1737,7 @@ fi
 # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1730: checking for $ac_word" >&5
+echo "configure:1741: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1758,7 +1769,7 @@ do
 # Extract the first word of "$ac_prog", so it can be a program name with args.
 set dummy $ac_prog; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1762: checking for $ac_word" >&5
+echo "configure:1773: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1799,7 +1810,7 @@ test -n "$YACC" || YACC="yacc"
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:1803: checking for a BSD compatible install" >&5
+echo "configure:1814: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1850,7 +1861,7 @@ test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
 
 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:1854: checking how to run the C preprocessor" >&5
+echo "configure:1865: checking how to run the C preprocessor" >&5
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
   CPP=
@@ -1865,13 +1876,13 @@ else
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp.
   cat > conftest.$ac_ext <<EOF
-#line 1869 "configure"
+#line 1880 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1875: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1886: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -1882,13 +1893,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -E -traditional-cpp"
   cat > conftest.$ac_ext <<EOF
-#line 1886 "configure"
+#line 1897 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1892: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1903: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -1899,13 +1910,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -nologo -E"
   cat > conftest.$ac_ext <<EOF
-#line 1903 "configure"
+#line 1914 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1909: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1920: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -1930,12 +1941,12 @@ fi
 echo "$ac_t""$CPP" 1>&6
 
 echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
-echo "configure:1934: checking for ANSI C header files" >&5
+echo "configure:1945: checking for ANSI C header files" >&5
 if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1939 "configure"
+#line 1950 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 #include <stdarg.h>
@@ -1943,7 +1954,7 @@ else
 #include <float.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1947: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1958: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -1960,7 +1971,7 @@ rm -f conftest*
 if test $ac_cv_header_stdc = yes; then
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 1964 "configure"
+#line 1975 "configure"
 #include "confdefs.h"
 #include <string.h>
 EOF
@@ -1978,7 +1989,7 @@ fi
 if test $ac_cv_header_stdc = yes; then
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 1982 "configure"
+#line 1993 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 EOF
@@ -1999,7 +2010,7 @@ if test "$cross_compiling" = yes; then
   :
 else
   cat > conftest.$ac_ext <<EOF
-#line 2003 "configure"
+#line 2014 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
@@ -2010,7 +2021,7 @@ if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
 exit (0); }
 
 EOF
-if { (eval echo configure:2014: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:2025: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   :
 else
@@ -2034,12 +2045,12 @@ EOF
 fi
 
 echo $ac_n "checking whether time.h and sys/time.h may both be included""... $ac_c" 1>&6
-echo "configure:2038: checking whether time.h and sys/time.h may both be included" >&5
+echo "configure:2049: checking whether time.h and sys/time.h may both be included" >&5
 if eval "test \"`echo '$''{'ac_cv_header_time'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2043 "configure"
+#line 2054 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/time.h>
@@ -2048,7 +2059,7 @@ int main() {
 struct tm *tp;
 ; return 0; }
 EOF
-if { (eval echo configure:2052: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2063: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_header_time=yes
 else
@@ -2069,12 +2080,12 @@ EOF
 fi
 
 echo $ac_n "checking whether string.h and strings.h may both be included""... $ac_c" 1>&6
-echo "configure:2073: checking whether string.h and strings.h may both be included" >&5
+echo "configure:2084: checking whether string.h and strings.h may both be included" >&5
 if eval "test \"`echo '$''{'gcc_cv_header_string'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2078 "configure"
+#line 2089 "configure"
 #include "confdefs.h"
 #include <string.h>
 #include <strings.h>
@@ -2082,7 +2093,7 @@ int main() {
 
 ; return 0; }
 EOF
-if { (eval echo configure:2086: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2097: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gcc_cv_header_string=yes
 else
@@ -2103,12 +2114,12 @@ EOF
 fi
 
 echo $ac_n "checking for sys/wait.h that is POSIX.1 compatible""... $ac_c" 1>&6
-echo "configure:2107: checking for sys/wait.h that is POSIX.1 compatible" >&5
+echo "configure:2118: checking for sys/wait.h that is POSIX.1 compatible" >&5
 if eval "test \"`echo '$''{'ac_cv_header_sys_wait_h'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2112 "configure"
+#line 2123 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -2124,7 +2135,7 @@ wait (&s);
 s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;
 ; return 0; }
 EOF
-if { (eval echo configure:2128: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2139: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_header_sys_wait_h=yes
 else
@@ -2151,17 +2162,17 @@ for ac_hdr in limits.h stddef.h string.h strings.h stdlib.h time.h \
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2155: checking for $ac_hdr" >&5
+echo "configure:2166: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2160 "configure"
+#line 2171 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2165: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2176: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2191,17 +2202,17 @@ done
 # Check for thread headers.
 ac_safe=`echo "thread.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for thread.h""... $ac_c" 1>&6
-echo "configure:2195: checking for thread.h" >&5
+echo "configure:2206: checking for thread.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2200 "configure"
+#line 2211 "configure"
 #include "confdefs.h"
 #include <thread.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2205: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2216: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2225,17 +2236,17 @@ fi
 
 ac_safe=`echo "pthread.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for pthread.h""... $ac_c" 1>&6
-echo "configure:2229: checking for pthread.h" >&5
+echo "configure:2240: checking for pthread.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2234 "configure"
+#line 2245 "configure"
 #include "confdefs.h"
 #include <pthread.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2239: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2250: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2262,7 +2273,7 @@ fi
 # Extract the first word of "gnatbind", so it can be a program name with args.
 set dummy gnatbind; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2266: checking for $ac_word" >&5
+echo "configure:2277: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gnat'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2301,7 +2312,7 @@ else
   # Extract the first word of "makeinfo", so it can be a program name with args.
 set dummy makeinfo; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2305: checking for $ac_word" >&5
+echo "configure:2316: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_MAKEINFO'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2330,13 +2341,13 @@ fi
 if test -n "$MAKEINFO"; then
   # Found it, now check the version.
   echo $ac_n "checking for modern makeinfo""... $ac_c" 1>&6
-echo "configure:2334: checking for modern makeinfo" >&5
+echo "configure:2345: checking for modern makeinfo" >&5
 if eval "test \"`echo '$''{'gcc_cv_prog_makeinfo_modern'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
     ac_prog_version=`$MAKEINFO --version 2>&1 |
                    sed -n 's/^.*GNU texinfo.* \([0-9][0-9.]*\).*$/\1/p'`
-  echo "configure:2340: version of makeinfo is $ac_prog_version" >&5
+  echo "configure:2351: version of makeinfo is $ac_prog_version" >&5
   case $ac_prog_version in
     '')     gcc_cv_prog_makeinfo_modern=no;;
     3.1[2-9] | 3.[2-9][0-9] | 4.* | 1.6[89] | 1.7[0-9])
@@ -2369,12 +2380,12 @@ fi
 
 
 echo $ac_n "checking for preprocessor stringizing operator""... $ac_c" 1>&6
-echo "configure:2373: checking for preprocessor stringizing operator" >&5
+echo "configure:2384: checking for preprocessor stringizing operator" >&5
 if eval "test \"`echo '$''{'ac_cv_c_stringize'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2378 "configure"
+#line 2389 "configure"
 #include "confdefs.h"
 
 #define x(y) #y
@@ -2407,12 +2418,12 @@ echo "$ac_t""${ac_cv_c_stringize}" 1>&6
 # Use <inttypes.h> only if it exists,
 # doesn't clash with <sys/types.h>, and declares intmax_t.
 echo $ac_n "checking for inttypes.h""... $ac_c" 1>&6
-echo "configure:2411: checking for inttypes.h" >&5
+echo "configure:2422: checking for inttypes.h" >&5
 if eval "test \"`echo '$''{'gcc_cv_header_inttypes_h'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2416 "configure"
+#line 2427 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <inttypes.h>
@@ -2420,7 +2431,7 @@ int main() {
 intmax_t i = -1;
 ; return 0; }
 EOF
-if { (eval echo configure:2424: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2435: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gcc_cv_header_inttypes_h=yes
 else
@@ -2445,7 +2456,7 @@ fi
 # be either signed or unsigned.
 #
 echo $ac_n "checking for unsigned enumerated bitfields""... $ac_c" 1>&6
-echo "configure:2449: checking for unsigned enumerated bitfields" >&5
+echo "configure:2460: checking for unsigned enumerated bitfields" >&5
 if eval "test \"`echo '$''{'gcc_cv_enum_bf_unsigned'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2453,7 +2464,7 @@ else
   gcc_cv_enum_bf_unsigned=yes
 else
   cat > conftest.$ac_ext <<EOF
-#line 2457 "configure"
+#line 2468 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 enum t { BLAH = 128 } ;
@@ -2466,7 +2477,7 @@ int main(void)
 
 }
 EOF
-if { (eval echo configure:2470: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:2481: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   gcc_cv_enum_bf_unsigned=yes
 else
@@ -2494,12 +2505,12 @@ for ac_func in strtoul bsearch putenv popen bcopy bzero bcmp \
        fputs_unlocked getrusage valloc
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2498: checking for $ac_func" >&5
+echo "configure:2509: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2503 "configure"
+#line 2514 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2522,7 +2533,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2526: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2537: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2548,12 +2559,12 @@ done
 
 
 echo $ac_n "checking for ssize_t""... $ac_c" 1>&6
-echo "configure:2552: checking for ssize_t" >&5
+echo "configure:2563: checking for ssize_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_ssize_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2557 "configure"
+#line 2568 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -2584,12 +2595,12 @@ fi
 # Try to determine the array type of the second argument of getgroups
 # for the target system (int or gid_t).
 echo $ac_n "checking for uid_t in sys/types.h""... $ac_c" 1>&6
-echo "configure:2588: checking for uid_t in sys/types.h" >&5
+echo "configure:2599: checking for uid_t in sys/types.h" >&5
 if eval "test \"`echo '$''{'ac_cv_type_uid_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2593 "configure"
+#line 2604 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 EOF
@@ -2618,7 +2629,7 @@ EOF
 fi
 
 echo $ac_n "checking type of array argument to getgroups""... $ac_c" 1>&6
-echo "configure:2622: checking type of array argument to getgroups" >&5
+echo "configure:2633: checking type of array argument to getgroups" >&5
 if eval "test \"`echo '$''{'ac_cv_type_getgroups'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2626,7 +2637,7 @@ else
   ac_cv_type_getgroups=cross
 else
   cat > conftest.$ac_ext <<EOF
-#line 2630 "configure"
+#line 2641 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Rendell for this test.  */
@@ -2651,7 +2662,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:2655: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:2666: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
     ac_cv_type_getgroups=gid_t
 else
@@ -2665,7 +2676,7 @@ fi
 
 if test $ac_cv_type_getgroups = cross; then
         cat > conftest.$ac_ext <<EOF
-#line 2669 "configure"
+#line 2680 "configure"
 #include "confdefs.h"
 #include <unistd.h>
 EOF
@@ -2706,12 +2717,12 @@ fi
 
 
 echo $ac_n "checking for vprintf""... $ac_c" 1>&6
-echo "configure:2710: checking for vprintf" >&5
+echo "configure:2721: checking for vprintf" >&5
 if eval "test \"`echo '$''{'ac_cv_func_vprintf'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2715 "configure"
+#line 2726 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char vprintf(); below.  */
@@ -2734,7 +2745,7 @@ vprintf();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2738: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2749: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_vprintf=yes"
 else
@@ -2758,12 +2769,12 @@ fi
 
 if test "$ac_cv_func_vprintf" != yes; then
 echo $ac_n "checking for _doprnt""... $ac_c" 1>&6
-echo "configure:2762: checking for _doprnt" >&5
+echo "configure:2773: checking for _doprnt" >&5
 if eval "test \"`echo '$''{'ac_cv_func__doprnt'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2767 "configure"
+#line 2778 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char _doprnt(); below.  */
@@ -2786,7 +2797,7 @@ _doprnt();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2790: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func__doprnt=yes"
 else
@@ -2822,7 +2833,7 @@ fi
 
 
 echo $ac_n "checking whether the printf functions support %p""... $ac_c" 1>&6
-echo "configure:2826: checking whether the printf functions support %p" >&5
+echo "configure:2837: checking whether the printf functions support %p" >&5
 if eval "test \"`echo '$''{'gcc_cv_func_printf_ptr'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2830,7 +2841,7 @@ else
   gcc_cv_func_printf_ptr=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 2834 "configure"
+#line 2845 "configure"
 #include "confdefs.h"
 #include <stdio.h>
 
@@ -2843,7 +2854,7 @@ int main()
   return (p != q);
 }
 EOF
-if { (eval echo configure:2847: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:2858: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   gcc_cv_func_printf_ptr=yes
 else
@@ -2876,12 +2887,12 @@ case "${host}" in
   ;;
 esac
 echo $ac_n "checking for pid_t""... $ac_c" 1>&6
-echo "configure:2880: checking for pid_t" >&5
+echo "configure:2891: checking for pid_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_pid_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2885 "configure"
+#line 2896 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -2910,17 +2921,17 @@ fi
 
 ac_safe=`echo "vfork.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for vfork.h""... $ac_c" 1>&6
-echo "configure:2914: checking for vfork.h" >&5
+echo "configure:2925: checking for vfork.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2919 "configure"
+#line 2930 "configure"
 #include "confdefs.h"
 #include <vfork.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2924: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2935: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2945,18 +2956,18 @@ else
 fi
 
 echo $ac_n "checking for working vfork""... $ac_c" 1>&6
-echo "configure:2949: checking for working vfork" >&5
+echo "configure:2960: checking for working vfork" >&5
 if eval "test \"`echo '$''{'ac_cv_func_vfork_works'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   if test "$cross_compiling" = yes; then
   echo $ac_n "checking for vfork""... $ac_c" 1>&6
-echo "configure:2955: checking for vfork" >&5
+echo "configure:2966: checking for vfork" >&5
 if eval "test \"`echo '$''{'ac_cv_func_vfork'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2960 "configure"
+#line 2971 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char vfork(); below.  */
@@ -2979,7 +2990,7 @@ vfork();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2983: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2994: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_vfork=yes"
 else
@@ -3001,7 +3012,7 @@ fi
 ac_cv_func_vfork_works=$ac_cv_func_vfork
 else
   cat > conftest.$ac_ext <<EOF
-#line 3005 "configure"
+#line 3016 "configure"
 #include "confdefs.h"
 /* Thanks to Paul Eggert for this test.  */
 #include <stdio.h>
@@ -3096,7 +3107,7 @@ main() {
   }
 }
 EOF
-if { (eval echo configure:3100: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3111: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_vfork_works=yes
 else
@@ -3122,17 +3133,17 @@ for ac_hdr in unistd.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3126: checking for $ac_hdr" >&5
+echo "configure:3137: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3131 "configure"
+#line 3142 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3136: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3147: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3161,12 +3172,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3165: checking for $ac_func" >&5
+echo "configure:3176: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3170 "configure"
+#line 3181 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3189,7 +3200,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3193: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3204: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3214,7 +3225,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap which provides zeroed pages anywhere""... $ac_c" 1>&6
-echo "configure:3218: checking for working mmap which provides zeroed pages anywhere" >&5
+echo "configure:3229: checking for working mmap which provides zeroed pages anywhere" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_anywhere'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -3222,7 +3233,7 @@ else
   ac_cv_func_mmap_anywhere=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 3226 "configure"
+#line 3237 "configure"
 #include "confdefs.h"
 
 /* Test by Richard Henderson and Alexandre Oliva.
@@ -3305,7 +3316,7 @@ int main()
   exit(0);
 }
 EOF
-if { (eval echo configure:3309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3320: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_anywhere=yes
 else
@@ -3328,7 +3339,7 @@ EOF
 fi
 
 echo $ac_n "checking for working mmap of a file""... $ac_c" 1>&6
-echo "configure:3332: checking for working mmap of a file" >&5
+echo "configure:3343: checking for working mmap of a file" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_file'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -3343,7 +3354,7 @@ if test "$cross_compiling" = yes; then
   ac_cv_func_mmap_file=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 3347 "configure"
+#line 3358 "configure"
 #include "confdefs.h"
 
 /* Test by Zack Weinberg.  Modified from MMAP_ANYWHERE test by
@@ -3380,7 +3391,7 @@ int main()
   exit(0);
 }
 EOF
-if { (eval echo configure:3384: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3395: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_file=yes
 else
@@ -3413,12 +3424,12 @@ for ac_func in bcopy bzero bcmp \
 do
   ac_tr_decl=HAVE_DECL_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 echo $ac_n "checking whether $ac_func is declared""... $ac_c" 1>&6
-echo "configure:3417: checking whether $ac_func is declared" >&5
+echo "configure:3428: checking whether $ac_func is declared" >&5
 if eval "test \"`echo '$''{'gcc_cv_have_decl_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3422 "configure"
+#line 3433 "configure"
 #include "confdefs.h"
 #include "gansidecl.h"
 #include "system.h"
@@ -3429,7 +3440,7 @@ char *(*pfn) = (char *(*)) $ac_func ;
 #endif
 ; return 0; }
 EOF
-if { (eval echo configure:3433: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3444: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   eval "gcc_cv_have_decl_$ac_func=yes"
 else
@@ -3534,12 +3545,12 @@ for ac_func in getrlimit setrlimit getrusage
 do
   ac_tr_decl=HAVE_DECL_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 echo $ac_n "checking whether $ac_func is declared""... $ac_c" 1>&6
-echo "configure:3538: checking whether $ac_func is declared" >&5
+echo "configure:3549: checking whether $ac_func is declared" >&5
 if eval "test \"`echo '$''{'gcc_cv_have_decl_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3543 "configure"
+#line 3554 "configure"
 #include "confdefs.h"
 #include "gansidecl.h"
 #include "system.h"
@@ -3554,7 +3565,7 @@ char *(*pfn) = (char *(*)) $ac_func ;
 #endif
 ; return 0; }
 EOF
-if { (eval echo configure:3558: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3569: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   eval "gcc_cv_have_decl_$ac_func=yes"
 else
@@ -3597,12 +3608,12 @@ CFLAGS="$saved_CFLAGS"
 
 # mkdir takes a single argument on some systems. 
 echo $ac_n "checking if mkdir takes one argument""... $ac_c" 1>&6
-echo "configure:3601: checking if mkdir takes one argument" >&5
+echo "configure:3612: checking if mkdir takes one argument" >&5
 if eval "test \"`echo '$''{'gcc_cv_mkdir_takes_one_arg'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3606 "configure"
+#line 3617 "configure"
 #include "confdefs.h"
 
 #include <sys/types.h>
@@ -3619,7 +3630,7 @@ int main() {
 mkdir ("foo", 0);
 ; return 0; }
 EOF
-if { (eval echo configure:3623: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3634: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gcc_cv_mkdir_takes_one_arg=no
 else
@@ -5008,6 +5019,7 @@ for machine in $build $host $target; do
                then
                        target_cpu_default="${target_cpu_default}|MASK_GNU_LD"
                fi
+               float_format=i386
                ;;
        ia64*-*-linux*)
                tm_file=ia64/linux.h
@@ -5016,6 +5028,7 @@ for machine in $build $host $target; do
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
+               float_format=i386
                ;;
        m32r-*-elf*)
                extra_parts="crtinit.o crtfini.o"
@@ -7104,7 +7117,7 @@ fi
 
 
         echo $ac_n "checking for strerror in -lcposix""... $ac_c" 1>&6
-echo "configure:7108: checking for strerror in -lcposix" >&5
+echo "configure:7121: checking for strerror in -lcposix" >&5
 ac_lib_var=`echo cposix'_'strerror | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -7112,7 +7125,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lcposix  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 7116 "configure"
+#line 7129 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7123,7 +7136,7 @@ int main() {
 strerror()
 ; return 0; }
 EOF
-if { (eval echo configure:7127: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7140: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7146,18 +7159,18 @@ fi
   
 
 echo $ac_n "checking for working const""... $ac_c" 1>&6
-echo "configure:7150: checking for working const" >&5
+echo "configure:7163: checking for working const" >&5
 if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7155 "configure"
+#line 7168 "configure"
 #include "confdefs.h"
 
 int main() {
 
 /* Ultrix mips cc rejects this.  */
-typedef int charset[2]; const charset x = {0,0};
+typedef int charset[2]; const charset x;
 /* SunOS 4.1.1 cc rejects this.  */
 char const *const *ccp;
 char **p;
@@ -7200,7 +7213,7 @@ ccp = (char const *const *) p;
 
 ; return 0; }
 EOF
-if { (eval echo configure:7204: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:7217: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_const=yes
 else
@@ -7221,12 +7234,12 @@ EOF
 fi
 
 echo $ac_n "checking for off_t""... $ac_c" 1>&6
-echo "configure:7225: checking for off_t" >&5
+echo "configure:7238: checking for off_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7230 "configure"
+#line 7243 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -7254,12 +7267,12 @@ EOF
 fi
 
 echo $ac_n "checking for size_t""... $ac_c" 1>&6
-echo "configure:7258: checking for size_t" >&5
+echo "configure:7271: checking for size_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7263 "configure"
+#line 7276 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -7289,19 +7302,19 @@ fi
 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
 # for constant arguments.  Useless!
 echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:7293: checking for working alloca.h" >&5
+echo "configure:7306: checking for working alloca.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7298 "configure"
+#line 7311 "configure"
 #include "confdefs.h"
 #include <alloca.h>
 int main() {
-void *p = alloca(2 * sizeof(int));
+char *p = alloca(2 * sizeof(int));
 ; return 0; }
 EOF
-if { (eval echo configure:7305: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7318: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_header_alloca_h=yes
 else
@@ -7322,12 +7335,12 @@ EOF
 fi
 
 echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:7326: checking for alloca" >&5
+echo "configure:7339: checking for alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7331 "configure"
+#line 7344 "configure"
 #include "confdefs.h"
 
 #ifdef __GNUC__
@@ -7355,7 +7368,7 @@ int main() {
 char *p = (char *) alloca(1);
 ; return 0; }
 EOF
-if { (eval echo configure:7359: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7372: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_func_alloca_works=yes
 else
@@ -7387,12 +7400,12 @@ EOF
 
 
 echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:7391: checking whether alloca needs Cray hooks" >&5
+echo "configure:7404: checking whether alloca needs Cray hooks" >&5
 if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7396 "configure"
+#line 7409 "configure"
 #include "confdefs.h"
 #if defined(CRAY) && ! defined(CRAY2)
 webecray
@@ -7417,12 +7430,12 @@ echo "$ac_t""$ac_cv_os_cray" 1>&6
 if test $ac_cv_os_cray = yes; then
 for ac_func in _getb67 GETB67 getb67; do
   echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:7421: checking for $ac_func" >&5
+echo "configure:7434: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7426 "configure"
+#line 7439 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -7445,7 +7458,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:7449: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7462: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -7472,7 +7485,7 @@ done
 fi
 
 echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:7476: checking stack direction for C alloca" >&5
+echo "configure:7489: checking stack direction for C alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -7480,7 +7493,7 @@ else
   ac_cv_c_stack_direction=0
 else
   cat > conftest.$ac_ext <<EOF
-#line 7484 "configure"
+#line 7497 "configure"
 #include "confdefs.h"
 find_stack_direction ()
 {
@@ -7499,7 +7512,7 @@ main ()
   exit (find_stack_direction() < 0);
 }
 EOF
-if { (eval echo configure:7503: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:7516: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_c_stack_direction=1
 else
@@ -7526,17 +7539,17 @@ unistd.h sys/param.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:7530: checking for $ac_hdr" >&5
+echo "configure:7543: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7535 "configure"
+#line 7548 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7540: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7553: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7566,12 +7579,12 @@ done
 strdup __argz_count __argz_stringify __argz_next
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:7570: checking for $ac_func" >&5
+echo "configure:7583: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7575 "configure"
+#line 7588 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -7594,7 +7607,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:7598: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7611: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -7623,12 +7636,12 @@ done
      for ac_func in stpcpy
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:7627: checking for $ac_func" >&5
+echo "configure:7640: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7632 "configure"
+#line 7645 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -7651,7 +7664,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:7655: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7668: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -7685,19 +7698,19 @@ EOF
 
    if test $ac_cv_header_locale_h = yes; then
     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
-echo "configure:7689: checking for LC_MESSAGES" >&5
+echo "configure:7702: checking for LC_MESSAGES" >&5
 if eval "test \"`echo '$''{'am_cv_val_LC_MESSAGES'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7694 "configure"
+#line 7707 "configure"
 #include "confdefs.h"
 #include <locale.h>
 int main() {
 return LC_MESSAGES
 ; return 0; }
 EOF
-if { (eval echo configure:7701: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7714: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   am_cv_val_LC_MESSAGES=yes
 else
@@ -7718,7 +7731,7 @@ EOF
     fi
   fi
    echo $ac_n "checking whether NLS is requested""... $ac_c" 1>&6
-echo "configure:7722: checking whether NLS is requested" >&5
+echo "configure:7735: checking whether NLS is requested" >&5
         # Check whether --enable-nls or --disable-nls was given.
 if test "${enable_nls+set}" = set; then
   enableval="$enable_nls"
@@ -7738,7 +7751,7 @@ fi
 EOF
 
       echo $ac_n "checking whether included gettext is requested""... $ac_c" 1>&6
-echo "configure:7742: checking whether included gettext is requested" >&5
+echo "configure:7755: checking whether included gettext is requested" >&5
       # Check whether --with-included-gettext or --without-included-gettext was given.
 if test "${with_included_gettext+set}" = set; then
   withval="$with_included_gettext"
@@ -7757,17 +7770,17 @@ fi
 
        ac_safe=`echo "libintl.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for libintl.h""... $ac_c" 1>&6
-echo "configure:7761: checking for libintl.h" >&5
+echo "configure:7774: checking for libintl.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7766 "configure"
+#line 7779 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7771: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7784: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -7784,19 +7797,19 @@ fi
 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libc""... $ac_c" 1>&6
-echo "configure:7788: checking for gettext in libc" >&5
+echo "configure:7801: checking for gettext in libc" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7793 "configure"
+#line 7806 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 int main() {
 return (int) gettext ("")
 ; return 0; }
 EOF
-if { (eval echo configure:7800: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7813: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   gt_cv_func_gettext_libc=yes
 else
@@ -7812,7 +7825,7 @@ echo "$ac_t""$gt_cv_func_gettext_libc" 1>&6
 
           if test "$gt_cv_func_gettext_libc" != "yes"; then
             echo $ac_n "checking for bindtextdomain in -lintl""... $ac_c" 1>&6
-echo "configure:7816: checking for bindtextdomain in -lintl" >&5
+echo "configure:7829: checking for bindtextdomain in -lintl" >&5
 ac_lib_var=`echo intl'_'bindtextdomain | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -7820,7 +7833,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lintl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 7824 "configure"
+#line 7837 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7831,7 +7844,7 @@ int main() {
 bindtextdomain()
 ; return 0; }
 EOF
-if { (eval echo configure:7835: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7848: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7847,12 +7860,12 @@ fi
 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libintl""... $ac_c" 1>&6
-echo "configure:7851: checking for gettext in libintl" >&5
+echo "configure:7864: checking for gettext in libintl" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libintl'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   echo $ac_n "checking for gettext in -lintl""... $ac_c" 1>&6
-echo "configure:7856: checking for gettext in -lintl" >&5
+echo "configure:7869: checking for gettext in -lintl" >&5
 ac_lib_var=`echo intl'_'gettext | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -7860,7 +7873,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lintl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 7864 "configure"
+#line 7877 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -7871,7 +7884,7 @@ int main() {
 gettext()
 ; return 0; }
 EOF
-if { (eval echo configure:7875: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7888: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -7910,7 +7923,7 @@ EOF
              # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7914: checking for $ac_word" >&5
+echo "configure:7927: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -7944,12 +7957,12 @@ fi
                for ac_func in dcgettext
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:7948: checking for $ac_func" >&5
+echo "configure:7961: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 7953 "configure"
+#line 7966 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -7972,7 +7985,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:7976: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7989: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -7999,7 +8012,7 @@ done
                # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8003: checking for $ac_word" >&5
+echo "configure:8016: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8035,7 +8048,7 @@ fi
                # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8039: checking for $ac_word" >&5
+echo "configure:8052: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8067,7 +8080,7 @@ else
 fi
 
                cat > conftest.$ac_ext <<EOF
-#line 8071 "configure"
+#line 8084 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -8075,7 +8088,7 @@ extern int _nl_msg_cat_cntr;
                               return _nl_msg_cat_cntr
 ; return 0; }
 EOF
-if { (eval echo configure:8079: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8092: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   CATOBJEXT=.gmo
                   DATADIRNAME=share
@@ -8098,7 +8111,7 @@ fi
 
         if test "$CATOBJEXT" = "NONE"; then
          echo $ac_n "checking whether catgets can be used""... $ac_c" 1>&6
-echo "configure:8102: checking whether catgets can be used" >&5
+echo "configure:8115: checking whether catgets can be used" >&5
          # Check whether --with-catgets or --without-catgets was given.
 if test "${with_catgets+set}" = set; then
   withval="$with_catgets"
@@ -8111,7 +8124,7 @@ fi
 
          if test "$nls_cv_use_catgets" = "yes"; then
                    echo $ac_n "checking for main in -li""... $ac_c" 1>&6
-echo "configure:8115: checking for main in -li" >&5
+echo "configure:8128: checking for main in -li" >&5
 ac_lib_var=`echo i'_'main | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -8119,14 +8132,14 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-li  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 8123 "configure"
+#line 8136 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:8130: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8143: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -8154,12 +8167,12 @@ else
 fi
 
            echo $ac_n "checking for catgets""... $ac_c" 1>&6
-echo "configure:8158: checking for catgets" >&5
+echo "configure:8171: checking for catgets" >&5
 if eval "test \"`echo '$''{'ac_cv_func_catgets'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 8163 "configure"
+#line 8176 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char catgets(); below.  */
@@ -8182,7 +8195,7 @@ catgets();
 
 ; return 0; }
 EOF
-if { (eval echo configure:8186: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:8199: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_catgets=yes"
 else
@@ -8204,7 +8217,7 @@ EOF
               # Extract the first word of "gencat", so it can be a program name with args.
 set dummy gencat; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8208: checking for $ac_word" >&5
+echo "configure:8221: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GENCAT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8240,7 +8253,7 @@ fi
                 # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8244: checking for $ac_word" >&5
+echo "configure:8257: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8277,7 +8290,7 @@ fi
                   # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8281: checking for $ac_word" >&5
+echo "configure:8294: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8316,7 +8329,7 @@ fi
                 # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8320: checking for $ac_word" >&5
+echo "configure:8333: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8374,7 +8387,7 @@ fi
         # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8378: checking for $ac_word" >&5
+echo "configure:8391: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8408,7 +8421,7 @@ fi
         # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8412: checking for $ac_word" >&5
+echo "configure:8425: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8448,7 +8461,7 @@ fi
         # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:8452: checking for $ac_word" >&5
+echo "configure:8465: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -8543,7 +8556,7 @@ fi
        LINGUAS=
      else
        echo $ac_n "checking for catalogs to be installed""... $ac_c" 1>&6
-echo "configure:8547: checking for catalogs to be installed" >&5
+echo "configure:8560: checking for catalogs to be installed" >&5
        if test "x$LINGUAS" = "x"; then
         LINGUAS=$ALL_LINGUAS
        else
@@ -8575,17 +8588,17 @@ echo "configure:8547: checking for catalogs to be installed" >&5
    if test "$CATOBJEXT" = ".cat"; then
      ac_safe=`echo "linux/version.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for linux/version.h""... $ac_c" 1>&6
-echo "configure:8579: checking for linux/version.h" >&5
+echo "configure:8592: checking for linux/version.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 8584 "configure"
+#line 8597 "configure"
 #include "confdefs.h"
 #include <linux/version.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:8589: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:8602: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -8660,7 +8673,7 @@ fi
 
 
 echo $ac_n "checking whether windows registry support is requested""... $ac_c" 1>&6
-echo "configure:8664: checking whether windows registry support is requested" >&5
+echo "configure:8677: checking whether windows registry support is requested" >&5
 if test x$enable_win32_registry != xno; then
   cat >> confdefs.h <<\EOF
 #define ENABLE_WIN32_REGISTRY 1
@@ -8689,7 +8702,7 @@ esac
 
 if test x$enable_win32_registry != xno; then
   echo $ac_n "checking registry key on windows hosts""... $ac_c" 1>&6
-echo "configure:8693: checking registry key on windows hosts" >&5
+echo "configure:8706: checking registry key on windows hosts" >&5
   cat >> confdefs.h <<EOF
 #define WIN32_REGISTRY_KEY "$gcc_cv_win32_registry_key"
 EOF
@@ -8883,7 +8896,7 @@ fi
 
 # Figure out what assembler alignment features are present.
 echo $ac_n "checking assembler alignment features""... $ac_c" 1>&6
-echo "configure:8887: checking assembler alignment features" >&5
+echo "configure:8900: checking assembler alignment features" >&5
 gcc_cv_as=
 gcc_cv_as_alignment_features=
 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
@@ -9004,7 +9017,7 @@ fi
 echo "$ac_t""$gcc_cv_as_alignment_features" 1>&6
 
 echo $ac_n "checking assembler subsection support""... $ac_c" 1>&6
-echo "configure:9008: checking assembler subsection support" >&5
+echo "configure:9021: checking assembler subsection support" >&5
 gcc_cv_as_subsections=
 if test x$gcc_cv_as != x; then
        # Check if we have .subsection
@@ -9044,7 +9057,7 @@ fi
 echo "$ac_t""$gcc_cv_as_subsections" 1>&6
 
 echo $ac_n "checking assembler weak support""... $ac_c" 1>&6
-echo "configure:9048: checking assembler weak support" >&5
+echo "configure:9061: checking assembler weak support" >&5
 gcc_cv_as_weak=
 if test x$gcc_cv_as != x; then
        # Check if we have .weak
@@ -9061,7 +9074,7 @@ fi
 echo "$ac_t""$gcc_cv_as_weak" 1>&6
 
 echo $ac_n "checking assembler hidden support""... $ac_c" 1>&6
-echo "configure:9065: checking assembler hidden support" >&5
+echo "configure:9078: checking assembler hidden support" >&5
 gcc_cv_as_hidden=
 if test x$gcc_cv_as != x; then
        # Check if we have .hidden
@@ -9081,7 +9094,7 @@ echo "$ac_t""$gcc_cv_as_hidden" 1>&6
 case "$target" in 
   sparc*-*-*)
     echo $ac_n "checking assembler .register pseudo-op support""... $ac_c" 1>&6
-echo "configure:9085: checking assembler .register pseudo-op support" >&5
+echo "configure:9098: checking assembler .register pseudo-op support" >&5
 if eval "test \"`echo '$''{'gcc_cv_as_register_pseudo_op'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -9109,7 +9122,7 @@ EOF
     fi
 
     echo $ac_n "checking assembler supports -relax""... $ac_c" 1>&6
-echo "configure:9113: checking assembler supports -relax" >&5
+echo "configure:9126: checking assembler supports -relax" >&5
 if eval "test \"`echo '$''{'gcc_cv_as_relax_opt'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -9139,7 +9152,7 @@ EOF
     case "$tm_file" in
     *64*)
        echo $ac_n "checking for 64 bit support in assembler ($gcc_cv_as)""... $ac_c" 1>&6
-echo "configure:9143: checking for 64 bit support in assembler ($gcc_cv_as)" >&5
+echo "configure:9156: checking for 64 bit support in assembler ($gcc_cv_as)" >&5
 if eval "test \"`echo '$''{'gcc_cv_as_flags64'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -9184,7 +9197,7 @@ EOF
 
     if test "x$gcc_cv_as_flags64" != xno; then
        echo $ac_n "checking for assembler offsetable %lo() support""... $ac_c" 1>&6
-echo "configure:9188: checking for assembler offsetable %lo() support" >&5
+echo "configure:9201: checking for assembler offsetable %lo() support" >&5
 if eval "test \"`echo '$''{'gcc_cv_as_offsetable_lo10'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -9223,7 +9236,7 @@ EOF
 
   i[34567]86-*-*)
     echo $ac_n "checking assembler instructions""... $ac_c" 1>&6
-echo "configure:9227: checking assembler instructions" >&5
+echo "configure:9240: checking assembler instructions" >&5
     gcc_cv_as_instructions=
     if test x$gcc_cv_as != x; then
        set "filds fists" "filds mem; fists mem"
@@ -9353,7 +9366,7 @@ fi
 
 # Build a new-libstdc++ system (ie libstdc++-v3)
 echo $ac_n "checking for libstdc++ to install""... $ac_c" 1>&6
-echo "configure:9357: checking for libstdc++ to install" >&5
+echo "configure:9370: checking for libstdc++ to install" >&5
 # Check whether --enable-libstdcxx-v3 or --disable-libstdcxx-v3 was given.
 if test "${enable_libstdcxx_v3+set}" = set; then
   enableval="$enable_libstdcxx_v3"
@@ -9377,7 +9390,7 @@ EOF
 
 
 echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
-echo "configure:9381: checking whether to enable maintainer-specific portions of Makefiles" >&5
+echo "configure:9394: checking whether to enable maintainer-specific portions of Makefiles" >&5
     # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
 if test "${enable_maintainer_mode+set}" = set; then
   enableval="$enable_maintainer_mode"

diff --git a/gcc/configure.in b/gcc/configure.in
index ed68e898c64da43e57f9552b25f381c573f7fef8..a1e81cea58ae0a95a6eb7944dd25c1bb3e455894 100644 (file)
--- a/gcc/configure.in
+++ b/gcc/configure.in
@@ -2020,6 +2020,7 @@ changequote([,])dnl
                then
                        target_cpu_default="${target_cpu_default}|MASK_GNU_LD"
                fi
+               float_format=i386
                ;;
        ia64*-*-linux*)
                tm_file=ia64/linux.h
@@ -2028,6 +2029,7 @@ changequote([,])dnl
                if test x$enable_threads = xyes; then
                        thread_file='posix'
                fi
+               float_format=i386
                ;;
        m32r-*-elf*)
                extra_parts="crtinit.o crtfini.o"

diff --git a/gcc/real.c b/gcc/real.c
index fa39ebd72536d2c43c574a1bf3b8642827f376bb..030f89a39a486c3811e4f9da8a5ba2bce9ecfeb1 100644 (file)
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -95,7 +95,9 @@ netlib.att.com: netlib/cephes.   */
 
    The case LONG_DOUBLE_TYPE_SIZE = 128 activates TFmode support
    and may deactivate XFmode since `long double' is used to refer
-   to both modes.
+   to both modes.  Defining INTEL_EXTENDED_IEEE_FORMAT at the same 
+   time enables 80387-style 80-bit floats in a 128-bit padded
+   image, as seen on IA-64.
 
    The macros FLOAT_WORDS_BIG_ENDIAN, HOST_FLOAT_WORDS_BIG_ENDIAN,
    contributed by Richard Earnshaw <Richard.Earnshaw@cl.cam.ac.uk>,
@@ -244,30 +246,31 @@ unknown arithmetic type
    A REAL_VALUE_TYPE is guaranteed to occupy contiguous locations
    in memory, with no holes.  */
 
-#if MAX_LONG_DOUBLE_TYPE_SIZE == 96
+#if MAX_LONG_DOUBLE_TYPE_SIZE == 96 || \
+    (defined(INTEL_EXTENDED_IEEE_FORMAT) && MAX_LONG_DOUBLE_TYPE_SIZE == 128)
 /* Number of 16 bit words in external e type format */
-#define NE 6
-#define MAXDECEXP 4932
-#define MINDECEXP -4956
-#define GET_REAL(r,e) bcopy ((char *) r, (char *) e, 2*NE)
-#define PUT_REAL(e,r)                          \
-do {                                           \
-  if (2*NE < sizeof(*r))                       \
-    bzero((char *)r, sizeof(*r));              \
-  bcopy ((char *) e, (char *) r, 2*NE);                \
-} while (0)
-#else /* no XFmode */
-#if MAX_LONG_DOUBLE_TYPE_SIZE == 128
-#define NE 10
-#define MAXDECEXP 4932
-#define MINDECEXP -4977
-#define GET_REAL(r,e) bcopy ((char *) r, (char *) e, 2*NE)
-#define PUT_REAL(e,r)                          \
-do {                                           \
-  if (2*NE < sizeof(*r))                       \
-    bzero((char *)r, sizeof(*r));              \
-  bcopy ((char *) e, (char *) r, 2*NE);                \
-} while (0)
+# define NE 6
+# define MAXDECEXP 4932
+# define MINDECEXP -4956
+# define GET_REAL(r,e)  memcpy ((char *)(e), (char *)(r), 2*NE)
+# define PUT_REAL(e,r)                                         \
+       do {                                                    \
+         memcpy ((char *)(r), (char *)(e), 2*NE);              \
+         if (2*NE < sizeof(*r))                                \
+           memset ((char *)(r) + 2*NE, 0, sizeof(*r) - 2*NE);  \
+       } while (0)
+# else /* no XFmode */
+#  if MAX_LONG_DOUBLE_TYPE_SIZE == 128
+#   define NE 10
+#   define MAXDECEXP 4932
+#   define MINDECEXP -4977
+#   define GET_REAL(r,e) memcpy ((char *)(e), (char *)(r), 2*NE)
+#   define PUT_REAL(e,r)                                       \
+       do {                                                    \
+         memcpy ((char *)(r), (char *)(e), 2*NE);              \
+         if (2*NE < sizeof(*r))                                \
+           memset ((char *)(r) + 2*NE, 0, sizeof(*r) - 2*NE);  \
+       } while (0)
 #else
 #define NE 6
 #define MAXDECEXP 4932
@@ -497,11 +500,13 @@ endian (e, x, mode)
       switch (mode)
        {
        case TFmode:
+#ifndef INTEL_EXTENDED_IEEE_FORMAT
          /* Swap halfwords in the fourth long.  */
          th = (unsigned long) e[6] & 0xffff;
          t = (unsigned long) e[7] & 0xffff;
          t |= th << 16;
          x[3] = (long) t;
+#endif
 
        case XFmode:
          /* Swap halfwords in the third long.  */
@@ -539,11 +544,13 @@ endian (e, x, mode)
       switch (mode)
        {
        case TFmode:
+#ifndef INTEL_EXTENDED_IEEE_FORMAT
          /* Pack the fourth long.  */
          th = (unsigned long) e[7] & 0xffff;
          t = (unsigned long) e[6] & 0xffff;
          t |= th << 16;
          x[3] = (long) t;
+#endif
 
        case XFmode:
          /* Pack the third long.
@@ -737,15 +744,18 @@ ereal_atof (s, t)
       e53toe (tem, e);
       break;
 
-    case XFmode:
-      asctoe64 (s, tem);
-      e64toe (tem, e);
-      break;
-
     case TFmode:
+#ifndef INTEL_EXTENDED_IEEE_FORMAT
       asctoe113 (s, tem);
       e113toe (tem, e);
       break;
+#endif
+      /* FALLTHRU */
+
+    case XFmode:
+      asctoe64 (s, tem);
+      e64toe (tem, e);
+      break;
 
     default:
       asctoe (s, e);
@@ -1070,9 +1080,12 @@ real_value_truncate (mode, arg)
   switch (mode)
     {
     case TFmode:
+#ifndef INTEL_EXTENDED_IEEE_FORMAT
       etoe113 (e, t);
       e113toe (t, t);
       break;
+#endif
+      /* FALLTHRU */
 
     case XFmode:
       etoe64 (e, t);
@@ -1486,7 +1499,7 @@ ereal_isneg (x)
 
 /*  e type constants used by high precision check routines */
 
-#if MAX_LONG_DOUBLE_TYPE_SIZE == 128
+#if MAX_LONG_DOUBLE_TYPE_SIZE == 128 && !defined(INTEL_EXTENDED_IEEE_FORMAT)
 /* 0.0 */
 unsigned EMUSHORT ezero[NE] =
  {0x0000, 0x0000, 0x0000, 0x0000,
@@ -3660,6 +3673,15 @@ toe64 (a, b)
          /* Clear the last two bytes of 12-byte Intel format */
          *(q+1) = 0;
        }
+#ifdef INTEL_EXTENDED_IEEE_FORMAT
+      if (LONG_DOUBLE_TYPE_SIZE == 128)
+       {
+         /* Clear the last 6 bytes of 16-byte Intel format.  */
+         q[1] = 0;
+         q[2] = 0;
+         q[3] = 0;
+       }
+#endif
     }
 #endif
 
@@ -4560,7 +4582,7 @@ enormlz (x)
 #define NTEN 12
 #define MAXP 4096
 
-#if MAX_LONG_DOUBLE_TYPE_SIZE == 128
+#if MAX_LONG_DOUBLE_TYPE_SIZE == 128 && !defined(INTEL_EXTENDED_IEEE_FORMAT)
 static unsigned EMUSHORT etens[NTEN + 1][NE] =
 {
   {0x6576, 0x4a92, 0x804a, 0x153f,
@@ -6276,12 +6298,15 @@ make_nan (nan, sign, mode)
    used like NaN's, but probably not in the same way as IEEE.  */
 #if !defined(DEC) && !defined(IBM) && !defined(C4X)
     case TFmode:
+#ifndef INTEL_EXTENDED_IEEE_FORMAT
       n = 8;
       if (REAL_WORDS_BIG_ENDIAN)
        p = TFbignan;
       else
        p = TFlittlenan;
       break;
+#endif
+      /* FALLTHRU */
 
     case XFmode:
       n = 6;

diff --git a/gcc/real.h b/gcc/real.h
index 384f0f1fc3cee336202ec452f898dfd54af3f475..b9ee6066837332501b8194b48666a68a18a4b8a6 100644 (file)
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -207,11 +207,15 @@ extern REAL_VALUE_TYPE real_value_truncate        PARAMS ((enum machine_mode,
   ereal_from_uint (&d, lo, hi, mode)
 
 /* IN is a REAL_VALUE_TYPE.  OUT is an array of longs. */
+#if defined(INTEL_EXTENDED_IEEE_FORMAT) && MAX_LONG_DOUBLE_TYPE_SIZE == 128
+#define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT) (etarldouble ((IN), (OUT)))
+#else
 #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT)              \
    (LONG_DOUBLE_TYPE_SIZE == 64 ? etardouble ((IN), (OUT))     \
     : LONG_DOUBLE_TYPE_SIZE == 96 ? etarldouble ((IN), (OUT))  \
     : LONG_DOUBLE_TYPE_SIZE == 128 ? etartdouble ((IN), (OUT))  \
     : abort())
+#endif
 #define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) (etardouble ((IN), (OUT)))
 
 /* IN is a REAL_VALUE_TYPE.  OUT is a long. */