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
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. */
144 XEXP (and_test, 1) = GEN_INT ((unsigned HOST_WIDE_INT) 1 << bitnum);
145 XEXP (XEXP (shift_test, 0), 1) = GEN_INT (bitnum);
147 return (rtx_cost (and_test, IF_THEN_ELSE, optimize_insn_for_speed_p ())
148 <= rtx_cost (shift_test, IF_THEN_ELSE, optimize_insn_for_speed_p ()));
151 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
152 the result is zero, or IF_TRUE_LABEL if the result is one.
153 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
154 meaning fall through in that case.
156 do_jump always does any pending stack adjust except when it does not
157 actually perform a jump. An example where there is no jump
158 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null. */
161 do_jump (tree exp, rtx if_false_label, rtx if_true_label)
163 enum tree_code code = TREE_CODE (exp);
167 enum machine_mode mode;
168 rtx drop_through_label = 0;
176 temp = integer_zerop (exp) ? if_false_label : if_true_label;
182 /* This is not true with #pragma weak */
184 /* The address of something can never be zero. */
186 emit_jump (if_true_label);
191 if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
192 || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
193 || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF
194 || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_RANGE_REF)
197 /* If we are narrowing the operand, we have to do the compare in the
199 if ((TYPE_PRECISION (TREE_TYPE (exp))
200 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
202 case NON_LVALUE_EXPR:
207 /* These cannot change zero->nonzero or vice versa. */
208 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
212 /* fold_single_bit_test() converts (X & (1 << C)) into (X >> C) & 1.
213 See if the former is preferred for jump tests and restore it
215 if (integer_onep (TREE_OPERAND (exp, 1)))
217 tree exp0 = TREE_OPERAND (exp, 0);
218 rtx set_label, clr_label;
220 /* Strip narrowing integral type conversions. */
221 while (CONVERT_EXPR_P (exp0)
222 && TREE_OPERAND (exp0, 0) != error_mark_node
223 && TYPE_PRECISION (TREE_TYPE (exp0))
224 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp0, 0))))
225 exp0 = TREE_OPERAND (exp0, 0);
227 /* "exp0 ^ 1" inverts the sense of the single bit test. */
228 if (TREE_CODE (exp0) == BIT_XOR_EXPR
229 && integer_onep (TREE_OPERAND (exp0, 1)))
231 exp0 = TREE_OPERAND (exp0, 0);
232 clr_label = if_true_label;
233 set_label = if_false_label;
237 clr_label = if_false_label;
238 set_label = if_true_label;
241 if (TREE_CODE (exp0) == RSHIFT_EXPR)
243 tree arg = TREE_OPERAND (exp0, 0);
244 tree shift = TREE_OPERAND (exp0, 1);
245 tree argtype = TREE_TYPE (arg);
246 if (TREE_CODE (shift) == INTEGER_CST
247 && compare_tree_int (shift, 0) >= 0
248 && compare_tree_int (shift, HOST_BITS_PER_WIDE_INT) < 0
249 && prefer_and_bit_test (TYPE_MODE (argtype),
250 TREE_INT_CST_LOW (shift)))
252 HOST_WIDE_INT mask = (HOST_WIDE_INT) 1
253 << TREE_INT_CST_LOW (shift);
254 do_jump (build2 (BIT_AND_EXPR, argtype, arg,
255 build_int_cst_type (argtype, mask)),
256 clr_label, set_label);
262 /* If we are AND'ing with a small constant, do this comparison in the
263 smallest type that fits. If the machine doesn't have comparisons
264 that small, it will be converted back to the wider comparison.
265 This helps if we are testing the sign bit of a narrower object.
266 combine can't do this for us because it can't know whether a
267 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
269 if (! SLOW_BYTE_ACCESS
270 && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
271 && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
272 && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
273 && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
274 && (type = lang_hooks.types.type_for_mode (mode, 1)) != 0
275 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
276 && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code
277 != CODE_FOR_nothing))
279 do_jump (fold_convert (type, exp), if_false_label, if_true_label);
285 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
290 rtx label1 = gen_label_rtx ();
291 if (!if_true_label || !if_false_label)
293 drop_through_label = gen_label_rtx ();
295 if_true_label = drop_through_label;
297 if_false_label = drop_through_label;
300 do_pending_stack_adjust ();
301 do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX);
302 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
304 do_jump (TREE_OPERAND (exp, 2), if_false_label, if_true_label);
309 /* Lowered by gimplify.c. */
315 case ARRAY_RANGE_REF:
317 HOST_WIDE_INT bitsize, bitpos;
319 enum machine_mode mode;
324 /* Get description of this reference. We don't actually care
325 about the underlying object here. */
326 get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
327 &unsignedp, &volatilep, false);
329 type = lang_hooks.types.type_for_size (bitsize, unsignedp);
330 if (! SLOW_BYTE_ACCESS
331 && type != 0 && bitsize >= 0
332 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
333 && (optab_handler (cmp_optab, TYPE_MODE (type))->insn_code
334 != CODE_FOR_nothing))
336 do_jump (fold_convert (type, exp), if_false_label, if_true_label);
344 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
346 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
347 != MODE_COMPLEX_FLOAT);
348 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
349 != MODE_COMPLEX_INT);
351 if (integer_zerop (TREE_OPERAND (exp, 1)))
352 do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
353 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
354 && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
355 do_jump_by_parts_equality (exp, if_false_label, if_true_label);
357 do_compare_and_jump (exp, EQ, EQ, if_false_label, if_true_label);
362 /* Nonzero iff operands of minus differ. */
363 exp = build2 (NE_EXPR, TREE_TYPE (exp),
364 TREE_OPERAND (exp, 0),
365 TREE_OPERAND (exp, 1));
369 tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
371 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
372 != MODE_COMPLEX_FLOAT);
373 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
374 != MODE_COMPLEX_INT);
376 if (integer_zerop (TREE_OPERAND (exp, 1)))
377 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
378 else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
379 && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
380 do_jump_by_parts_equality (exp, if_true_label, if_false_label);
382 do_compare_and_jump (exp, NE, NE, if_false_label, if_true_label);
387 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
388 if (GET_MODE_CLASS (mode) == MODE_INT
389 && ! can_compare_p (LT, mode, ccp_jump))
390 do_jump_by_parts_greater (exp, 1, if_false_label, if_true_label);
392 do_compare_and_jump (exp, LT, LTU, if_false_label, if_true_label);
396 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
397 if (GET_MODE_CLASS (mode) == MODE_INT
398 && ! can_compare_p (LE, mode, ccp_jump))
399 do_jump_by_parts_greater (exp, 0, if_true_label, if_false_label);
401 do_compare_and_jump (exp, LE, LEU, if_false_label, if_true_label);
405 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
406 if (GET_MODE_CLASS (mode) == MODE_INT
407 && ! can_compare_p (GT, mode, ccp_jump))
408 do_jump_by_parts_greater (exp, 0, if_false_label, if_true_label);
410 do_compare_and_jump (exp, GT, GTU, if_false_label, if_true_label);
414 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
415 if (GET_MODE_CLASS (mode) == MODE_INT
416 && ! can_compare_p (GE, mode, ccp_jump))
417 do_jump_by_parts_greater (exp, 1, if_true_label, if_false_label);
419 do_compare_and_jump (exp, GE, GEU, if_false_label, if_true_label);
425 enum rtx_code cmp, rcmp;
428 if (code == UNORDERED_EXPR)
429 cmp = UNORDERED, rcmp = ORDERED;
431 cmp = ORDERED, rcmp = UNORDERED;
432 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
435 if (! can_compare_p (cmp, mode, ccp_jump)
436 && (can_compare_p (rcmp, mode, ccp_jump)
437 /* If the target doesn't provide either UNORDERED or ORDERED
438 comparisons, canonicalize on UNORDERED for the library. */
439 || rcmp == UNORDERED))
443 do_compare_and_jump (exp, cmp, cmp, if_false_label, if_true_label);
445 do_compare_and_jump (exp, rcmp, rcmp, if_true_label, if_false_label);
450 enum rtx_code rcode1;
451 enum tree_code tcode1, tcode2;
455 tcode1 = UNORDERED_EXPR;
460 tcode1 = UNORDERED_EXPR;
465 tcode1 = UNORDERED_EXPR;
470 tcode1 = UNORDERED_EXPR;
475 tcode1 = UNORDERED_EXPR;
479 /* It is ok for LTGT_EXPR to trap when the result is unordered,
480 so expand to (a < b) || (a > b). */
487 mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
488 if (can_compare_p (rcode1, mode, ccp_jump))
489 do_compare_and_jump (exp, rcode1, rcode1, if_false_label,
493 tree op0 = save_expr (TREE_OPERAND (exp, 0));
494 tree op1 = save_expr (TREE_OPERAND (exp, 1));
497 /* If the target doesn't support combined unordered
498 compares, decompose into two comparisons. */
499 if (if_true_label == 0)
500 drop_through_label = if_true_label = gen_label_rtx ();
502 cmp0 = fold_build2 (tcode1, TREE_TYPE (exp), op0, op1);
503 cmp1 = fold_build2 (tcode2, TREE_TYPE (exp), op0, op1);
504 do_jump (cmp0, 0, if_true_label);
505 do_jump (cmp1, if_false_label, if_true_label);
511 /* High branch cost, expand as the bitwise AND of the conditions.
512 Do the same if the RHS has side effects, because we're effectively
513 turning a TRUTH_AND_EXPR into a TRUTH_ANDIF_EXPR. */
514 if (BRANCH_COST (optimize_insn_for_speed_p (),
516 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
519 case TRUTH_ANDIF_EXPR:
520 if (if_false_label == NULL_RTX)
522 drop_through_label = gen_label_rtx ();
523 do_jump (TREE_OPERAND (exp, 0), drop_through_label, NULL_RTX);
524 do_jump (TREE_OPERAND (exp, 1), NULL_RTX, if_true_label);
528 do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX);
529 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
534 /* High branch cost, expand as the bitwise OR of the conditions.
535 Do the same if the RHS has side effects, because we're effectively
536 turning a TRUTH_OR_EXPR into a TRUTH_ORIF_EXPR. */
537 if (BRANCH_COST (optimize_insn_for_speed_p (), false)>= 4
538 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
541 case TRUTH_ORIF_EXPR:
542 if (if_true_label == NULL_RTX)
544 drop_through_label = gen_label_rtx ();
545 do_jump (TREE_OPERAND (exp, 0), NULL_RTX, drop_through_label);
546 do_jump (TREE_OPERAND (exp, 1), if_false_label, NULL_RTX);
550 do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label);
551 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label);
555 /* Fall through and generate the normal code. */
558 temp = expand_normal (exp);
559 do_pending_stack_adjust ();
560 /* The RTL optimizers prefer comparisons against pseudos. */
561 if (GET_CODE (temp) == SUBREG)
563 /* Compare promoted variables in their promoted mode. */
564 if (SUBREG_PROMOTED_VAR_P (temp)
565 && REG_P (XEXP (temp, 0)))
566 temp = XEXP (temp, 0);
568 temp = copy_to_reg (temp);
570 do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
571 NE, TYPE_UNSIGNED (TREE_TYPE (exp)),
572 GET_MODE (temp), NULL_RTX,
573 if_false_label, if_true_label);
576 if (drop_through_label)
578 do_pending_stack_adjust ();
579 emit_label (drop_through_label);
583 /* Compare OP0 with OP1, word at a time, in mode MODE.
584 UNSIGNEDP says to do unsigned comparison.
585 Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
588 do_jump_by_parts_greater_rtx (enum machine_mode mode, int unsignedp, rtx op0,
589 rtx op1, rtx if_false_label, rtx if_true_label)
591 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
592 rtx drop_through_label = 0;
595 if (! if_true_label || ! if_false_label)
596 drop_through_label = gen_label_rtx ();
598 if_true_label = drop_through_label;
599 if (! if_false_label)
600 if_false_label = drop_through_label;
602 /* Compare a word at a time, high order first. */
603 for (i = 0; i < nwords; i++)
605 rtx op0_word, op1_word;
607 if (WORDS_BIG_ENDIAN)
609 op0_word = operand_subword_force (op0, i, mode);
610 op1_word = operand_subword_force (op1, i, mode);
614 op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
615 op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
618 /* All but high-order word must be compared as unsigned. */
619 do_compare_rtx_and_jump (op0_word, op1_word, GT,
620 (unsignedp || i > 0), word_mode, NULL_RTX,
621 NULL_RTX, if_true_label);
623 /* Consider lower words only if these are equal. */
624 do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
625 NULL_RTX, NULL_RTX, if_false_label);
629 emit_jump (if_false_label);
630 if (drop_through_label)
631 emit_label (drop_through_label);
634 /* Given a comparison expression EXP for values too wide to be compared
635 with one insn, test the comparison and jump to the appropriate label.
636 The code of EXP is ignored; we always test GT if SWAP is 0,
637 and LT if SWAP is 1. */
640 do_jump_by_parts_greater (tree exp, int swap, rtx if_false_label,
643 rtx op0 = expand_normal (TREE_OPERAND (exp, swap));
644 rtx op1 = expand_normal (TREE_OPERAND (exp, !swap));
645 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
646 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0)));
648 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label,
652 /* Jump according to whether OP0 is 0. We assume that OP0 has an integer
653 mode, MODE, that is too wide for the available compare insns. Either
654 Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL_RTX
655 to indicate drop through. */
658 do_jump_by_parts_zero_rtx (enum machine_mode mode, rtx op0,
659 rtx if_false_label, rtx if_true_label)
661 int nwords = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
664 rtx drop_through_label = 0;
666 /* The fastest way of doing this comparison on almost any machine is to
667 "or" all the words and compare the result. If all have to be loaded
668 from memory and this is a very wide item, it's possible this may
669 be slower, but that's highly unlikely. */
671 part = gen_reg_rtx (word_mode);
672 emit_move_insn (part, operand_subword_force (op0, 0, GET_MODE (op0)));
673 for (i = 1; i < nwords && part != 0; i++)
674 part = expand_binop (word_mode, ior_optab, part,
675 operand_subword_force (op0, i, GET_MODE (op0)),
676 part, 1, OPTAB_WIDEN);
680 do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode,
681 NULL_RTX, if_false_label, if_true_label);
686 /* If we couldn't do the "or" simply, do this with a series of compares. */
687 if (! if_false_label)
688 drop_through_label = if_false_label = gen_label_rtx ();
690 for (i = 0; i < nwords; i++)
691 do_compare_rtx_and_jump (operand_subword_force (op0, i, GET_MODE (op0)),
692 const0_rtx, EQ, 1, word_mode, NULL_RTX,
693 if_false_label, NULL_RTX);
696 emit_jump (if_true_label);
698 if (drop_through_label)
699 emit_label (drop_through_label);
702 /* Test for the equality of two RTX expressions OP0 and OP1 in mode MODE,
703 where MODE is an integer mode too wide to be compared with one insn.
704 Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL_RTX
705 to indicate drop through. */
708 do_jump_by_parts_equality_rtx (enum machine_mode mode, rtx op0, rtx op1,
709 rtx if_false_label, rtx if_true_label)
711 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
712 rtx drop_through_label = 0;
715 if (op1 == const0_rtx)
717 do_jump_by_parts_zero_rtx (mode, op0, if_false_label, if_true_label);
720 else if (op0 == const0_rtx)
722 do_jump_by_parts_zero_rtx (mode, op1, if_false_label, if_true_label);
726 if (! if_false_label)
727 drop_through_label = if_false_label = gen_label_rtx ();
729 for (i = 0; i < nwords; i++)
730 do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
731 operand_subword_force (op1, i, mode),
732 EQ, 0, word_mode, NULL_RTX,
733 if_false_label, NULL_RTX);
736 emit_jump (if_true_label);
737 if (drop_through_label)
738 emit_label (drop_through_label);
741 /* Given an EQ_EXPR expression EXP for values too wide to be compared
742 with one insn, test the comparison and jump to the appropriate label. */
745 do_jump_by_parts_equality (tree exp, rtx if_false_label, rtx if_true_label)
747 rtx op0 = expand_normal (TREE_OPERAND (exp, 0));
748 rtx op1 = expand_normal (TREE_OPERAND (exp, 1));
749 enum machine_mode mode = TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0)));
750 do_jump_by_parts_equality_rtx (mode, op0, op1, if_false_label,
754 /* Generate code for a comparison of OP0 and OP1 with rtx code CODE.
755 MODE is the machine mode of the comparison, not of the result.
756 (including code to compute the values to be compared) and set CC0
757 according to the result. The decision as to signed or unsigned
758 comparison must be made by the caller.
760 We force a stack adjustment unless there are currently
761 things pushed on the stack that aren't yet used.
763 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
767 compare_from_rtx (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
768 enum machine_mode mode, rtx size)
772 /* If one operand is constant, make it the second one. Only do this
773 if the other operand is not constant as well. */
775 if (swap_commutative_operands_p (op0, op1))
780 code = swap_condition (code);
783 do_pending_stack_adjust ();
785 code = unsignedp ? unsigned_condition (code) : code;
786 tem = simplify_relational_operation (code, VOIDmode, mode, op0, op1);
789 if (CONSTANT_P (tem))
792 if (COMPARISON_P (tem))
794 code = GET_CODE (tem);
797 mode = GET_MODE (op0);
798 unsignedp = (code == GTU || code == LTU
799 || code == GEU || code == LEU);
803 emit_cmp_insn (op0, op1, code, size, mode, unsignedp);
806 return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
808 return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
812 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
813 The decision as to signed or unsigned comparison must be made by the caller.
815 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
819 do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
820 enum machine_mode mode, rtx size, rtx if_false_label,
824 int dummy_true_label = 0;
826 /* Reverse the comparison if that is safe and we want to jump if it is
828 if (! if_true_label && ! FLOAT_MODE_P (mode))
830 if_true_label = if_false_label;
832 code = reverse_condition (code);
835 /* If one operand is constant, make it the second one. Only do this
836 if the other operand is not constant as well. */
838 if (swap_commutative_operands_p (op0, op1))
843 code = swap_condition (code);
846 do_pending_stack_adjust ();
848 code = unsignedp ? unsigned_condition (code) : code;
849 if (0 != (tem = simplify_relational_operation (code, mode, VOIDmode,
852 if (CONSTANT_P (tem))
854 rtx label = (tem == const0_rtx || tem == CONST0_RTX (mode))
855 ? if_false_label : if_true_label;
861 code = GET_CODE (tem);
862 mode = GET_MODE (tem);
865 unsignedp = (code == GTU || code == LTU || code == GEU || code == LEU);
871 dummy_true_label = 1;
872 if_true_label = gen_label_rtx ();
875 if (GET_MODE_CLASS (mode) == MODE_INT
876 && ! can_compare_p (code, mode, ccp_jump))
881 do_jump_by_parts_greater_rtx (mode, 1, op1, op0,
882 if_false_label, if_true_label);
886 do_jump_by_parts_greater_rtx (mode, 1, op0, op1,
887 if_true_label, if_false_label);
891 do_jump_by_parts_greater_rtx (mode, 1, op0, op1,
892 if_false_label, if_true_label);
896 do_jump_by_parts_greater_rtx (mode, 1, op1, op0,
897 if_true_label, if_false_label);
901 do_jump_by_parts_greater_rtx (mode, 0, op1, op0,
902 if_false_label, if_true_label);
906 do_jump_by_parts_greater_rtx (mode, 0, op0, op1,
907 if_true_label, if_false_label);
911 do_jump_by_parts_greater_rtx (mode, 0, op0, op1,
912 if_false_label, if_true_label);
916 do_jump_by_parts_greater_rtx (mode, 0, op1, op0,
917 if_true_label, if_false_label);
921 do_jump_by_parts_equality_rtx (mode, op0, op1, if_false_label,
926 do_jump_by_parts_equality_rtx (mode, op0, op1, if_true_label,
935 emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp,
939 emit_jump (if_false_label);
940 if (dummy_true_label)
941 emit_label (if_true_label);
944 /* Generate code for a comparison expression EXP (including code to compute
945 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
946 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
947 generated code will drop through.
948 SIGNED_CODE should be the rtx operation for this comparison for
949 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
951 We force a stack adjustment unless there are currently
952 things pushed on the stack that aren't yet used. */
955 do_compare_and_jump (tree exp, enum rtx_code signed_code,
956 enum rtx_code unsigned_code, rtx if_false_label,
961 enum machine_mode mode;
965 /* Don't crash if the comparison was erroneous. */
966 op0 = expand_normal (TREE_OPERAND (exp, 0));
967 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ERROR_MARK)
970 op1 = expand_normal (TREE_OPERAND (exp, 1));
971 if (TREE_CODE (TREE_OPERAND (exp, 1)) == ERROR_MARK)
974 type = TREE_TYPE (TREE_OPERAND (exp, 0));
975 mode = TYPE_MODE (type);
976 if (TREE_CODE (TREE_OPERAND (exp, 0)) == INTEGER_CST
977 && (TREE_CODE (TREE_OPERAND (exp, 1)) != INTEGER_CST
978 || (GET_MODE_BITSIZE (mode)
979 > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp,
982 /* op0 might have been replaced by promoted constant, in which
983 case the type of second argument should be used. */
984 type = TREE_TYPE (TREE_OPERAND (exp, 1));
985 mode = TYPE_MODE (type);
987 unsignedp = TYPE_UNSIGNED (type);
988 code = unsignedp ? unsigned_code : signed_code;
990 #ifdef HAVE_canonicalize_funcptr_for_compare
991 /* If function pointers need to be "canonicalized" before they can
992 be reliably compared, then canonicalize them.
993 Only do this if *both* sides of the comparison are function pointers.
994 If one side isn't, we want a noncanonicalized comparison. See PR
996 if (HAVE_canonicalize_funcptr_for_compare
997 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
998 && TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
1000 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 1))) == POINTER_TYPE
1001 && TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 1))))
1004 rtx new_op0 = gen_reg_rtx (mode);
1005 rtx new_op1 = gen_reg_rtx (mode);
1007 emit_insn (gen_canonicalize_funcptr_for_compare (new_op0, op0));
1010 emit_insn (gen_canonicalize_funcptr_for_compare (new_op1, op1));
1015 do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
1017 ? expr_size (TREE_OPERAND (exp, 0)) : NULL_RTX),
1018 if_false_label, if_true_label);
1021 #include "gt-dojump.h"