* rtl.def: Add unordered fp comparisions.

        * tree.def: Likewise.
	* tree.h: Add ISO C 9x unordered fp comparision builtins.

	* builtins.c (expand_tree_builtin): New function.
	* c-typeck.c (build_function_call): Use it.
	(build_binary_op): Support unordered compares.
	* c-common.c (c_common_nodes_and_builtins): Add unordered compares.

	* combine.c (known_cond): Handle reverse_condition returning UNKNOWN.
	(reversible_comparison_p): Allow UNORDERED/ORDERED to be reversed.
	* cse.c (fold_rtx): Check FLOAT_MODE_P before reversing.
	(record_jump_equiv): Handle reverse_condition returning UNKNOWN.
	* jump.c (reverse_condition): Don't abort for UNLE etc, but
	return UNKNOWN.
	(swap_condition): Handle unordered compares.
	(thread_jumps): Check can_reverse before reversing.
	* loop.c (get_condition): Likewise.  Allow UNORERED/ORDERED to be
	reversed for FP.

	* optabs.c (can_compare_p): New argument CODE.  Verify branch or
	setcc is present before acking for cmp_optab.  Update all callers.
	(prepare_float_lib_cmp, init_optabs): Handle UNORDERED.
	* expmed.c (do_cmp_and_jump): Update for can_compare_p.
	* expr.c (expand_expr): Likewise.  Support unordered compares.
	(do_jump, do_store_flag): Likewise.
	* expr.h (enum libfunc_index): Add unordered compares.

	* Makefile.in (FPBIT_FUNCS): Add _unord_sf.
	(DPBIT_FUNCS): Add _unord_df.
	* config/fp-bit.c (_unord_f2): New.
	* fp-test.c (main): Try unordered compare builtins.

	* alpha-protos.h (alpha_fp_comparison_operator): Declare.
	* alpha.c (alpha_comparison_operator): Check mode properly.
	(alpha_swapped_comparison_operator): Likewise.
	(signed_comparison_operator): Likewise.
	(alpha_fp_comparison_operator): New.
	(alpha_emit_conditional_branch): Handle unordered compares.
	* alpha.h (PREDICATE_CODES): Update.
	* alpha.md (fp compares): Use alpha_fp_comparison_operator.
	(bunordered, bordered): New.

	* cp/call.c (build_over_call): Use expand_tree_builtin.
	* cp/typeck.c (build_function_call_real): Likewise.
	(build_binary_op_nodefault): Handle unordered compares.

	* gcc.c-torture/execute/ieee/fp-cmp-4.c: New.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@31591 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 97 insertions, 0 deletions

diff --git a/gcc/builtins.c b/gcc/builtins.c
index 1ca5b5dbb5e..fcb6a7aa676 100644
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -2520,3 +2520,100 @@ expand_builtin (exp, target, subtarget, mode, ignore)
      to be called normally.  */
   return expand_call (exp, target, ignore);
 }
+
+/* Recognize certain built-in functions so we can make tree-codes
+   other than CALL_EXPR.  We do this when it enables fold-const.c
+   to do something useful.  */
+
+tree
+expand_tree_builtin (function, params, coerced_params)
+     tree function, params, coerced_params;
+{
+  enum tree_code code;
+
+  if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
+    return NULL_TREE;
+
+  switch (DECL_FUNCTION_CODE (function))
+    {
+    case BUILT_IN_ABS:
+    case BUILT_IN_LABS:
+    case BUILT_IN_FABS:
+      if (coerced_params == 0)
+	return integer_zero_node;
+      return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
+
+    case BUILT_IN_ISGREATER:
+      if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
+	code = UNLE_EXPR;
+      else
+	code = LE_EXPR;
+      goto unordered_cmp;
+
+    case BUILT_IN_ISGREATEREQUAL:
+      if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
+	code = UNLT_EXPR;
+      else
+	code = LT_EXPR;
+      goto unordered_cmp;
+
+    case BUILT_IN_ISLESS:
+      if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
+	code = UNGE_EXPR;
+      else
+	code = GE_EXPR;
+      goto unordered_cmp;
+
+    case BUILT_IN_ISLESSEQUAL:
+      if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
+	code = UNGT_EXPR;
+      else
+	code = GT_EXPR;
+      goto unordered_cmp;
+
+    case BUILT_IN_ISLESSGREATER:
+      if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
+	code = UNEQ_EXPR;
+      else
+	code = EQ_EXPR;
+      goto unordered_cmp;
+
+    case BUILT_IN_ISUNORDERED:
+      if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
+	return integer_zero_node;
+      code = UNORDERED_EXPR;
+      goto unordered_cmp;
+
+    unordered_cmp:
+      {
+	tree arg0, arg1;
+
+	if (params == 0
+	    || TREE_CHAIN (params) == 0)
+	  {
+	    error ("too few arguments to function `%s'",
+		   IDENTIFIER_POINTER (DECL_NAME (function)));
+	    return error_mark_node;
+	  }
+	else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
+	  {
+	    error ("too many arguments to function `%s'",
+		   IDENTIFIER_POINTER (DECL_NAME (function)));
+	    return error_mark_node;
+	  }
+
+	arg0 = TREE_VALUE (params);
+	arg1 = TREE_VALUE (TREE_CHAIN (params));
+	arg0 = build_binary_op (code, arg0, arg1, 0);
+	if (code != UNORDERED_EXPR)
+	  arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
+	return arg0;
+      }
+      break;
+
+    default:
+      break;
+    }
+
+  return NULL_TREE;
+}