1 /* Convert tree expression to rtl instructions, for GNU compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
30 #include "insn-config.h"
31 #include "insn-attr.h"
32 /* Include expr.h after insn-config.h so we get HAVE_conditional_move. */
35 #include "langhooks.h"
37 #include "basic-block.h"
39 static bool prefer_and_bit_test (enum machine_mode
, int);
40 static void do_jump_by_parts_greater (tree
, int, rtx
, rtx
);
41 static void do_jump_by_parts_equality (tree
, rtx
, rtx
);
42 static void do_compare_and_jump (tree
, enum rtx_code
, enum rtx_code
, rtx
,
45 /* At the start of a function, record that we have no previously-pushed
46 arguments waiting to be popped. */
49 init_pending_stack_adjust (void)
51 pending_stack_adjust
= 0;
54 /* Discard any pending stack adjustment. This avoid relying on the
55 RTL optimizers to remove useless adjustments when we know the
56 stack pointer value is dead. */
58 discard_pending_stack_adjust (void)
60 stack_pointer_delta
-= pending_stack_adjust
;
61 pending_stack_adjust
= 0;
64 /* When exiting from function, if safe, clear out any pending stack adjust
65 so the adjustment won't get done.
67 Note, if the current function calls alloca, then it must have a
68 frame pointer regardless of the value of flag_omit_frame_pointer. */
71 clear_pending_stack_adjust (void)
74 && (! flag_omit_frame_pointer
|| cfun
->calls_alloca
)
76 discard_pending_stack_adjust ();
79 /* Pop any previously-pushed arguments that have not been popped yet. */
82 do_pending_stack_adjust (void)
84 if (inhibit_defer_pop
== 0)
86 if (pending_stack_adjust
!= 0)
87 adjust_stack (GEN_INT (pending_stack_adjust
));
88 pending_stack_adjust
= 0;
92 /* Expand conditional expressions. */
94 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
95 LABEL is an rtx of code CODE_LABEL, in this function and all the
99 jumpifnot (tree exp
, rtx label
)
101 do_jump (exp
, label
, NULL_RTX
);
104 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
107 jumpif (tree exp
, rtx label
)
109 do_jump (exp
, NULL_RTX
, label
);
112 /* Used internally by prefer_and_bit_test. */
114 static GTY(()) rtx and_reg
;
115 static GTY(()) rtx and_test
;
116 static GTY(()) rtx shift_test
;
118 /* Compare the relative costs of "(X & (1 << BITNUM))" and "(X >> BITNUM) & 1",
119 where X is an arbitrary register of mode MODE. Return true if the former
123 prefer_and_bit_test (enum machine_mode mode
, int bitnum
)
127 /* Set up rtxes for the two variations. Use NULL as a placeholder
128 for the BITNUM-based constants. */
129 and_reg
= gen_rtx_REG (mode
, FIRST_PSEUDO_REGISTER
);
130 and_test
= gen_rtx_AND (mode
, and_reg
, NULL
);
131 shift_test
= gen_rtx_AND (mode
, gen_rtx_ASHIFTRT (mode
, and_reg
, NULL
),
136 /* Change the mode of the previously-created rtxes. */
137 PUT_MODE (and_reg
, mode
);
138 PUT_MODE (and_test
, mode
);
139 PUT_MODE (shift_test
, mode
);
140 PUT_MODE (XEXP (shift_test
, 0), mode
);
143 /* Fill in the integers. */
145 = immed_double_const ((unsigned HOST_WIDE_INT
) 1 << bitnum
, 0, mode
);
146 XEXP (XEXP (shift_test
, 0), 1) = GEN_INT (bitnum
);
148 return (rtx_cost (and_test
, IF_THEN_ELSE
, optimize_insn_for_speed_p ())
149 <= rtx_cost (shift_test
, IF_THEN_ELSE
, optimize_insn_for_speed_p ()));
152 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
153 the result is zero, or IF_TRUE_LABEL if the result is one.
154 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
155 meaning fall through in that case.
157 do_jump always does any pending stack adjust except when it does not
158 actually perform a jump. An example where there is no jump
159 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null. */
162 do_jump (tree exp
, rtx if_false_label
, rtx if_true_label
)
164 enum tree_code code
= TREE_CODE (exp
);
168 enum machine_mode mode
;
169 rtx drop_through_label
= 0;
177 temp
= integer_zerop (exp
) ? if_false_label
: if_true_label
;
183 /* This is not true with #pragma weak */
185 /* The address of something can never be zero. */
187 emit_jump (if_true_label
);
192 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == COMPONENT_REF
193 || TREE_CODE (TREE_OPERAND (exp
, 0)) == BIT_FIELD_REF
194 || TREE_CODE (TREE_OPERAND (exp
, 0)) == ARRAY_REF
195 || TREE_CODE (TREE_OPERAND (exp
, 0)) == ARRAY_RANGE_REF
)
198 /* If we are narrowing the operand, we have to do the compare in the
200 if ((TYPE_PRECISION (TREE_TYPE (exp
))
201 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
203 case NON_LVALUE_EXPR
:
208 /* These cannot change zero->nonzero or vice versa. */
209 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
213 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
218 rtx label1
= gen_label_rtx ();
219 if (!if_true_label
|| !if_false_label
)
221 drop_through_label
= gen_label_rtx ();
223 if_true_label
= drop_through_label
;
225 if_false_label
= drop_through_label
;
228 do_pending_stack_adjust ();
229 do_jump (TREE_OPERAND (exp
, 0), label1
, NULL_RTX
);
230 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
232 do_jump (TREE_OPERAND (exp
, 2), if_false_label
, if_true_label
);
237 /* Lowered by gimplify.c. */
243 case ARRAY_RANGE_REF
:
245 HOST_WIDE_INT bitsize
, bitpos
;
247 enum machine_mode mode
;
252 /* Get description of this reference. We don't actually care
253 about the underlying object here. */
254 get_inner_reference (exp
, &bitsize
, &bitpos
, &offset
, &mode
,
255 &unsignedp
, &volatilep
, false);
257 type
= lang_hooks
.types
.type_for_size (bitsize
, unsignedp
);
258 if (! SLOW_BYTE_ACCESS
259 && type
!= 0 && bitsize
>= 0
260 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
))
261 && have_insn_for (COMPARE
, TYPE_MODE (type
)))
263 do_jump (fold_convert (type
, exp
), if_false_label
, if_true_label
);
271 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
273 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
274 != MODE_COMPLEX_FLOAT
);
275 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
276 != MODE_COMPLEX_INT
);
278 if (integer_zerop (TREE_OPERAND (exp
, 1)))
279 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
);
280 else if (GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_INT
281 && !can_compare_p (EQ
, TYPE_MODE (inner_type
), ccp_jump
))
282 do_jump_by_parts_equality (exp
, if_false_label
, if_true_label
);
284 do_compare_and_jump (exp
, EQ
, EQ
, if_false_label
, if_true_label
);
289 /* Nonzero iff operands of minus differ. */
290 exp
= build2 (NE_EXPR
, TREE_TYPE (exp
),
291 TREE_OPERAND (exp
, 0),
292 TREE_OPERAND (exp
, 1));
296 tree inner_type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
298 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
299 != MODE_COMPLEX_FLOAT
);
300 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
301 != MODE_COMPLEX_INT
);
303 if (integer_zerop (TREE_OPERAND (exp
, 1)))
304 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
);
305 else if (GET_MODE_CLASS (TYPE_MODE (inner_type
)) == MODE_INT
306 && !can_compare_p (NE
, TYPE_MODE (inner_type
), ccp_jump
))
307 do_jump_by_parts_equality (exp
, if_true_label
, if_false_label
);
309 do_compare_and_jump (exp
, NE
, NE
, if_false_label
, if_true_label
);
314 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
315 if (GET_MODE_CLASS (mode
) == MODE_INT
316 && ! can_compare_p (LT
, mode
, ccp_jump
))
317 do_jump_by_parts_greater (exp
, 1, if_false_label
, if_true_label
);
319 do_compare_and_jump (exp
, LT
, LTU
, if_false_label
, if_true_label
);
323 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
324 if (GET_MODE_CLASS (mode
) == MODE_INT
325 && ! can_compare_p (LE
, mode
, ccp_jump
))
326 do_jump_by_parts_greater (exp
, 0, if_true_label
, if_false_label
);
328 do_compare_and_jump (exp
, LE
, LEU
, if_false_label
, if_true_label
);
332 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
333 if (GET_MODE_CLASS (mode
) == MODE_INT
334 && ! can_compare_p (GT
, mode
, ccp_jump
))
335 do_jump_by_parts_greater (exp
, 0, if_false_label
, if_true_label
);
337 do_compare_and_jump (exp
, GT
, GTU
, if_false_label
, if_true_label
);
341 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
342 if (GET_MODE_CLASS (mode
) == MODE_INT
343 && ! can_compare_p (GE
, mode
, ccp_jump
))
344 do_jump_by_parts_greater (exp
, 1, if_true_label
, if_false_label
);
346 do_compare_and_jump (exp
, GE
, GEU
, if_false_label
, if_true_label
);
352 enum rtx_code cmp
, rcmp
;
355 if (code
== UNORDERED_EXPR
)
356 cmp
= UNORDERED
, rcmp
= ORDERED
;
358 cmp
= ORDERED
, rcmp
= UNORDERED
;
359 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
362 if (! can_compare_p (cmp
, mode
, ccp_jump
)
363 && (can_compare_p (rcmp
, mode
, ccp_jump
)
364 /* If the target doesn't provide either UNORDERED or ORDERED
365 comparisons, canonicalize on UNORDERED for the library. */
366 || rcmp
== UNORDERED
))
370 do_compare_and_jump (exp
, cmp
, cmp
, if_false_label
, if_true_label
);
372 do_compare_and_jump (exp
, rcmp
, rcmp
, if_true_label
, if_false_label
);
377 enum rtx_code rcode1
;
378 enum tree_code tcode1
, tcode2
;
382 tcode1
= UNORDERED_EXPR
;
387 tcode1
= UNORDERED_EXPR
;
392 tcode1
= UNORDERED_EXPR
;
397 tcode1
= UNORDERED_EXPR
;
402 tcode1
= UNORDERED_EXPR
;
406 /* It is ok for LTGT_EXPR to trap when the result is unordered,
407 so expand to (a < b) || (a > b). */
414 mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
415 if (can_compare_p (rcode1
, mode
, ccp_jump
))
416 do_compare_and_jump (exp
, rcode1
, rcode1
, if_false_label
,
420 tree op0
= save_expr (TREE_OPERAND (exp
, 0));
421 tree op1
= save_expr (TREE_OPERAND (exp
, 1));
424 /* If the target doesn't support combined unordered
425 compares, decompose into two comparisons. */
426 if (if_true_label
== 0)
427 drop_through_label
= if_true_label
= gen_label_rtx ();
429 cmp0
= fold_build2 (tcode1
, TREE_TYPE (exp
), op0
, op1
);
430 cmp1
= fold_build2 (tcode2
, TREE_TYPE (exp
), op0
, op1
);
431 do_jump (cmp0
, 0, if_true_label
);
432 do_jump (cmp1
, if_false_label
, if_true_label
);
438 /* fold_single_bit_test() converts (X & (1 << C)) into (X >> C) & 1.
439 See if the former is preferred for jump tests and restore it
441 if (integer_onep (TREE_OPERAND (exp
, 1)))
443 tree exp0
= TREE_OPERAND (exp
, 0);
444 rtx set_label
, clr_label
;
446 /* Strip narrowing integral type conversions. */
447 while (CONVERT_EXPR_P (exp0
)
448 && TREE_OPERAND (exp0
, 0) != error_mark_node
449 && TYPE_PRECISION (TREE_TYPE (exp0
))
450 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp0
, 0))))
451 exp0
= TREE_OPERAND (exp0
, 0);
453 /* "exp0 ^ 1" inverts the sense of the single bit test. */
454 if (TREE_CODE (exp0
) == BIT_XOR_EXPR
455 && integer_onep (TREE_OPERAND (exp0
, 1)))
457 exp0
= TREE_OPERAND (exp0
, 0);
458 clr_label
= if_true_label
;
459 set_label
= if_false_label
;
463 clr_label
= if_false_label
;
464 set_label
= if_true_label
;
467 if (TREE_CODE (exp0
) == RSHIFT_EXPR
)
469 tree arg
= TREE_OPERAND (exp0
, 0);
470 tree shift
= TREE_OPERAND (exp0
, 1);
471 tree argtype
= TREE_TYPE (arg
);
472 if (TREE_CODE (shift
) == INTEGER_CST
473 && compare_tree_int (shift
, 0) >= 0
474 && compare_tree_int (shift
, HOST_BITS_PER_WIDE_INT
) < 0
475 && prefer_and_bit_test (TYPE_MODE (argtype
),
476 TREE_INT_CST_LOW (shift
)))
478 unsigned HOST_WIDE_INT mask
479 = (unsigned HOST_WIDE_INT
) 1 << TREE_INT_CST_LOW (shift
);
480 do_jump (build2 (BIT_AND_EXPR
, argtype
, arg
,
481 build_int_cst_wide_type (argtype
, mask
, 0)),
482 clr_label
, set_label
);
488 /* If we are AND'ing with a small constant, do this comparison in the
489 smallest type that fits. If the machine doesn't have comparisons
490 that small, it will be converted back to the wider comparison.
491 This helps if we are testing the sign bit of a narrower object.
492 combine can't do this for us because it can't know whether a
493 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
495 if (! SLOW_BYTE_ACCESS
496 && TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
497 && TYPE_PRECISION (TREE_TYPE (exp
)) <= HOST_BITS_PER_WIDE_INT
498 && (i
= tree_floor_log2 (TREE_OPERAND (exp
, 1))) >= 0
499 && (mode
= mode_for_size (i
+ 1, MODE_INT
, 0)) != BLKmode
500 && (type
= lang_hooks
.types
.type_for_mode (mode
, 1)) != 0
501 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
))
502 && have_insn_for (COMPARE
, TYPE_MODE (type
)))
504 do_jump (fold_convert (type
, exp
), if_false_label
, if_true_label
);
508 if (TYPE_PRECISION (TREE_TYPE (exp
)) > 1
509 || TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
512 /* Boolean comparisons can be compiled as TRUTH_AND_EXPR. */
515 /* High branch cost, expand as the bitwise AND of the conditions.
516 Do the same if the RHS has side effects, because we're effectively
517 turning a TRUTH_AND_EXPR into a TRUTH_ANDIF_EXPR. */
518 if (BRANCH_COST (optimize_insn_for_speed_p (),
520 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 1)))
523 case TRUTH_ANDIF_EXPR
:
524 if (if_false_label
== NULL_RTX
)
526 drop_through_label
= gen_label_rtx ();
527 do_jump (TREE_OPERAND (exp
, 0), drop_through_label
, NULL_RTX
);
528 do_jump (TREE_OPERAND (exp
, 1), NULL_RTX
, if_true_label
);
532 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, NULL_RTX
);
533 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
539 /* High branch cost, expand as the bitwise OR of the conditions.
540 Do the same if the RHS has side effects, because we're effectively
541 turning a TRUTH_OR_EXPR into a TRUTH_ORIF_EXPR. */
542 if (BRANCH_COST (optimize_insn_for_speed_p (), false)>= 4
543 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 1)))
546 case TRUTH_ORIF_EXPR
:
547 if (if_true_label
== NULL_RTX
)
549 drop_through_label
= gen_label_rtx ();
550 do_jump (TREE_OPERAND (exp
, 0), NULL_RTX
, drop_through_label
);
551 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, NULL_RTX
);
555 do_jump (TREE_OPERAND (exp
, 0), NULL_RTX
, if_true_label
);
556 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
);
560 /* Fall through and generate the normal code. */
563 temp
= expand_normal (exp
);
564 do_pending_stack_adjust ();
565 /* The RTL optimizers prefer comparisons against pseudos. */
566 if (GET_CODE (temp
) == SUBREG
)
568 /* Compare promoted variables in their promoted mode. */
569 if (SUBREG_PROMOTED_VAR_P (temp
)
570 && REG_P (XEXP (temp
, 0)))
571 temp
= XEXP (temp
, 0);
573 temp
= copy_to_reg (temp
);
575 do_compare_rtx_and_jump (temp
, CONST0_RTX (GET_MODE (temp
)),
576 NE
, TYPE_UNSIGNED (TREE_TYPE (exp
)),
577 GET_MODE (temp
), NULL_RTX
,
578 if_false_label
, if_true_label
);
581 if (drop_through_label
)
583 do_pending_stack_adjust ();
584 emit_label (drop_through_label
);
588 /* Compare OP0 with OP1, word at a time, in mode MODE.
589 UNSIGNEDP says to do unsigned comparison.
590 Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
593 do_jump_by_parts_greater_rtx (enum machine_mode mode
, int unsignedp
, rtx op0
,
594 rtx op1
, rtx if_false_label
, rtx if_true_label
)
596 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
597 rtx drop_through_label
= 0;
600 if (! if_true_label
|| ! if_false_label
)
601 drop_through_label
= gen_label_rtx ();
603 if_true_label
= drop_through_label
;
604 if (! if_false_label
)
605 if_false_label
= drop_through_label
;
607 /* Compare a word at a time, high order first. */
608 for (i
= 0; i
< nwords
; i
++)
610 rtx op0_word
, op1_word
;
612 if (WORDS_BIG_ENDIAN
)
614 op0_word
= operand_subword_force (op0
, i
, mode
);
615 op1_word
= operand_subword_force (op1
, i
, mode
);
619 op0_word
= operand_subword_force (op0
, nwords
- 1 - i
, mode
);
620 op1_word
= operand_subword_force (op1
, nwords
- 1 - i
, mode
);
623 /* All but high-order word must be compared as unsigned. */
624 do_compare_rtx_and_jump (op0_word
, op1_word
, GT
,
625 (unsignedp
|| i
> 0), word_mode
, NULL_RTX
,
626 NULL_RTX
, if_true_label
);
628 /* Consider lower words only if these are equal. */
629 do_compare_rtx_and_jump (op0_word
, op1_word
, NE
, unsignedp
, word_mode
,
630 NULL_RTX
, NULL_RTX
, if_false_label
);
634 emit_jump (if_false_label
);
635 if (drop_through_label
)
636 emit_label (drop_through_label
);
639 /* Given a comparison expression EXP for values too wide to be compared
640 with one insn, test the comparison and jump to the appropriate label.
641 The code of EXP is ignored; we always test GT if SWAP is 0,
642 and LT if SWAP is 1. */
645 do_jump_by_parts_greater (tree exp
, int swap
, rtx if_false_label
,
648 rtx op0
= expand_normal (TREE_OPERAND (exp
, swap
));
649 rtx op1
= expand_normal (TREE_OPERAND (exp
, !swap
));
650 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
651 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp
, 0)));
653 do_jump_by_parts_greater_rtx (mode
, unsignedp
, op0
, op1
, if_false_label
,
657 /* Jump according to whether OP0 is 0. We assume that OP0 has an integer
658 mode, MODE, that is too wide for the available compare insns. Either
659 Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL_RTX
660 to indicate drop through. */
663 do_jump_by_parts_zero_rtx (enum machine_mode mode
, rtx op0
,
664 rtx if_false_label
, rtx if_true_label
)
666 int nwords
= GET_MODE_SIZE (mode
) / UNITS_PER_WORD
;
669 rtx drop_through_label
= 0;
671 /* The fastest way of doing this comparison on almost any machine is to
672 "or" all the words and compare the result. If all have to be loaded
673 from memory and this is a very wide item, it's possible this may
674 be slower, but that's highly unlikely. */
676 part
= gen_reg_rtx (word_mode
);
677 emit_move_insn (part
, operand_subword_force (op0
, 0, mode
));
678 for (i
= 1; i
< nwords
&& part
!= 0; i
++)
679 part
= expand_binop (word_mode
, ior_optab
, part
,
680 operand_subword_force (op0
, i
, mode
),
681 part
, 1, OPTAB_WIDEN
);
685 do_compare_rtx_and_jump (part
, const0_rtx
, EQ
, 1, word_mode
,
686 NULL_RTX
, if_false_label
, if_true_label
);
691 /* If we couldn't do the "or" simply, do this with a series of compares. */
692 if (! if_false_label
)
693 drop_through_label
= if_false_label
= gen_label_rtx ();
695 for (i
= 0; i
< nwords
; i
++)
696 do_compare_rtx_and_jump (operand_subword_force (op0
, i
, mode
),
697 const0_rtx
, EQ
, 1, word_mode
, NULL_RTX
,
698 if_false_label
, NULL_RTX
);
701 emit_jump (if_true_label
);
703 if (drop_through_label
)
704 emit_label (drop_through_label
);
707 /* Test for the equality of two RTX expressions OP0 and OP1 in mode MODE,
708 where MODE is an integer mode too wide to be compared with one insn.
709 Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL_RTX
710 to indicate drop through. */
713 do_jump_by_parts_equality_rtx (enum machine_mode mode
, rtx op0
, rtx op1
,
714 rtx if_false_label
, rtx if_true_label
)
716 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
717 rtx drop_through_label
= 0;
720 if (op1
== const0_rtx
)
722 do_jump_by_parts_zero_rtx (mode
, op0
, if_false_label
, if_true_label
);
725 else if (op0
== const0_rtx
)
727 do_jump_by_parts_zero_rtx (mode
, op1
, if_false_label
, if_true_label
);
731 if (! if_false_label
)
732 drop_through_label
= if_false_label
= gen_label_rtx ();
734 for (i
= 0; i
< nwords
; i
++)
735 do_compare_rtx_and_jump (operand_subword_force (op0
, i
, mode
),
736 operand_subword_force (op1
, i
, mode
),
737 EQ
, 0, word_mode
, NULL_RTX
,
738 if_false_label
, NULL_RTX
);
741 emit_jump (if_true_label
);
742 if (drop_through_label
)
743 emit_label (drop_through_label
);
746 /* Given an EQ_EXPR expression EXP for values too wide to be compared
747 with one insn, test the comparison and jump to the appropriate label. */
750 do_jump_by_parts_equality (tree exp
, rtx if_false_label
, rtx if_true_label
)
752 rtx op0
= expand_normal (TREE_OPERAND (exp
, 0));
753 rtx op1
= expand_normal (TREE_OPERAND (exp
, 1));
754 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
, 0)));
755 do_jump_by_parts_equality_rtx (mode
, op0
, op1
, if_false_label
,
759 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
760 The decision as to signed or unsigned comparison must be made by the caller.
762 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
766 do_compare_rtx_and_jump (rtx op0
, rtx op1
, enum rtx_code code
, int unsignedp
,
767 enum machine_mode mode
, rtx size
, rtx if_false_label
,
771 int dummy_true_label
= 0;
773 /* Reverse the comparison if that is safe and we want to jump if it is
775 if (! if_true_label
&& ! FLOAT_MODE_P (mode
))
777 if_true_label
= if_false_label
;
779 code
= reverse_condition (code
);
782 /* If one operand is constant, make it the second one. Only do this
783 if the other operand is not constant as well. */
785 if (swap_commutative_operands_p (op0
, op1
))
790 code
= swap_condition (code
);
793 do_pending_stack_adjust ();
795 code
= unsignedp
? unsigned_condition (code
) : code
;
796 if (0 != (tem
= simplify_relational_operation (code
, mode
, VOIDmode
,
799 if (CONSTANT_P (tem
))
801 rtx label
= (tem
== const0_rtx
|| tem
== CONST0_RTX (mode
))
802 ? if_false_label
: if_true_label
;
808 code
= GET_CODE (tem
);
809 mode
= GET_MODE (tem
);
812 unsignedp
= (code
== GTU
|| code
== LTU
|| code
== GEU
|| code
== LEU
);
818 dummy_true_label
= 1;
819 if_true_label
= gen_label_rtx ();
822 if (GET_MODE_CLASS (mode
) == MODE_INT
823 && ! can_compare_p (code
, mode
, ccp_jump
))
828 do_jump_by_parts_greater_rtx (mode
, 1, op1
, op0
,
829 if_false_label
, if_true_label
);
833 do_jump_by_parts_greater_rtx (mode
, 1, op0
, op1
,
834 if_true_label
, if_false_label
);
838 do_jump_by_parts_greater_rtx (mode
, 1, op0
, op1
,
839 if_false_label
, if_true_label
);
843 do_jump_by_parts_greater_rtx (mode
, 1, op1
, op0
,
844 if_true_label
, if_false_label
);
848 do_jump_by_parts_greater_rtx (mode
, 0, op1
, op0
,
849 if_false_label
, if_true_label
);
853 do_jump_by_parts_greater_rtx (mode
, 0, op0
, op1
,
854 if_true_label
, if_false_label
);
858 do_jump_by_parts_greater_rtx (mode
, 0, op0
, op1
,
859 if_false_label
, if_true_label
);
863 do_jump_by_parts_greater_rtx (mode
, 0, op1
, op0
,
864 if_true_label
, if_false_label
);
868 do_jump_by_parts_equality_rtx (mode
, op0
, op1
, if_false_label
,
873 do_jump_by_parts_equality_rtx (mode
, op0
, op1
, if_true_label
,
882 emit_cmp_and_jump_insns (op0
, op1
, code
, size
, mode
, unsignedp
,
886 emit_jump (if_false_label
);
887 if (dummy_true_label
)
888 emit_label (if_true_label
);
891 /* Generate code for a comparison expression EXP (including code to compute
892 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
893 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
894 generated code will drop through.
895 SIGNED_CODE should be the rtx operation for this comparison for
896 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
898 We force a stack adjustment unless there are currently
899 things pushed on the stack that aren't yet used. */
902 do_compare_and_jump (tree exp
, enum rtx_code signed_code
,
903 enum rtx_code unsigned_code
, rtx if_false_label
,
908 enum machine_mode mode
;
912 /* Don't crash if the comparison was erroneous. */
913 op0
= expand_normal (TREE_OPERAND (exp
, 0));
914 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ERROR_MARK
)
917 op1
= expand_normal (TREE_OPERAND (exp
, 1));
918 if (TREE_CODE (TREE_OPERAND (exp
, 1)) == ERROR_MARK
)
921 type
= TREE_TYPE (TREE_OPERAND (exp
, 0));
922 mode
= TYPE_MODE (type
);
923 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == INTEGER_CST
924 && (TREE_CODE (TREE_OPERAND (exp
, 1)) != INTEGER_CST
925 || (GET_MODE_BITSIZE (mode
)
926 > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp
,
929 /* op0 might have been replaced by promoted constant, in which
930 case the type of second argument should be used. */
931 type
= TREE_TYPE (TREE_OPERAND (exp
, 1));
932 mode
= TYPE_MODE (type
);
934 unsignedp
= TYPE_UNSIGNED (type
);
935 code
= unsignedp
? unsigned_code
: signed_code
;
937 #ifdef HAVE_canonicalize_funcptr_for_compare
938 /* If function pointers need to be "canonicalized" before they can
939 be reliably compared, then canonicalize them.
940 Only do this if *both* sides of the comparison are function pointers.
941 If one side isn't, we want a noncanonicalized comparison. See PR
943 if (HAVE_canonicalize_funcptr_for_compare
944 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
945 && TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
947 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 1))) == POINTER_TYPE
948 && TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 1))))
951 rtx new_op0
= gen_reg_rtx (mode
);
952 rtx new_op1
= gen_reg_rtx (mode
);
954 emit_insn (gen_canonicalize_funcptr_for_compare (new_op0
, op0
));
957 emit_insn (gen_canonicalize_funcptr_for_compare (new_op1
, op1
));
962 do_compare_rtx_and_jump (op0
, op1
, code
, unsignedp
, mode
,
964 ? expr_size (TREE_OPERAND (exp
, 0)) : NULL_RTX
),
965 if_false_label
, if_true_label
);
968 #include "gt-dojump.h"