1/* Convert tree expression to rtl instructions, for GNU compiler.
2 Copyright (C) 1988-2025 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "backend.h"
24#include "target.h"
25#include "rtl.h"
26#include "tree.h"
27#include "predict.h"
28#include "memmodel.h"
29#include "tm_p.h"
30#include "optabs.h"
31#include "emit-rtl.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. */
35#include "dojump.h"
36#include "explow.h"
37#include "expr.h"
38#include "langhooks.h"
39
40static bool prefer_and_bit_test (scalar_int_mode, int);
41static void do_jump (tree, rtx_code_label *, rtx_code_label *,
42 profile_probability);
43static void do_jump_by_parts_greater (scalar_int_mode, tree, tree, int,
44 rtx_code_label *, rtx_code_label *,
45 profile_probability);
46static void do_jump_by_parts_equality (scalar_int_mode, tree, tree,
47 rtx_code_label *, rtx_code_label *,
48 profile_probability);
49static void do_compare_and_jump (tree, tree, enum rtx_code, enum rtx_code,
50 rtx_code_label *, rtx_code_label *,
51 profile_probability);
52
53/* At the start of a function, record that we have no previously-pushed
54 arguments waiting to be popped. */
55
56void
57init_pending_stack_adjust (void)
58{
59 pending_stack_adjust = 0;
60}
61
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. */
65void
66discard_pending_stack_adjust (void)
67{
68 stack_pointer_delta -= pending_stack_adjust;
69 pending_stack_adjust = 0;
70}
71
72/* When exiting from function, if safe, clear out any pending stack adjust
73 so the adjustment won't get done.
74
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. */
77
78void
79clear_pending_stack_adjust (void)
80{
81 if (optimize > 0
82 && (! flag_omit_frame_pointer || cfun->calls_alloca)
83 && EXIT_IGNORE_STACK)
84 discard_pending_stack_adjust ();
85}
86
87/* Pop any previously-pushed arguments that have not been popped yet. */
88
89void
90do_pending_stack_adjust (void)
91{
92 if (inhibit_defer_pop == 0)
93 {
94 if (maybe_ne (pending_stack_adjust, b: 0))
95 adjust_stack (gen_int_mode (pending_stack_adjust, Pmode));
96 pending_stack_adjust = 0;
97 }
98}
99
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. */
103
104void
105save_pending_stack_adjust (saved_pending_stack_adjust *save)
106{
107 save->x_pending_stack_adjust = pending_stack_adjust;
108 save->x_stack_pointer_delta = stack_pointer_delta;
109}
110
111/* Restore the saved pending_stack_adjust/stack_pointer_delta. */
112
113void
114restore_pending_stack_adjust (saved_pending_stack_adjust *save)
115{
116 if (inhibit_defer_pop == 0)
117 {
118 pending_stack_adjust = save->x_pending_stack_adjust;
119 stack_pointer_delta = save->x_stack_pointer_delta;
120 }
121}
122
123/* Used internally by prefer_and_bit_test. */
124
125static GTY(()) rtx and_reg;
126static GTY(()) rtx and_test;
127static GTY(()) rtx shift_test;
128
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
131 is preferred. */
132
133static bool
134prefer_and_bit_test (scalar_int_mode mode, int bitnum)
135{
136 bool speed_p;
137 wide_int mask = wi::set_bit_in_zero (bit: bitnum, precision: GET_MODE_PRECISION (mode));
138
139 if (and_test == 0)
140 {
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),
146 const1_rtx);
147 }
148 else
149 {
150 /* Change the mode of the previously-created rtxes. */
151 PUT_MODE (x: and_reg, mode);
152 PUT_MODE (x: and_test, mode);
153 PUT_MODE (x: shift_test, mode);
154 PUT_MODE (XEXP (shift_test, 0), mode);
155 }
156
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);
160
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));
164}
165
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. */
169
170static void
171do_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)
174{
175 machine_mode mode;
176 rtx_code_label *drop_through_label = 0;
177 scalar_int_mode int_mode;
178
179 switch (code)
180 {
181 case EQ_EXPR:
182 {
183 tree inner_type = TREE_TYPE (op0);
184
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);
189
190 if (integer_zerop (op1))
191 do_jump (op0, if_true_label, if_false_label,
192 prob.invert ());
193 else if (is_int_mode (TYPE_MODE (inner_type), int_mode: &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);
197 else
198 do_compare_and_jump (op0, op1, EQ, EQ, if_false_label, if_true_label,
199 prob);
200 break;
201 }
202
203 case NE_EXPR:
204 {
205 tree inner_type = TREE_TYPE (op0);
206
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);
211
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: &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 ());
218 else
219 do_compare_and_jump (op0, op1, NE, NE, if_false_label, if_true_label,
220 prob);
221 break;
222 }
223
224 case LT_EXPR:
225 mode = TYPE_MODE (TREE_TYPE (op0));
226 if (is_int_mode (mode, int_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);
230 else
231 do_compare_and_jump (op0, op1, LT, LTU, if_false_label, if_true_label,
232 prob);
233 break;
234
235 case LE_EXPR:
236 mode = TYPE_MODE (TREE_TYPE (op0));
237 if (is_int_mode (mode, int_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 ());
241 else
242 do_compare_and_jump (op0, op1, LE, LEU, if_false_label, if_true_label,
243 prob);
244 break;
245
246 case GT_EXPR:
247 mode = TYPE_MODE (TREE_TYPE (op0));
248 if (is_int_mode (mode, int_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);
252 else
253 do_compare_and_jump (op0, op1, GT, GTU, if_false_label, if_true_label,
254 prob);
255 break;
256
257 case GE_EXPR:
258 mode = TYPE_MODE (TREE_TYPE (op0));
259 if (is_int_mode (mode, int_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 ());
263 else
264 do_compare_and_jump (op0, op1, GE, GEU, if_false_label, if_true_label,
265 prob);
266 break;
267
268 case ORDERED_EXPR:
269 do_compare_and_jump (op0, op1, ORDERED, ORDERED,
270 if_false_label, if_true_label, prob);
271 break;
272
273 case UNORDERED_EXPR:
274 do_compare_and_jump (op0, op1, UNORDERED, UNORDERED,
275 if_false_label, if_true_label, prob);
276 break;
277
278 case UNLT_EXPR:
279 do_compare_and_jump (op0, op1, UNLT, UNLT, if_false_label, if_true_label,
280 prob);
281 break;
282
283 case UNLE_EXPR:
284 do_compare_and_jump (op0, op1, UNLE, UNLE, if_false_label, if_true_label,
285 prob);
286 break;
287
288 case UNGT_EXPR:
289 do_compare_and_jump (op0, op1, UNGT, UNGT, if_false_label, if_true_label,
290 prob);
291 break;
292
293 case UNGE_EXPR:
294 do_compare_and_jump (op0, op1, UNGE, UNGE, if_false_label, if_true_label,
295 prob);
296 break;
297
298 case UNEQ_EXPR:
299 do_compare_and_jump (op0, op1, UNEQ, UNEQ, if_false_label, if_true_label,
300 prob);
301 break;
302
303 case LTGT_EXPR:
304 do_compare_and_jump (op0, op1, LTGT, LTGT, if_false_label, if_true_label,
305 prob);
306 break;
307
308 case TRUTH_ANDIF_EXPR:
309 {
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 ())
319 {
320 op1_prob = prob.invert ();
321 op0_prob = op1_prob.split (cprob: 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 ();
325 }
326 if (if_false_label == NULL)
327 {
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);
331 }
332 else
333 {
334 do_jump (op0, if_false_label, NULL, op0_prob);
335 do_jump (op1, if_false_label, if_true_label, op1_prob);
336 }
337 break;
338 }
339
340 case TRUTH_ORIF_EXPR:
341 {
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 ())
350 {
351 op1_prob = prob;
352 op0_prob = op1_prob.split (cprob: profile_probability::even ());
353 }
354 if (if_true_label == NULL)
355 {
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);
359 }
360 else
361 {
362 do_jump (op0, NULL, if_true_label, op0_prob);
363 do_jump (op1, if_false_label, if_true_label, op1_prob);
364 }
365 break;
366 }
367
368 default:
369 gcc_unreachable ();
370 }
371
372 if (drop_through_label)
373 {
374 do_pending_stack_adjust ();
375 emit_label (drop_through_label);
376 }
377}
378
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.
383
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.
387
388 PROB is probability of jump to if_true_label. */
389
390static void
391do_jump (tree exp, rtx_code_label *if_false_label,
392 rtx_code_label *if_true_label, profile_probability prob)
393{
394 enum tree_code code = TREE_CODE (exp);
395 rtx temp;
396 int i;
397 tree type;
398 scalar_int_mode mode;
399 rtx_code_label *drop_through_label = NULL;
400
401 switch (code)
402 {
403 case ERROR_MARK:
404 break;
405
406 case INTEGER_CST:
407 {
408 rtx_code_label *lab = integer_zerop (exp) ? if_false_label
409 : if_true_label;
410 if (lab)
411 emit_jump (lab);
412 break;
413 }
414
415#if 0
416 /* This is not true with #pragma weak */
417 case ADDR_EXPR:
418 /* The address of something can never be zero. */
419 if (if_true_label)
420 emit_jump (if_true_label);
421 break;
422#endif
423
424 CASE_CONVERT:
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)
429 goto normal;
430 /* If we are narrowing the operand, we have to do the compare in the
431 narrower mode. */
432 if ((TYPE_PRECISION (TREE_TYPE (exp))
433 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
434 goto normal;
435 /* FALLTHRU */
436 case NON_LVALUE_EXPR:
437 case ABS_EXPR:
438 case ABSU_EXPR:
439 case NEGATE_EXPR:
440 case LROTATE_EXPR:
441 case RROTATE_EXPR:
442 /* These cannot change zero->nonzero or vice versa. */
443 do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label, prob);
444 break;
445
446 case TRUTH_NOT_EXPR:
447 do_jump (TREE_OPERAND (exp, 0), if_false_label: if_true_label, if_true_label: if_false_label,
448 prob: prob.invert ());
449 break;
450
451 case COND_EXPR:
452 {
453 rtx_code_label *label1 = gen_label_rtx ();
454 if (!if_true_label || !if_false_label)
455 {
456 drop_through_label = gen_label_rtx ();
457 if (!if_true_label)
458 if_true_label = drop_through_label;
459 if (!if_false_label)
460 if_false_label = drop_through_label;
461 }
462
463 do_pending_stack_adjust ();
464 do_jump (TREE_OPERAND (exp, 0), if_false_label: label1, NULL,
465 prob: profile_probability::uninitialized ());
466 do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label, prob);
467 emit_label (label1);
468 do_jump (TREE_OPERAND (exp, 2), if_false_label, if_true_label, prob);
469 break;
470 }
471
472 case COMPOUND_EXPR:
473 /* Lowered by gimplify.cc. */
474 gcc_unreachable ();
475
476 case MINUS_EXPR:
477 /* Nonzero iff operands of minus differ. */
478 code = NE_EXPR;
479
480 /* FALLTHRU */
481 case EQ_EXPR:
482 case NE_EXPR:
483 case LT_EXPR:
484 case LE_EXPR:
485 case GT_EXPR:
486 case GE_EXPR:
487 case ORDERED_EXPR:
488 case UNORDERED_EXPR:
489 case UNLT_EXPR:
490 case UNLE_EXPR:
491 case UNGT_EXPR:
492 case UNGE_EXPR:
493 case UNEQ_EXPR:
494 case LTGT_EXPR:
495 case TRUTH_ANDIF_EXPR:
496 case TRUTH_ORIF_EXPR:
497 other_code:
498 do_jump_1 (code, TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
499 if_false_label, if_true_label, prob);
500 break;
501
502 case BIT_AND_EXPR:
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
505 if so. */
506 if (integer_onep (TREE_OPERAND (exp, 1)))
507 {
508 tree exp0 = TREE_OPERAND (exp, 0);
509 rtx_code_label *set_label, *clr_label;
510 profile_probability setclr_prob = prob;
511
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);
518
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)))
522 {
523 exp0 = TREE_OPERAND (exp0, 0);
524 clr_label = if_true_label;
525 set_label = if_false_label;
526 setclr_prob = prob.invert ();
527 }
528 else
529 {
530 clr_label = if_false_label;
531 set_label = if_true_label;
532 }
533
534 if (TREE_CODE (exp0) == RSHIFT_EXPR)
535 {
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)))
544 {
545 unsigned HOST_WIDE_INT mask
546 = HOST_WIDE_INT_1U << TREE_INT_CST_LOW (shift);
547 do_jump (exp: build2 (BIT_AND_EXPR, argtype, arg,
548 build_int_cstu (type: argtype, mask)),
549 if_false_label: clr_label, if_true_label: set_label, prob: setclr_prob);
550 break;
551 }
552 }
553 }
554
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. */
561
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 (size: i + 1, limit: 0).exists (mode: &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)))
570 {
571 do_jump (fold_convert (type, exp), if_false_label, if_true_label,
572 prob);
573 break;
574 }
575
576 if (TYPE_PRECISION (TREE_TYPE (exp)) > 1
577 || TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
578 goto normal;
579
580 /* Boolean comparisons can be compiled as TRUTH_AND_EXPR. */
581 /* FALLTHRU */
582
583 case 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 (),
588 false) >= 4
589 || TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
590 goto normal;
591 code = TRUTH_ANDIF_EXPR;
592 goto other_code;
593
594 case BIT_IOR_EXPR:
595 case TRUTH_OR_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)))
601 goto normal;
602 code = TRUTH_ORIF_EXPR;
603 goto other_code;
604
605 /* Fall through and generate the normal code. */
606 default:
607 normal:
608 temp = expand_normal (exp);
609 do_pending_stack_adjust ();
610 /* The RTL optimizers prefer comparisons against pseudos. */
611 if (GET_CODE (temp) == SUBREG)
612 {
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);
617 else
618 temp = copy_to_reg (temp);
619 }
620 do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
621 NE, TYPE_UNSIGNED (TREE_TYPE (exp)),
622 exp, GET_MODE (temp), NULL_RTX,
623 if_false_label, if_true_label, prob);
624 }
625
626 if (drop_through_label)
627 {
628 do_pending_stack_adjust ();
629 emit_label (drop_through_label);
630 }
631}
632
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. */
636
637static void
638do_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)
642{
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;
647 int i;
648
649 if (! if_true_label || ! if_false_label)
650 drop_through_label = gen_label_rtx ();
651 if (! if_true_label)
652 {
653 if_true_label = drop_through_label;
654 drop_through_if_true = true;
655 }
656 if (! if_false_label)
657 {
658 if_false_label = drop_through_label;
659 drop_through_if_false = true;
660 }
661
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)
665 {
666 code = LE;
667 if_true_label = if_false_label;
668 if_false_label = drop_through_label;
669 prob = prob.invert ();
670 }
671
672 /* Compare a word at a time, high order first. */
673 for (i = 0; i < nwords; i++)
674 {
675 rtx op0_word, op1_word;
676
677 if (WORDS_BIG_ENDIAN)
678 {
679 op0_word = operand_subword_force (op0, i, mode);
680 op1_word = operand_subword_force (op1, i, mode);
681 }
682 else
683 {
684 op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
685 op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
686 }
687
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 NULL, word_mode, NULL_RTX, NULL, if_true_label,
691 prob);
692
693 /* Emit only one comparison for 0. Do not emit the last cond jump. */
694 if (op0 == const0_rtx || i == nwords - 1)
695 break;
696
697 /* Consider lower words only if these are equal. */
698 do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, NULL,
699 word_mode, NULL_RTX, NULL, if_false_label,
700 prob.invert ());
701 }
702
703 if (!drop_through_if_false)
704 emit_jump (if_false_label);
705 if (drop_through_label)
706 emit_label (drop_through_label);
707}
708
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. */
713
714static void
715do_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)
719{
720 rtx op0 = expand_normal (exp: swap ? treeop1 : treeop0);
721 rtx op1 = expand_normal (exp: swap ? treeop0 : treeop1);
722 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (treeop0));
723
724 do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label,
725 if_true_label, prob);
726}
727
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. */
732
733static void
734do_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)
738{
739 int nwords = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
740 rtx part;
741 int i;
742 rtx_code_label *drop_through_label = NULL;
743
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. */
748
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);
755
756 if (part != 0)
757 {
758 do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, NULL, word_mode,
759 NULL_RTX, if_false_label, if_true_label, prob);
760 return;
761 }
762
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 ();
766
767 for (i = 0; i < nwords; i++)
768 do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
769 const0_rtx, EQ, 1, NULL, word_mode, NULL_RTX,
770 if_false_label, NULL, prob);
771
772 if (if_true_label)
773 emit_jump (if_true_label);
774
775 if (drop_through_label)
776 emit_label (drop_through_label);
777}
778
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. */
783
784static void
785do_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)
789{
790 int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
791 rtx_code_label *drop_through_label = NULL;
792 int i;
793
794 if (op1 == const0_rtx)
795 {
796 do_jump_by_parts_zero_rtx (mode, op0, if_false_label, if_true_label,
797 prob);
798 return;
799 }
800 else if (op0 == const0_rtx)
801 {
802 do_jump_by_parts_zero_rtx (mode, op0: op1, if_false_label, if_true_label,
803 prob);
804 return;
805 }
806
807 if (! if_false_label)
808 drop_through_label = if_false_label = gen_label_rtx ();
809
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, NULL, word_mode, NULL_RTX,
814 if_false_label, NULL, prob);
815
816 if (if_true_label)
817 emit_jump (if_true_label);
818 if (drop_through_label)
819 emit_label (drop_through_label);
820}
821
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. */
825
826static void
827do_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)
831{
832 rtx op0 = expand_normal (exp: treeop0);
833 rtx op1 = expand_normal (exp: treeop1);
834 do_jump_by_parts_equality_rtx (mode, op0, op1, if_false_label,
835 if_true_label, prob);
836}
837
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).
842
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. */
845
846bool
847split_comparison (enum rtx_code code, machine_mode mode,
848 enum rtx_code *code1, enum rtx_code *code2)
849{
850 switch (code)
851 {
852 case LT:
853 *code1 = ORDERED;
854 *code2 = UNLT;
855 return true;
856 case LE:
857 *code1 = ORDERED;
858 *code2 = UNLE;
859 return true;
860 case GT:
861 *code1 = ORDERED;
862 *code2 = UNGT;
863 return true;
864 case GE:
865 *code1 = ORDERED;
866 *code2 = UNGE;
867 return true;
868 case EQ:
869 *code1 = ORDERED;
870 *code2 = UNEQ;
871 return true;
872 case NE:
873 *code1 = UNORDERED;
874 *code2 = LTGT;
875 return false;
876 case UNLT:
877 *code1 = UNORDERED;
878 *code2 = LT;
879 return false;
880 case UNLE:
881 *code1 = UNORDERED;
882 *code2 = LE;
883 return false;
884 case UNGT:
885 *code1 = UNORDERED;
886 *code2 = GT;
887 return false;
888 case UNGE:
889 *code1 = UNORDERED;
890 *code2 = GE;
891 return false;
892 case UNEQ:
893 *code1 = UNORDERED;
894 *code2 = EQ;
895 return false;
896 case LTGT:
897 /* Do not turn a trapping comparison into a non-trapping one. */
898 if (HONOR_NANS (mode))
899 {
900 *code1 = LT;
901 *code2 = GT;
902 return false;
903 }
904 else
905 {
906 *code1 = ORDERED;
907 *code2 = NE;
908 return true;
909 }
910 default:
911 gcc_unreachable ();
912 }
913}
914
915/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.
916 PROB is probability of jump to LABEL. */
917
918void
919jumpif (tree exp, rtx_code_label *label, profile_probability prob)
920{
921 do_jump (exp, NULL, if_true_label: label, prob);
922}
923
924/* Similar to jumpif but dealing with exploded comparisons of the type
925 OP0 CODE OP1 . LABEL and PROB are like in jumpif. */
926
927void
928jumpif_1 (enum tree_code code, tree op0, tree op1, rtx_code_label *label,
929 profile_probability prob)
930{
931 do_jump_1 (code, op0, op1, NULL, if_true_label: label, prob);
932}
933
934/* Generate code to evaluate EXP and jump to LABEL if the value is zero.
935 PROB is probability of jump to LABEL. */
936
937void
938jumpifnot (tree exp, rtx_code_label *label, profile_probability prob)
939{
940 do_jump (exp, if_false_label: label, NULL, prob: prob.invert ());
941}
942
943/* Similar to jumpifnot but dealing with exploded comparisons of the type
944 OP0 CODE OP1 . LABEL and PROB are like in jumpifnot. */
945
946void
947jumpifnot_1 (enum tree_code code, tree op0, tree op1, rtx_code_label *label,
948 profile_probability prob)
949{
950 do_jump_1 (code, op0, op1, if_false_label: label, NULL, prob: prob.invert ());
951}
952
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.
955
956 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
957 compared. */
958
959void
960do_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)
965{
966 do_compare_rtx_and_jump (op0, op1, code, unsignedp, NULL, mode, size,
967 if_false_label, if_true_label, prob);
968}
969
970/* Like do_compare_and_jump but expects the values to compare as two rtx's.
971 The decision as to signed or unsigned comparison must be made by the caller.
972
973 If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
974 compared. */
975
976void
977do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
978 tree val, machine_mode mode, rtx size,
979 rtx_code_label *if_false_label,
980 rtx_code_label *if_true_label,
981 profile_probability prob)
982{
983 rtx tem;
984 rtx_code_label *dummy_label = NULL;
985
986 /* Reverse the comparison if that is safe and we want to jump if it is
987 false. Also convert to the reverse comparison if the target can
988 implement it. */
989 if ((! if_true_label
990 || ! can_compare_p (code, mode, ccp_jump))
991 && (! FLOAT_MODE_P (mode)
992 || code == ORDERED || code == UNORDERED
993 || (! HONOR_NANS (mode) && (code == LTGT || code == UNEQ))
994 || (! HONOR_SNANS (mode) && (code == EQ || code == NE))))
995 {
996 enum rtx_code rcode;
997 if (FLOAT_MODE_P (mode))
998 rcode = reverse_condition_maybe_unordered (code);
999 else
1000 rcode = reverse_condition (code);
1001
1002 /* Canonicalize to UNORDERED for the libcall. */
1003 if (can_compare_p (rcode, mode, ccp_jump)
1004 || (code == ORDERED && ! can_compare_p (ORDERED, mode, ccp_jump)))
1005 {
1006 std::swap (a&: if_true_label, b&: if_false_label);
1007 code = rcode;
1008 prob = prob.invert ();
1009 }
1010 }
1011
1012 /* If one operand is constant, make it the second one. Only do this
1013 if the other operand is not constant as well. */
1014
1015 if (swap_commutative_operands_p (op0, op1))
1016 {
1017 std::swap (a&: op0, b&: op1);
1018 code = swap_condition (code);
1019 }
1020
1021 do_pending_stack_adjust ();
1022
1023 code = unsignedp ? unsigned_condition (code) : code;
1024 if ((tem = simplify_relational_operation (code, mode, VOIDmode,
1025 op0, op1)) != 0)
1026 {
1027 if (CONSTANT_P (tem))
1028 {
1029 rtx_code_label *label = (tem == const0_rtx
1030 || tem == CONST0_RTX (mode))
1031 ? if_false_label : if_true_label;
1032 if (label)
1033 emit_jump (label);
1034 return;
1035 }
1036
1037 code = GET_CODE (tem);
1038 mode = GET_MODE (tem);
1039 op0 = XEXP (tem, 0);
1040 op1 = XEXP (tem, 1);
1041 unsignedp = (code == GTU || code == LTU || code == GEU || code == LEU);
1042 }
1043
1044 if (! if_true_label)
1045 dummy_label = if_true_label = gen_label_rtx ();
1046
1047 scalar_int_mode int_mode;
1048 if (is_int_mode (mode, int_mode: &int_mode)
1049 && ! can_compare_p (code, int_mode, ccp_jump))
1050 {
1051 switch (code)
1052 {
1053 case LTU:
1054 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 1, op0: op1, op1: op0,
1055 if_false_label, if_true_label, prob);
1056 break;
1057
1058 case LEU:
1059 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 1, op0, op1,
1060 if_false_label: if_true_label, if_true_label: if_false_label,
1061 prob: prob.invert ());
1062 break;
1063
1064 case GTU:
1065 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 1, op0, op1,
1066 if_false_label, if_true_label, prob);
1067 break;
1068
1069 case GEU:
1070 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 1, op0: op1, op1: op0,
1071 if_false_label: if_true_label, if_true_label: if_false_label,
1072 prob: prob.invert ());
1073 break;
1074
1075 case LT:
1076 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 0, op0: op1, op1: op0,
1077 if_false_label, if_true_label, prob);
1078 break;
1079
1080 case LE:
1081 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 0, op0, op1,
1082 if_false_label: if_true_label, if_true_label: if_false_label,
1083 prob: prob.invert ());
1084 break;
1085
1086 case GT:
1087 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 0, op0, op1,
1088 if_false_label, if_true_label, prob);
1089 break;
1090
1091 case GE:
1092 do_jump_by_parts_greater_rtx (mode: int_mode, unsignedp: 0, op0: op1, op1: op0,
1093 if_false_label: if_true_label, if_true_label: if_false_label,
1094 prob: prob.invert ());
1095 break;
1096
1097 case EQ:
1098 do_jump_by_parts_equality_rtx (mode: int_mode, op0, op1, if_false_label,
1099 if_true_label, prob);
1100 break;
1101
1102 case NE:
1103 do_jump_by_parts_equality_rtx (mode: int_mode, op0, op1, if_false_label: if_true_label,
1104 if_true_label: if_false_label,
1105 prob: prob.invert ());
1106 break;
1107
1108 default:
1109 gcc_unreachable ();
1110 }
1111 }
1112 else
1113 {
1114 if (SCALAR_FLOAT_MODE_P (mode)
1115 && ! can_compare_p (code, mode, ccp_jump)
1116 && can_compare_p (swap_condition (code), mode, ccp_jump))
1117 {
1118 code = swap_condition (code);
1119 std::swap (a&: op0, b&: op1);
1120 }
1121 else if (SCALAR_FLOAT_MODE_P (mode)
1122 && ! can_compare_p (code, mode, ccp_jump)
1123 /* Never split ORDERED and UNORDERED.
1124 These must be implemented. */
1125 && (code != ORDERED && code != UNORDERED)
1126 /* Split a floating-point comparison if
1127 we can jump on other conditions... */
1128 && (have_insn_for (COMPARE, mode)
1129 /* ... or if there is no libcall for it. */
1130 || code_to_optab (code) == unknown_optab))
1131 {
1132 enum rtx_code first_code, orig_code = code;
1133 bool and_them = split_comparison (code, mode, code1: &first_code, code2: &code);
1134
1135 /* If there are no NaNs, the first comparison should always fall
1136 through. */
1137 if (!HONOR_NANS (mode))
1138 gcc_assert (first_code == (and_them ? ORDERED : UNORDERED));
1139
1140 else if ((orig_code == EQ || orig_code == NE)
1141 && rtx_equal_p (op0, op1))
1142 /* Self-comparisons x == x or x != x can be optimized into
1143 just x ord x or x nord x. */
1144 code = orig_code == EQ ? ORDERED : UNORDERED;
1145
1146 else
1147 {
1148 profile_probability cprob
1149 = profile_probability::guessed_always ();
1150 if (first_code == UNORDERED)
1151 cprob /= 100;
1152 else if (first_code == ORDERED)
1153 cprob = cprob.apply_scale (num: 99, den: 100);
1154 else
1155 cprob = profile_probability::even ();
1156 /* For and_them we want to split:
1157 if (x) goto t; // prob;
1158 goto f;
1159 into
1160 if (a) ; else goto f; // first_prob for ;
1161 // 1 - first_prob for goto f;
1162 if (b) goto t; // adjusted prob;
1163 goto f;
1164 such that the overall probability of jumping to t
1165 remains the same. The and_them case should be
1166 probability-wise equivalent to the !and_them case with
1167 f and t swapped and also the conditions inverted, i.e.
1168 if (!a) goto f;
1169 if (!b) goto f;
1170 goto t;
1171 where the overall probability of jumping to f is
1172 1 - prob (thus the first prob.invert () below).
1173 cprob.invert () is because the a condition is inverted,
1174 so if it was originally ORDERED, !a is UNORDERED and
1175 thus should be relative 1% rather than 99%.
1176 The invert () on assignment to first_prob is because
1177 first_prob represents the probability of fallthru,
1178 rather than goto f. And the last prob.invert () is
1179 because the adjusted prob represents the probability of
1180 jumping to t rather than to f. */
1181 if (and_them)
1182 {
1183 rtx_code_label *dest_label;
1184 prob = prob.invert ();
1185 profile_probability first_prob
1186 = prob.split (cprob: cprob.invert ()).invert ();
1187 prob = prob.invert ();
1188 /* If we only jump if true, just bypass the second jump. */
1189 if (! if_false_label)
1190 {
1191 if (! dummy_label)
1192 dummy_label = gen_label_rtx ();
1193 dest_label = dummy_label;
1194 }
1195 else
1196 dest_label = if_false_label;
1197
1198 do_compare_rtx_and_jump (op0, op1, code: first_code, unsignedp,
1199 val, mode, size, if_false_label: dest_label, NULL,
1200 prob: first_prob);
1201 }
1202 /* For !and_them we want to split:
1203 if (x) goto t; // prob;
1204 goto f;
1205 into
1206 if (a) goto t; // first_prob;
1207 if (b) goto t; // adjusted prob;
1208 goto f;
1209 such that the overall probability of jumping to t
1210 remains the same and first_prob is prob * cprob. */
1211 else
1212 {
1213 profile_probability first_prob = prob.split (cprob);
1214 do_compare_rtx_and_jump (op0, op1, code: first_code, unsignedp,
1215 val, mode, size, NULL,
1216 if_true_label, prob: first_prob);
1217 if (orig_code == NE && can_compare_p (UNEQ, mode, ccp_jump))
1218 {
1219 /* x != y can be split into x unord y || x ltgt y
1220 or x unord y || !(x uneq y). The latter has the
1221 advantage that both comparisons are non-signalling and
1222 so there is a higher chance that the RTL optimizations
1223 merge the two comparisons into just one. */
1224 code = UNEQ;
1225 prob = prob.invert ();
1226 if (! if_false_label)
1227 {
1228 if (! dummy_label)
1229 dummy_label = gen_label_rtx ();
1230 if_false_label = dummy_label;
1231 }
1232 std::swap (a&: if_false_label, b&: if_true_label);
1233 }
1234 }
1235 }
1236 }
1237
1238 /* For boolean vectors with less than mode precision
1239 make sure to fill padding with consistent values. */
1240 if (val
1241 && VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (val))
1242 && SCALAR_INT_MODE_P (mode))
1243 {
1244 auto nunits = TYPE_VECTOR_SUBPARTS (TREE_TYPE (val)).to_constant ();
1245 if (maybe_ne (a: GET_MODE_PRECISION (mode), b: nunits))
1246 {
1247 op0 = expand_binop (mode, and_optab, op0,
1248 GEN_INT ((HOST_WIDE_INT_1U << nunits) - 1),
1249 NULL_RTX, true, OPTAB_WIDEN);
1250 op1 = expand_binop (mode, and_optab, op1,
1251 GEN_INT ((HOST_WIDE_INT_1U << nunits) - 1),
1252 NULL_RTX, true, OPTAB_WIDEN);
1253 }
1254 }
1255
1256 emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp, val,
1257 if_true_label, prob);
1258 }
1259
1260 if (if_false_label)
1261 emit_jump (if_false_label);
1262 if (dummy_label)
1263 emit_label (dummy_label);
1264}
1265
1266/* Generate code for a comparison expression EXP (including code to compute
1267 the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
1268 IF_TRUE_LABEL. One of the labels can be NULL_RTX, in which case the
1269 generated code will drop through.
1270 SIGNED_CODE should be the rtx operation for this comparison for
1271 signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
1272
1273 We force a stack adjustment unless there are currently
1274 things pushed on the stack that aren't yet used. */
1275
1276static void
1277do_compare_and_jump (tree treeop0, tree treeop1, enum rtx_code signed_code,
1278 enum rtx_code unsigned_code,
1279 rtx_code_label *if_false_label,
1280 rtx_code_label *if_true_label, profile_probability prob)
1281{
1282 rtx op0, op1;
1283 tree type;
1284 machine_mode mode;
1285 int unsignedp;
1286 enum rtx_code code;
1287
1288 /* Don't crash if the comparison was erroneous. */
1289 op0 = expand_normal (exp: treeop0);
1290 if (TREE_CODE (treeop0) == ERROR_MARK)
1291 return;
1292
1293 op1 = expand_normal (exp: treeop1);
1294 if (TREE_CODE (treeop1) == ERROR_MARK)
1295 return;
1296
1297 type = TREE_TYPE (treeop0);
1298 if (TREE_CODE (treeop0) == INTEGER_CST
1299 && (TREE_CODE (treeop1) != INTEGER_CST
1300 || (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type))
1301 > GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (treeop1))))))
1302 /* op0 might have been replaced by promoted constant, in which
1303 case the type of second argument should be used. */
1304 type = TREE_TYPE (treeop1);
1305 mode = TYPE_MODE (type);
1306 unsignedp = TYPE_UNSIGNED (type);
1307 code = unsignedp ? unsigned_code : signed_code;
1308
1309 /* If function pointers need to be "canonicalized" before they can
1310 be reliably compared, then canonicalize them. Canonicalize the
1311 expression when one of the operands is a function pointer. This
1312 handles the case where the other operand is a void pointer. See
1313 PR middle-end/17564. */
1314 if (targetm.have_canonicalize_funcptr_for_compare ()
1315 && ((POINTER_TYPE_P (TREE_TYPE (treeop0))
1316 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (treeop0))))
1317 || (POINTER_TYPE_P (TREE_TYPE (treeop1))
1318 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (treeop1))))))
1319 {
1320 rtx new_op0 = gen_reg_rtx (mode);
1321 rtx new_op1 = gen_reg_rtx (mode);
1322
1323 emit_insn (targetm.gen_canonicalize_funcptr_for_compare (new_op0, op0));
1324 op0 = new_op0;
1325
1326 emit_insn (targetm.gen_canonicalize_funcptr_for_compare (new_op1, op1));
1327 op1 = new_op1;
1328 }
1329
1330 do_compare_rtx_and_jump (op0, op1, code, unsignedp, val: treeop0, mode,
1331 size: ((mode == BLKmode)
1332 ? expr_size (treeop0) : NULL_RTX),
1333 if_false_label, if_true_label, prob);
1334}
1335
1336#include "gt-dojump.h"
1337

source code of gcc/dojump.cc