Bootstrapped on x86_64-unknown-linux-gnu, testing in progress.
Richard.
2015-06-29 Richard Biener <rguent...@suse.de>
* target-insns.def (canonicalize_funcptr_for_compare): Add.
* fold-const.c (build_range_check): Replace uses of
HAVE_canonicalize_funcptr_for_compare.
(fold_widened_comparison): Likewise.
(fold_sign_changed_comparison): Likewise.
* dojump.c: Include "target.h".
(do_compare_and_jump): Replace uses of
HAVE_canonicalize_funcptr_for_compare and
gen_canonicalize_funcptr_for_compare.
* expr.c (do_store_flag): Likewise.
Index: gcc/target-insns.def
===================================================================
--- gcc/target-insns.def (revision 225115)
+++ gcc/target-insns.def (working copy)
@@ -32,3 +32,4 @@
Instructions should be documented in md.texi rather than here. */
DEF_TARGET_INSN (return, (void))
DEF_TARGET_INSN (simple_return, (void))
+DEF_TARGET_INSN (canonicalize_funcptr_for_compare, (rtx x0, rtx x1))
Index: gcc/fold-const.c
===================================================================
--- gcc/fold-const.c (revision 225115)
+++ gcc/fold-const.c (working copy)
@@ -4488,14 +4488,12 @@ build_range_check (location_t loc, tree
{
tree etype = TREE_TYPE (exp), value;
-#ifdef HAVE_canonicalize_funcptr_for_compare
/* Disable this optimization for function pointer expressions
on targets that require function pointer canonicalization. */
- if (HAVE_canonicalize_funcptr_for_compare
+ if (targetm.have_canonicalize_funcptr_for_compare ()
&& TREE_CODE (etype) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
return NULL_TREE;
-#endif
if (! in_p)
{
@@ -6964,14 +6962,12 @@ fold_widened_comparison (location_t loc,
return NULL_TREE;
shorter_type = TREE_TYPE (arg0_unw);
-#ifdef HAVE_canonicalize_funcptr_for_compare
/* Disable this optimization if we're casting a function pointer
type on targets that require function pointer canonicalization. */
- if (HAVE_canonicalize_funcptr_for_compare
+ if (targetm.have_canonicalize_funcptr_for_compare ()
&& TREE_CODE (shorter_type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
return NULL_TREE;
-#endif
if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
return NULL_TREE;
@@ -7059,14 +7055,12 @@ fold_sign_changed_comparison (location_t
arg0_inner = TREE_OPERAND (arg0, 0);
inner_type = TREE_TYPE (arg0_inner);
-#ifdef HAVE_canonicalize_funcptr_for_compare
/* Disable this optimization if we're casting a function pointer
type on targets that require function pointer canonicalization. */
- if (HAVE_canonicalize_funcptr_for_compare
+ if (targetm.have_canonicalize_funcptr_for_compare ()
&& TREE_CODE (inner_type) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
return NULL_TREE;
-#endif
if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
return NULL_TREE;
Index: gcc/dojump.c
===================================================================
--- gcc/dojump.c (revision 225115)
+++ gcc/dojump.c (working copy)
@@ -47,6 +47,7 @@ along with GCC; see the file COPYING3.
#include "predict.h"
#include "basic-block.h"
#include "tm_p.h"
+#include "target.h"
static bool prefer_and_bit_test (machine_mode, int);
static void do_jump_by_parts_greater (tree, tree, int,
@@ -1204,13 +1205,12 @@ do_compare_and_jump (tree treeop0, tree
unsignedp = TYPE_UNSIGNED (type);
code = unsignedp ? unsigned_code : signed_code;
-#ifdef HAVE_canonicalize_funcptr_for_compare
/* If function pointers need to be "canonicalized" before they can
be reliably compared, then canonicalize them.
Only do this if *both* sides of the comparison are function pointers.
If one side isn't, we want a noncanonicalized comparison. See PR
middle-end/17564. */
- if (HAVE_canonicalize_funcptr_for_compare
+ if (targetm.have_canonicalize_funcptr_for_compare ()
&& TREE_CODE (TREE_TYPE (treeop0)) == POINTER_TYPE
&& TREE_CODE (TREE_TYPE (TREE_TYPE (treeop0)))
== FUNCTION_TYPE
@@ -1221,13 +1221,12 @@ do_compare_and_jump (tree treeop0, tree
rtx new_op0 = gen_reg_rtx (mode);
rtx new_op1 = gen_reg_rtx (mode);
- emit_insn (gen_canonicalize_funcptr_for_compare (new_op0, op0));
+ emit_insn (targetm.gen_canonicalize_funcptr_for_compare (new_op0, op0));
op0 = new_op0;
- emit_insn (gen_canonicalize_funcptr_for_compare (new_op1, op1));
+ emit_insn (targetm.gen_canonicalize_funcptr_for_compare (new_op1, op1));
op1 = new_op1;
}
-#endif
do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
((mode == BLKmode)
Index: gcc/expr.c
===================================================================
--- gcc/expr.c (revision 225115)
+++ gcc/expr.c (working copy)
@@ -8916,7 +8916,7 @@ expand_expr_real_2 (sepops ops, rtx targ
return temp;
/* Use a compare and a jump for BLKmode comparisons, or for function
- type comparisons is HAVE_canonicalize_funcptr_for_compare. */
+ type comparisons is have_canonicalize_funcptr_for_compare. */
if ((target == 0
|| modifier == EXPAND_STACK_PARM
@@ -10920,8 +10920,7 @@ do_store_flag (sepops ops, rtx target, m
/* We won't bother with store-flag operations involving function pointers
when function pointers must be canonicalized before comparisons. */
-#ifdef HAVE_canonicalize_funcptr_for_compare
- if (HAVE_canonicalize_funcptr_for_compare
+ if (targetm.have_canonicalize_funcptr_for_compare ()
&& ((TREE_CODE (TREE_TYPE (arg0)) == POINTER_TYPE
&& (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0)))
== FUNCTION_TYPE))
@@ -10929,7 +10928,6 @@ do_store_flag (sepops ops, rtx target, m
&& (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1)))
== FUNCTION_TYPE))))
return 0;
-#endif
STRIP_NOPS (arg0);
STRIP_NOPS (arg1);
