1 /* Convert tree expression to rtl instructions, for GNU compiler.
2 Copyright (C) 1988-2022 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
32 #include "fold-const.h"
33 #include "stor-layout.h"
34 /* Include expr.h after insn-config.h so we get HAVE_conditional_move. */
38 #include "langhooks.h"
40 static bool prefer_and_bit_test (scalar_int_mode
, int);
41 static void do_jump (tree
, rtx_code_label
*, rtx_code_label
*,
43 static void do_jump_by_parts_greater (scalar_int_mode
, tree
, tree
, int,
44 rtx_code_label
*, rtx_code_label
*,
46 static void do_jump_by_parts_equality (scalar_int_mode
, tree
, tree
,
47 rtx_code_label
*, rtx_code_label
*,
49 static void do_compare_and_jump (tree
, tree
, enum rtx_code
, enum rtx_code
,
50 rtx_code_label
*, rtx_code_label
*,
53 /* At the start of a function, record that we have no previously-pushed
54 arguments waiting to be popped. */
57 init_pending_stack_adjust (void)
59 pending_stack_adjust
= 0;
62 /* Discard any pending stack adjustment. This avoid relying on the
63 RTL optimizers to remove useless adjustments when we know the
64 stack pointer value is dead. */
66 discard_pending_stack_adjust (void)
68 stack_pointer_delta
-= pending_stack_adjust
;
69 pending_stack_adjust
= 0;
72 /* When exiting from function, if safe, clear out any pending stack adjust
73 so the adjustment won't get done.
75 Note, if the current function calls alloca, then it must have a
76 frame pointer regardless of the value of flag_omit_frame_pointer. */
79 clear_pending_stack_adjust (void)
82 && (! flag_omit_frame_pointer
|| cfun
->calls_alloca
)
84 discard_pending_stack_adjust ();
87 /* Pop any previously-pushed arguments that have not been popped yet. */
90 do_pending_stack_adjust (void)
92 if (inhibit_defer_pop
== 0)
94 if (maybe_ne (pending_stack_adjust
, 0))
95 adjust_stack (gen_int_mode (pending_stack_adjust
, Pmode
));
96 pending_stack_adjust
= 0;
100 /* Remember pending_stack_adjust/stack_pointer_delta.
101 To be used around code that may call do_pending_stack_adjust (),
102 but the generated code could be discarded e.g. using delete_insns_since. */
105 save_pending_stack_adjust (saved_pending_stack_adjust
*save
)
107 save
->x_pending_stack_adjust
= pending_stack_adjust
;
108 save
->x_stack_pointer_delta
= stack_pointer_delta
;
111 /* Restore the saved pending_stack_adjust/stack_pointer_delta. */
114 restore_pending_stack_adjust (saved_pending_stack_adjust
*save
)
116 if (inhibit_defer_pop
== 0)
118 pending_stack_adjust
= save
->x_pending_stack_adjust
;
119 stack_pointer_delta
= save
->x_stack_pointer_delta
;
123 /* Used internally by prefer_and_bit_test. */
125 static GTY(()) rtx and_reg
;
126 static GTY(()) rtx and_test
;
127 static GTY(()) rtx shift_test
;
129 /* Compare the relative costs of "(X & (1 << BITNUM))" and "(X >> BITNUM) & 1",
130 where X is an arbitrary register of mode MODE. Return true if the former
134 prefer_and_bit_test (scalar_int_mode mode
, int bitnum
)
137 wide_int mask
= wi::set_bit_in_zero (bitnum
, GET_MODE_PRECISION (mode
));
141 /* Set up rtxes for the two variations. Use NULL as a placeholder
142 for the BITNUM-based constants. */
143 and_reg
= gen_rtx_REG (mode
, LAST_VIRTUAL_REGISTER
+ 1);
144 and_test
= gen_rtx_AND (mode
, and_reg
, NULL
);
145 shift_test
= gen_rtx_AND (mode
, gen_rtx_ASHIFTRT (mode
, and_reg
, NULL
),
150 /* Change the mode of the previously-created rtxes. */
151 PUT_MODE (and_reg
, mode
);
152 PUT_MODE (and_test
, mode
);
153 PUT_MODE (shift_test
, mode
);
154 PUT_MODE (XEXP (shift_test
, 0), mode
);
157 /* Fill in the integers. */
158 XEXP (and_test
, 1) = immed_wide_int_const (mask
, mode
);
159 XEXP (XEXP (shift_test
, 0), 1) = GEN_INT (bitnum
);
161 speed_p
= optimize_insn_for_speed_p ();
162 return (rtx_cost (and_test
, mode
, IF_THEN_ELSE
, 0, speed_p
)
163 <= rtx_cost (shift_test
, mode
, IF_THEN_ELSE
, 0, speed_p
));
166 /* Subroutine of do_jump, dealing with exploded comparisons of the type
167 OP0 CODE OP1 . IF_FALSE_LABEL and IF_TRUE_LABEL like in do_jump.
168 PROB is probability of jump to if_true_label. */
171 do_jump_1 (enum tree_code code
, tree op0
, tree op1
,
172 rtx_code_label
*if_false_label
, rtx_code_label
*if_true_label
,
173 profile_probability prob
)
176 rtx_code_label
*drop_through_label
= 0;
177 scalar_int_mode int_mode
;
183 tree inner_type
= TREE_TYPE (op0
);
185 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
186 != MODE_COMPLEX_FLOAT
);
187 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
188 != MODE_COMPLEX_INT
);
190 if (integer_zerop (op1
))
191 do_jump (op0
, if_true_label
, if_false_label
,
193 else if (is_int_mode (TYPE_MODE (inner_type
), &int_mode
)
194 && !can_compare_p (EQ
, int_mode
, ccp_jump
))
195 do_jump_by_parts_equality (int_mode
, op0
, op1
, if_false_label
,
196 if_true_label
, prob
);
198 do_compare_and_jump (op0
, op1
, EQ
, EQ
, if_false_label
, if_true_label
,
205 tree inner_type
= TREE_TYPE (op0
);
207 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
208 != MODE_COMPLEX_FLOAT
);
209 gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type
))
210 != MODE_COMPLEX_INT
);
212 if (integer_zerop (op1
))
213 do_jump (op0
, if_false_label
, if_true_label
, prob
);
214 else if (is_int_mode (TYPE_MODE (inner_type
), &int_mode
)
215 && !can_compare_p (NE
, int_mode
, ccp_jump
))
216 do_jump_by_parts_equality (int_mode
, op0
, op1
, if_true_label
,
217 if_false_label
, prob
.invert ());
219 do_compare_and_jump (op0
, op1
, NE
, NE
, if_false_label
, if_true_label
,
225 mode
= TYPE_MODE (TREE_TYPE (op0
));
226 if (is_int_mode (mode
, &int_mode
)
227 && ! can_compare_p (LT
, int_mode
, ccp_jump
))
228 do_jump_by_parts_greater (int_mode
, op0
, op1
, 1, if_false_label
,
229 if_true_label
, prob
);
231 do_compare_and_jump (op0
, op1
, LT
, LTU
, if_false_label
, if_true_label
,
236 mode
= TYPE_MODE (TREE_TYPE (op0
));
237 if (is_int_mode (mode
, &int_mode
)
238 && ! can_compare_p (LE
, int_mode
, ccp_jump
))
239 do_jump_by_parts_greater (int_mode
, op0
, op1
, 0, if_true_label
,
240 if_false_label
, prob
.invert ());
242 do_compare_and_jump (op0
, op1
, LE
, LEU
, if_false_label
, if_true_label
,
247 mode
= TYPE_MODE (TREE_TYPE (op0
));
248 if (is_int_mode (mode
, &int_mode
)
249 && ! can_compare_p (GT
, int_mode
, ccp_jump
))
250 do_jump_by_parts_greater (int_mode
, op0
, op1
, 0, if_false_label
,
251 if_true_label
, prob
);
253 do_compare_and_jump (op0
, op1
, GT
, GTU
, if_false_label
, if_true_label
,
258 mode
= TYPE_MODE (TREE_TYPE (op0
));
259 if (is_int_mode (mode
, &int_mode
)
260 && ! can_compare_p (GE
, int_mode
, ccp_jump
))
261 do_jump_by_parts_greater (int_mode
, op0
, op1
, 1, if_true_label
,
262 if_false_label
, prob
.invert ());
264 do_compare_and_jump (op0
, op1
, GE
, GEU
, if_false_label
, if_true_label
,
269 do_compare_and_jump (op0
, op1
, ORDERED
, ORDERED
,
270 if_false_label
, if_true_label
, prob
);
274 do_compare_and_jump (op0
, op1
, UNORDERED
, UNORDERED
,
275 if_false_label
, if_true_label
, prob
);
279 do_compare_and_jump (op0
, op1
, UNLT
, UNLT
, if_false_label
, if_true_label
,
284 do_compare_and_jump (op0
, op1
, UNLE
, UNLE
, if_false_label
, if_true_label
,
289 do_compare_and_jump (op0
, op1
, UNGT
, UNGT
, if_false_label
, if_true_label
,
294 do_compare_and_jump (op0
, op1
, UNGE
, UNGE
, if_false_label
, if_true_label
,
299 do_compare_and_jump (op0
, op1
, UNEQ
, UNEQ
, if_false_label
, if_true_label
,
304 do_compare_and_jump (op0
, op1
, LTGT
, LTGT
, if_false_label
, if_true_label
,
308 case TRUTH_ANDIF_EXPR
:
310 /* Spread the probability that the expression is false evenly between
311 the two conditions. So the first condition is false half the total
312 probability of being false. The second condition is false the other
313 half of the total probability of being false, so its jump has a false
314 probability of half the total, relative to the probability we
315 reached it (i.e. the first condition was true). */
316 profile_probability op0_prob
= profile_probability::uninitialized ();
317 profile_probability op1_prob
= profile_probability::uninitialized ();
318 if (prob
.initialized_p ())
320 op1_prob
= prob
.invert ();
321 op0_prob
= op1_prob
.split (profile_probability::even ());
322 /* Get the probability that each jump below is true. */
323 op0_prob
= op0_prob
.invert ();
324 op1_prob
= op1_prob
.invert ();
326 if (if_false_label
== NULL
)
328 drop_through_label
= gen_label_rtx ();
329 do_jump (op0
, drop_through_label
, NULL
, op0_prob
);
330 do_jump (op1
, NULL
, if_true_label
, op1_prob
);
334 do_jump (op0
, if_false_label
, NULL
, op0_prob
);
335 do_jump (op1
, if_false_label
, if_true_label
, op1_prob
);
340 case TRUTH_ORIF_EXPR
:
342 /* Spread the probability evenly between the two conditions. So
343 the first condition has half the total probability of being true.
344 The second condition has the other half of the total probability,
345 so its jump has a probability of half the total, relative to
346 the probability we reached it (i.e. the first condition was false). */
347 profile_probability op0_prob
= profile_probability::uninitialized ();
348 profile_probability op1_prob
= profile_probability::uninitialized ();
349 if (prob
.initialized_p ())
352 op0_prob
= op1_prob
.split (profile_probability::even ());
354 if (if_true_label
== NULL
)
356 drop_through_label
= gen_label_rtx ();
357 do_jump (op0
, NULL
, drop_through_label
, op0_prob
);
358 do_jump (op1
, if_false_label
, NULL
, op1_prob
);
362 do_jump (op0
, NULL
, if_true_label
, op0_prob
);
363 do_jump (op1
, if_false_label
, if_true_label
, op1_prob
);
372 if (drop_through_label
)
374 do_pending_stack_adjust ();
375 emit_label (drop_through_label
);
379 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
380 the result is zero, or IF_TRUE_LABEL if the result is one.
381 Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
382 meaning fall through in that case.
384 do_jump always does any pending stack adjust except when it does not
385 actually perform a jump. An example where there is no jump
386 is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
388 PROB is probability of jump to if_true_label. */
391 do_jump (tree exp
, rtx_code_label
*if_false_label
,
392 rtx_code_label
*if_true_label
, profile_probability prob
)
394 enum tree_code code
= TREE_CODE (exp
);
398 scalar_int_mode mode
;
399 rtx_code_label
*drop_through_label
= NULL
;
408 rtx_code_label
*lab
= integer_zerop (exp
) ? if_false_label
416 /* This is not true with #pragma weak */
418 /* The address of something can never be zero. */
420 emit_jump (if_true_label
);
425 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == COMPONENT_REF
426 || TREE_CODE (TREE_OPERAND (exp
, 0)) == BIT_FIELD_REF
427 || TREE_CODE (TREE_OPERAND (exp
, 0)) == ARRAY_REF
428 || TREE_CODE (TREE_OPERAND (exp
, 0)) == ARRAY_RANGE_REF
)
430 /* If we are narrowing the operand, we have to do the compare in the
432 if ((TYPE_PRECISION (TREE_TYPE (exp
))
433 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0)))))
436 case NON_LVALUE_EXPR
:
442 /* These cannot change zero->nonzero or vice versa. */
443 do_jump (TREE_OPERAND (exp
, 0), if_false_label
, if_true_label
, prob
);
447 do_jump (TREE_OPERAND (exp
, 0), if_true_label
, if_false_label
,
453 rtx_code_label
*label1
= gen_label_rtx ();
454 if (!if_true_label
|| !if_false_label
)
456 drop_through_label
= gen_label_rtx ();
458 if_true_label
= drop_through_label
;
460 if_false_label
= drop_through_label
;
463 do_pending_stack_adjust ();
464 do_jump (TREE_OPERAND (exp
, 0), label1
, NULL
,
465 profile_probability::uninitialized ());
466 do_jump (TREE_OPERAND (exp
, 1), if_false_label
, if_true_label
, prob
);
468 do_jump (TREE_OPERAND (exp
, 2), if_false_label
, if_true_label
, prob
);
473 /* Lowered by gimplify.cc. */
477 /* Nonzero iff operands of minus differ. */
495 case TRUTH_ANDIF_EXPR
:
496 case TRUTH_ORIF_EXPR
:
498 do_jump_1 (code
, TREE_OPERAND (exp
, 0), TREE_OPERAND (exp
, 1),
499 if_false_label
, if_true_label
, prob
);
503 /* fold_single_bit_test() converts (X & (1 << C)) into (X >> C) & 1.
504 See if the former is preferred for jump tests and restore it
506 if (integer_onep (TREE_OPERAND (exp
, 1)))
508 tree exp0
= TREE_OPERAND (exp
, 0);
509 rtx_code_label
*set_label
, *clr_label
;
510 profile_probability setclr_prob
= prob
;
512 /* Strip narrowing integral type conversions. */
513 while (CONVERT_EXPR_P (exp0
)
514 && TREE_OPERAND (exp0
, 0) != error_mark_node
515 && TYPE_PRECISION (TREE_TYPE (exp0
))
516 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp0
, 0))))
517 exp0
= TREE_OPERAND (exp0
, 0);
519 /* "exp0 ^ 1" inverts the sense of the single bit test. */
520 if (TREE_CODE (exp0
) == BIT_XOR_EXPR
521 && integer_onep (TREE_OPERAND (exp0
, 1)))
523 exp0
= TREE_OPERAND (exp0
, 0);
524 clr_label
= if_true_label
;
525 set_label
= if_false_label
;
526 setclr_prob
= prob
.invert ();
530 clr_label
= if_false_label
;
531 set_label
= if_true_label
;
534 if (TREE_CODE (exp0
) == RSHIFT_EXPR
)
536 tree arg
= TREE_OPERAND (exp0
, 0);
537 tree shift
= TREE_OPERAND (exp0
, 1);
538 tree argtype
= TREE_TYPE (arg
);
539 if (TREE_CODE (shift
) == INTEGER_CST
540 && compare_tree_int (shift
, 0) >= 0
541 && compare_tree_int (shift
, HOST_BITS_PER_WIDE_INT
) < 0
542 && prefer_and_bit_test (SCALAR_INT_TYPE_MODE (argtype
),
543 TREE_INT_CST_LOW (shift
)))
545 unsigned HOST_WIDE_INT mask
546 = HOST_WIDE_INT_1U
<< TREE_INT_CST_LOW (shift
);
547 do_jump (build2 (BIT_AND_EXPR
, argtype
, arg
,
548 build_int_cstu (argtype
, mask
)),
549 clr_label
, set_label
, setclr_prob
);
555 /* If we are AND'ing with a small constant, do this comparison in the
556 smallest type that fits. If the machine doesn't have comparisons
557 that small, it will be converted back to the wider comparison.
558 This helps if we are testing the sign bit of a narrower object.
559 combine can't do this for us because it can't know whether a
560 ZERO_EXTRACT or a compare in a smaller mode exists, but we do. */
562 if (! SLOW_BYTE_ACCESS
563 && TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
564 && TYPE_PRECISION (TREE_TYPE (exp
)) <= HOST_BITS_PER_WIDE_INT
565 && (i
= tree_floor_log2 (TREE_OPERAND (exp
, 1))) >= 0
566 && int_mode_for_size (i
+ 1, 0).exists (&mode
)
567 && (type
= lang_hooks
.types
.type_for_mode (mode
, 1)) != 0
568 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (exp
))
569 && have_insn_for (COMPARE
, TYPE_MODE (type
)))
571 do_jump (fold_convert (type
, exp
), if_false_label
, if_true_label
,
576 if (TYPE_PRECISION (TREE_TYPE (exp
)) > 1
577 || TREE_CODE (TREE_OPERAND (exp
, 1)) == INTEGER_CST
)
580 /* Boolean comparisons can be compiled as TRUTH_AND_EXPR. */
584 /* High branch cost, expand as the bitwise AND of the conditions.
585 Do the same if the RHS has side effects, because we're effectively
586 turning a TRUTH_AND_EXPR into a TRUTH_ANDIF_EXPR. */
587 if (BRANCH_COST (optimize_insn_for_speed_p (),
589 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 1)))
591 code
= TRUTH_ANDIF_EXPR
;
596 /* High branch cost, expand as the bitwise OR of the conditions.
597 Do the same if the RHS has side effects, because we're effectively
598 turning a TRUTH_OR_EXPR into a TRUTH_ORIF_EXPR. */
599 if (BRANCH_COST (optimize_insn_for_speed_p (), false) >= 4
600 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp
, 1)))
602 code
= TRUTH_ORIF_EXPR
;
605 /* Fall through and generate the normal code. */
608 temp
= expand_normal (exp
);
609 do_pending_stack_adjust ();
610 /* The RTL optimizers prefer comparisons against pseudos. */
611 if (GET_CODE (temp
) == SUBREG
)
613 /* Compare promoted variables in their promoted mode. */
614 if (SUBREG_PROMOTED_VAR_P (temp
)
615 && REG_P (XEXP (temp
, 0)))
616 temp
= XEXP (temp
, 0);
618 temp
= copy_to_reg (temp
);
620 do_compare_rtx_and_jump (temp
, CONST0_RTX (GET_MODE (temp
)),
621 NE
, TYPE_UNSIGNED (TREE_TYPE (exp
)),
622 GET_MODE (temp
), NULL_RTX
,
623 if_false_label
, if_true_label
, prob
);
626 if (drop_through_label
)
628 do_pending_stack_adjust ();
629 emit_label (drop_through_label
);
633 /* Compare OP0 with OP1, word at a time, in mode MODE.
634 UNSIGNEDP says to do unsigned comparison.
635 Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise. */
638 do_jump_by_parts_greater_rtx (scalar_int_mode mode
, int unsignedp
, rtx op0
,
639 rtx op1
, rtx_code_label
*if_false_label
,
640 rtx_code_label
*if_true_label
,
641 profile_probability prob
)
643 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
644 rtx_code_label
*drop_through_label
= 0;
645 bool drop_through_if_true
= false, drop_through_if_false
= false;
646 enum rtx_code code
= GT
;
649 if (! if_true_label
|| ! if_false_label
)
650 drop_through_label
= gen_label_rtx ();
653 if_true_label
= drop_through_label
;
654 drop_through_if_true
= true;
656 if (! if_false_label
)
658 if_false_label
= drop_through_label
;
659 drop_through_if_false
= true;
662 /* Deal with the special case 0 > x: only one comparison is necessary and
663 we reverse it to avoid jumping to the drop-through label. */
664 if (op0
== const0_rtx
&& drop_through_if_true
&& !drop_through_if_false
)
667 if_true_label
= if_false_label
;
668 if_false_label
= drop_through_label
;
669 prob
= prob
.invert ();
672 /* Compare a word at a time, high order first. */
673 for (i
= 0; i
< nwords
; i
++)
675 rtx op0_word
, op1_word
;
677 if (WORDS_BIG_ENDIAN
)
679 op0_word
= operand_subword_force (op0
, i
, mode
);
680 op1_word
= operand_subword_force (op1
, i
, mode
);
684 op0_word
= operand_subword_force (op0
, nwords
- 1 - i
, mode
);
685 op1_word
= operand_subword_force (op1
, nwords
- 1 - i
, mode
);
688 /* All but high-order word must be compared as unsigned. */
689 do_compare_rtx_and_jump (op0_word
, op1_word
, code
, (unsignedp
|| i
> 0),
690 word_mode
, NULL_RTX
, NULL
, if_true_label
,
693 /* Emit only one comparison for 0. Do not emit the last cond jump. */
694 if (op0
== const0_rtx
|| i
== nwords
- 1)
697 /* Consider lower words only if these are equal. */
698 do_compare_rtx_and_jump (op0_word
, op1_word
, NE
, unsignedp
, word_mode
,
699 NULL_RTX
, NULL
, if_false_label
,
703 if (!drop_through_if_false
)
704 emit_jump (if_false_label
);
705 if (drop_through_label
)
706 emit_label (drop_through_label
);
709 /* Given a comparison expression EXP for values too wide to be compared
710 with one insn, test the comparison and jump to the appropriate label.
711 The code of EXP is ignored; we always test GT if SWAP is 0,
712 and LT if SWAP is 1. MODE is the mode of the two operands. */
715 do_jump_by_parts_greater (scalar_int_mode mode
, tree treeop0
, tree treeop1
,
716 int swap
, rtx_code_label
*if_false_label
,
717 rtx_code_label
*if_true_label
,
718 profile_probability prob
)
720 rtx op0
= expand_normal (swap
? treeop1
: treeop0
);
721 rtx op1
= expand_normal (swap
? treeop0
: treeop1
);
722 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (treeop0
));
724 do_jump_by_parts_greater_rtx (mode
, unsignedp
, op0
, op1
, if_false_label
,
725 if_true_label
, prob
);
728 /* Jump according to whether OP0 is 0. We assume that OP0 has an integer
729 mode, MODE, that is too wide for the available compare insns. Either
730 Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL
731 to indicate drop through. */
734 do_jump_by_parts_zero_rtx (scalar_int_mode mode
, rtx op0
,
735 rtx_code_label
*if_false_label
,
736 rtx_code_label
*if_true_label
,
737 profile_probability prob
)
739 int nwords
= GET_MODE_SIZE (mode
) / UNITS_PER_WORD
;
742 rtx_code_label
*drop_through_label
= NULL
;
744 /* The fastest way of doing this comparison on almost any machine is to
745 "or" all the words and compare the result. If all have to be loaded
746 from memory and this is a very wide item, it's possible this may
747 be slower, but that's highly unlikely. */
749 part
= gen_reg_rtx (word_mode
);
750 emit_move_insn (part
, operand_subword_force (op0
, 0, mode
));
751 for (i
= 1; i
< nwords
&& part
!= 0; i
++)
752 part
= expand_binop (word_mode
, ior_optab
, part
,
753 operand_subword_force (op0
, i
, mode
),
754 part
, 1, OPTAB_WIDEN
);
758 do_compare_rtx_and_jump (part
, const0_rtx
, EQ
, 1, word_mode
,
759 NULL_RTX
, if_false_label
, if_true_label
, prob
);
763 /* If we couldn't do the "or" simply, do this with a series of compares. */
764 if (! if_false_label
)
765 if_false_label
= drop_through_label
= gen_label_rtx ();
767 for (i
= 0; i
< nwords
; i
++)
768 do_compare_rtx_and_jump (operand_subword_force (op0
, i
, mode
),
769 const0_rtx
, EQ
, 1, word_mode
, NULL_RTX
,
770 if_false_label
, NULL
, prob
);
773 emit_jump (if_true_label
);
775 if (drop_through_label
)
776 emit_label (drop_through_label
);
779 /* Test for the equality of two RTX expressions OP0 and OP1 in mode MODE,
780 where MODE is an integer mode too wide to be compared with one insn.
781 Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL_RTX
782 to indicate drop through. */
785 do_jump_by_parts_equality_rtx (scalar_int_mode mode
, rtx op0
, rtx op1
,
786 rtx_code_label
*if_false_label
,
787 rtx_code_label
*if_true_label
,
788 profile_probability prob
)
790 int nwords
= (GET_MODE_SIZE (mode
) / UNITS_PER_WORD
);
791 rtx_code_label
*drop_through_label
= NULL
;
794 if (op1
== const0_rtx
)
796 do_jump_by_parts_zero_rtx (mode
, op0
, if_false_label
, if_true_label
,
800 else if (op0
== const0_rtx
)
802 do_jump_by_parts_zero_rtx (mode
, op1
, if_false_label
, if_true_label
,
807 if (! if_false_label
)
808 drop_through_label
= if_false_label
= gen_label_rtx ();
810 for (i
= 0; i
< nwords
; i
++)
811 do_compare_rtx_and_jump (operand_subword_force (op0
, i
, mode
),
812 operand_subword_force (op1
, i
, mode
),
813 EQ
, 0, word_mode
, NULL_RTX
,
814 if_false_label
, NULL
, prob
);
817 emit_jump (if_true_label
);
818 if (drop_through_label
)
819 emit_label (drop_through_label
);
822 /* Given an EQ_EXPR expression EXP for values too wide to be compared
823 with one insn, test the comparison and jump to the appropriate label.
824 MODE is the mode of the two operands. */
827 do_jump_by_parts_equality (scalar_int_mode mode
, tree treeop0
, tree treeop1
,
828 rtx_code_label
*if_false_label
,
829 rtx_code_label
*if_true_label
,
830 profile_probability prob
)
832 rtx op0
= expand_normal (treeop0
);
833 rtx op1
= expand_normal (treeop1
);
834 do_jump_by_parts_equality_rtx (mode
, op0
, op1
, if_false_label
,
835 if_true_label
, prob
);
838 /* Split a comparison into two others, the second of which has the other
839 "orderedness". The first is always ORDERED or UNORDERED if MODE
840 does not honor NaNs (which means that it can be skipped in that case;
841 see do_compare_rtx_and_jump).
843 The two conditions are written in *CODE1 and *CODE2. Return true if
844 the conditions must be ANDed, false if they must be ORed. */
847 split_comparison (enum rtx_code code
, machine_mode mode
,
848 enum rtx_code
*code1
, enum rtx_code
*code2
)
897 /* Do not turn a trapping comparison into a non-trapping one. */
898 if (HONOR_NANS (mode
))
915 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.
916 PROB is probability of jump to LABEL. */
919 jumpif (tree exp
, rtx_code_label
*label
, profile_probability prob
)
921 do_jump (exp
, NULL
, label
, prob
);
924 /* Similar to jumpif but dealing with exploded comparisons of the type
925 OP0 CODE OP1 . LABEL and PROB are like in jumpif. */
928 jumpif_1 (enum tree_code code
, tree op0
, tree op1
, rtx_code_label
*label
,
929 profile_probability prob
)
931 do_jump_1 (code
, op0
, op1
, NULL
, label
, prob
);
934 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.
935 PROB is probability of jump to LABEL. */
938 jumpifnot (tree exp
, rtx_code_label
*label
, profile_probability prob
)
940 do_jump (exp
, label
, NULL
, prob
.invert ());
943 /* Similar to jumpifnot but dealing with exploded comparisons of the type
944 OP0 CODE OP1 . LABEL and PROB are like in jumpifnot. */
947 jumpifnot_1 (enum tree_code code
, tree op0
, tree op1
, rtx_code_label
*label
,
948 profile_probability prob
)
950 do_jump_1 (code
, op0
, op1
, label
, NULL
, prob
.invert ());
953 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
954 The decision as to signed or unsigned comparison must be made by the caller.
956 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
960 do_compare_rtx_and_jump (rtx op0
, rtx op1
, enum rtx_code code
, int unsignedp
,
961 machine_mode mode
, rtx size
,
962 rtx_code_label
*if_false_label
,
963 rtx_code_label
*if_true_label
,
964 profile_probability prob
)
967 rtx_code_label
*dummy_label
= NULL
;
969 /* Reverse the comparison if that is safe and we want to jump if it is
970 false. Also convert to the reverse comparison if the target can
973 || ! can_compare_p (code
, mode
, ccp_jump
))
974 && (! FLOAT_MODE_P (mode
)
975 || code
== ORDERED
|| code
== UNORDERED
976 || (! HONOR_NANS (mode
) && (code
== LTGT
|| code
== UNEQ
))
977 || (! HONOR_SNANS (mode
) && (code
== EQ
|| code
== NE
))))
980 if (FLOAT_MODE_P (mode
))
981 rcode
= reverse_condition_maybe_unordered (code
);
983 rcode
= reverse_condition (code
);
985 /* Canonicalize to UNORDERED for the libcall. */
986 if (can_compare_p (rcode
, mode
, ccp_jump
)
987 || (code
== ORDERED
&& ! can_compare_p (ORDERED
, mode
, ccp_jump
)))
989 std::swap (if_true_label
, if_false_label
);
991 prob
= prob
.invert ();
995 /* If one operand is constant, make it the second one. Only do this
996 if the other operand is not constant as well. */
998 if (swap_commutative_operands_p (op0
, op1
))
1000 std::swap (op0
, op1
);
1001 code
= swap_condition (code
);
1004 do_pending_stack_adjust ();
1006 code
= unsignedp
? unsigned_condition (code
) : code
;
1007 if ((tem
= simplify_relational_operation (code
, mode
, VOIDmode
,
1010 if (CONSTANT_P (tem
))
1012 rtx_code_label
*label
= (tem
== const0_rtx
1013 || tem
== CONST0_RTX (mode
))
1014 ? if_false_label
: if_true_label
;
1020 code
= GET_CODE (tem
);
1021 mode
= GET_MODE (tem
);
1022 op0
= XEXP (tem
, 0);
1023 op1
= XEXP (tem
, 1);
1024 unsignedp
= (code
== GTU
|| code
== LTU
|| code
== GEU
|| code
== LEU
);
1027 if (! if_true_label
)
1028 dummy_label
= if_true_label
= gen_label_rtx ();
1030 scalar_int_mode int_mode
;
1031 if (is_int_mode (mode
, &int_mode
)
1032 && ! can_compare_p (code
, int_mode
, ccp_jump
))
1037 do_jump_by_parts_greater_rtx (int_mode
, 1, op1
, op0
,
1038 if_false_label
, if_true_label
, prob
);
1042 do_jump_by_parts_greater_rtx (int_mode
, 1, op0
, op1
,
1043 if_true_label
, if_false_label
,
1048 do_jump_by_parts_greater_rtx (int_mode
, 1, op0
, op1
,
1049 if_false_label
, if_true_label
, prob
);
1053 do_jump_by_parts_greater_rtx (int_mode
, 1, op1
, op0
,
1054 if_true_label
, if_false_label
,
1059 do_jump_by_parts_greater_rtx (int_mode
, 0, op1
, op0
,
1060 if_false_label
, if_true_label
, prob
);
1064 do_jump_by_parts_greater_rtx (int_mode
, 0, op0
, op1
,
1065 if_true_label
, if_false_label
,
1070 do_jump_by_parts_greater_rtx (int_mode
, 0, op0
, op1
,
1071 if_false_label
, if_true_label
, prob
);
1075 do_jump_by_parts_greater_rtx (int_mode
, 0, op1
, op0
,
1076 if_true_label
, if_false_label
,
1081 do_jump_by_parts_equality_rtx (int_mode
, op0
, op1
, if_false_label
,
1082 if_true_label
, prob
);
1086 do_jump_by_parts_equality_rtx (int_mode
, op0
, op1
, if_true_label
,
1097 if (SCALAR_FLOAT_MODE_P (mode
)
1098 && ! can_compare_p (code
, mode
, ccp_jump
)
1099 && can_compare_p (swap_condition (code
), mode
, ccp_jump
))
1101 code
= swap_condition (code
);
1102 std::swap (op0
, op1
);
1104 else if (SCALAR_FLOAT_MODE_P (mode
)
1105 && ! can_compare_p (code
, mode
, ccp_jump
)
1106 /* Never split ORDERED and UNORDERED.
1107 These must be implemented. */
1108 && (code
!= ORDERED
&& code
!= UNORDERED
)
1109 /* Split a floating-point comparison if
1110 we can jump on other conditions... */
1111 && (have_insn_for (COMPARE
, mode
)
1112 /* ... or if there is no libcall for it. */
1113 || code_to_optab (code
) == unknown_optab
))
1115 enum rtx_code first_code
, orig_code
= code
;
1116 bool and_them
= split_comparison (code
, mode
, &first_code
, &code
);
1118 /* If there are no NaNs, the first comparison should always fall
1120 if (!HONOR_NANS (mode
))
1121 gcc_assert (first_code
== (and_them
? ORDERED
: UNORDERED
));
1123 else if ((orig_code
== EQ
|| orig_code
== NE
)
1124 && rtx_equal_p (op0
, op1
))
1125 /* Self-comparisons x == x or x != x can be optimized into
1126 just x ord x or x nord x. */
1127 code
= orig_code
== EQ
? ORDERED
: UNORDERED
;
1131 profile_probability cprob
1132 = profile_probability::guessed_always ();
1133 if (first_code
== UNORDERED
)
1134 cprob
= cprob
.apply_scale (1, 100);
1135 else if (first_code
== ORDERED
)
1136 cprob
= cprob
.apply_scale (99, 100);
1138 cprob
= profile_probability::even ();
1139 /* For and_them we want to split:
1140 if (x) goto t; // prob;
1143 if (a) ; else goto f; // first_prob for ;
1144 // 1 - first_prob for goto f;
1145 if (b) goto t; // adjusted prob;
1147 such that the overall probability of jumping to t
1148 remains the same. The and_them case should be
1149 probability-wise equivalent to the !and_them case with
1150 f and t swapped and also the conditions inverted, i.e.
1154 where the overall probability of jumping to f is
1155 1 - prob (thus the first prob.invert () below).
1156 cprob.invert () is because the a condition is inverted,
1157 so if it was originally ORDERED, !a is UNORDERED and
1158 thus should be relative 1% rather than 99%.
1159 The invert () on assignment to first_prob is because
1160 first_prob represents the probability of fallthru,
1161 rather than goto f. And the last prob.invert () is
1162 because the adjusted prob represents the probability of
1163 jumping to t rather than to f. */
1166 rtx_code_label
*dest_label
;
1167 prob
= prob
.invert ();
1168 profile_probability first_prob
1169 = prob
.split (cprob
.invert ()).invert ();
1170 prob
= prob
.invert ();
1171 /* If we only jump if true, just bypass the second jump. */
1172 if (! if_false_label
)
1175 dummy_label
= gen_label_rtx ();
1176 dest_label
= dummy_label
;
1179 dest_label
= if_false_label
;
1180 do_compare_rtx_and_jump (op0
, op1
, first_code
, unsignedp
, mode
,
1181 size
, dest_label
, NULL
, first_prob
);
1183 /* For !and_them we want to split:
1184 if (x) goto t; // prob;
1187 if (a) goto t; // first_prob;
1188 if (b) goto t; // adjusted prob;
1190 such that the overall probability of jumping to t
1191 remains the same and first_prob is prob * cprob. */
1194 profile_probability first_prob
= prob
.split (cprob
);
1195 do_compare_rtx_and_jump (op0
, op1
, first_code
, unsignedp
, mode
,
1196 size
, NULL
, if_true_label
, first_prob
);
1197 if (orig_code
== NE
&& can_compare_p (UNEQ
, mode
, ccp_jump
))
1199 /* x != y can be split into x unord y || x ltgt y
1200 or x unord y || !(x uneq y). The latter has the
1201 advantage that both comparisons are non-signalling and
1202 so there is a higher chance that the RTL optimizations
1203 merge the two comparisons into just one. */
1205 prob
= prob
.invert ();
1206 if (! if_false_label
)
1209 dummy_label
= gen_label_rtx ();
1210 if_false_label
= dummy_label
;
1212 std::swap (if_false_label
, if_true_label
);
1218 emit_cmp_and_jump_insns (op0
, op1
, code
, size
, mode
, unsignedp
,
1219 if_true_label
, prob
);
1223 emit_jump (if_false_label
);
1225 emit_label (dummy_label
);
1228 /* Generate code for a comparison expression EXP (including code to compute
1229 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
1230 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
1231 generated code will drop through.
1232 SIGNED_CODE should be the rtx operation for this comparison for
1233 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
1235 We force a stack adjustment unless there are currently
1236 things pushed on the stack that aren't yet used. */
1239 do_compare_and_jump (tree treeop0
, tree treeop1
, enum rtx_code signed_code
,
1240 enum rtx_code unsigned_code
,
1241 rtx_code_label
*if_false_label
,
1242 rtx_code_label
*if_true_label
, profile_probability prob
)
1250 /* Don't crash if the comparison was erroneous. */
1251 op0
= expand_normal (treeop0
);
1252 if (TREE_CODE (treeop0
) == ERROR_MARK
)
1255 op1
= expand_normal (treeop1
);
1256 if (TREE_CODE (treeop1
) == ERROR_MARK
)
1259 type
= TREE_TYPE (treeop0
);
1260 if (TREE_CODE (treeop0
) == INTEGER_CST
1261 && (TREE_CODE (treeop1
) != INTEGER_CST
1262 || (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type
))
1263 > GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (treeop1
))))))
1264 /* op0 might have been replaced by promoted constant, in which
1265 case the type of second argument should be used. */
1266 type
= TREE_TYPE (treeop1
);
1267 mode
= TYPE_MODE (type
);
1268 unsignedp
= TYPE_UNSIGNED (type
);
1269 code
= unsignedp
? unsigned_code
: signed_code
;
1271 /* If function pointers need to be "canonicalized" before they can
1272 be reliably compared, then canonicalize them. Canonicalize the
1273 expression when one of the operands is a function pointer. This
1274 handles the case where the other operand is a void pointer. See
1275 PR middle-end/17564. */
1276 if (targetm
.have_canonicalize_funcptr_for_compare ()
1277 && ((POINTER_TYPE_P (TREE_TYPE (treeop0
))
1278 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (treeop0
))))
1279 || (POINTER_TYPE_P (TREE_TYPE (treeop1
))
1280 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (treeop1
))))))
1282 rtx new_op0
= gen_reg_rtx (mode
);
1283 rtx new_op1
= gen_reg_rtx (mode
);
1285 emit_insn (targetm
.gen_canonicalize_funcptr_for_compare (new_op0
, op0
));
1288 emit_insn (targetm
.gen_canonicalize_funcptr_for_compare (new_op1
, op1
));
1292 do_compare_rtx_and_jump (op0
, op1
, code
, unsignedp
, mode
,
1294 ? expr_size (treeop0
) : NULL_RTX
),
1295 if_false_label
, if_true_label
, prob
);
1298 #include "gt-dojump.h"