gcc/dojump.c

   1 /* Convert tree expression to rtl instructions, for GNU compiler.
   2    Copyright (C) 1988-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   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
   9 version.
  10
  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
  14 for more details.
  15
  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/>.  */
  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
  40 static bool prefer_and_bit_test (machine_mode, int);
  41 static void do_jump_by_parts_greater (tree, tree, int,
  42                                       rtx_code_label *, rtx_code_label *, int);
  43 static void do_jump_by_parts_equality (tree, tree, rtx_code_label *,
  44                                        rtx_code_label *, int);
  45 static void do_compare_and_jump (tree, tree, enum rtx_code, enum rtx_code,
  46                                  rtx_code_label *, rtx_code_label *, int);
  47
  48 /* Invert probability if there is any.  -1 stands for unknown.  */
  49
  50 static inline int
  51 inv (int prob)
  52 {
  53   return prob == -1 ? -1 : REG_BR_PROB_BASE - prob;
  54 }
  55
  56 /* At the start of a function, record that we have no previously-pushed
  57    arguments waiting to be popped.  */
  58
  59 void
  60 init_pending_stack_adjust (void)
  61 {
  62   pending_stack_adjust = 0;
  63 }
  64
  65 /* Discard any pending stack adjustment.  This avoid relying on the
  66    RTL optimizers to remove useless adjustments when we know the
  67    stack pointer value is dead.  */
  68 void
  69 discard_pending_stack_adjust (void)
  70 {
  71   stack_pointer_delta -= pending_stack_adjust;
  72   pending_stack_adjust = 0;
  73 }
  74
  75 /* When exiting from function, if safe, clear out any pending stack adjust
  76    so the adjustment won't get done.
  77
  78    Note, if the current function calls alloca, then it must have a
  79    frame pointer regardless of the value of flag_omit_frame_pointer.  */
  80
  81 void
  82 clear_pending_stack_adjust (void)
  83 {
  84   if (optimize > 0
  85       && (! flag_omit_frame_pointer || cfun->calls_alloca)
  86       && EXIT_IGNORE_STACK)
  87     discard_pending_stack_adjust ();
  88 }
  89
  90 /* Pop any previously-pushed arguments that have not been popped yet.  */
  91
  92 void
  93 do_pending_stack_adjust (void)
  94 {
  95   if (inhibit_defer_pop == 0)
  96     {
  97       if (pending_stack_adjust != 0)
  98         adjust_stack (GEN_INT (pending_stack_adjust));
  99       pending_stack_adjust = 0;
 100     }
 101 }
 102
 103 /* Remember pending_stack_adjust/stack_pointer_delta.
 104    To be used around code that may call do_pending_stack_adjust (),
 105    but the generated code could be discarded e.g. using delete_insns_since.  */
 106
 107 void
 108 save_pending_stack_adjust (saved_pending_stack_adjust *save)
 109 {
 110   save->x_pending_stack_adjust = pending_stack_adjust;
 111   save->x_stack_pointer_delta = stack_pointer_delta;
 112 }
 113
 114 /* Restore the saved pending_stack_adjust/stack_pointer_delta.  */
 115
 116 void
 117 restore_pending_stack_adjust (saved_pending_stack_adjust *save)
 118 {
 119   if (inhibit_defer_pop == 0)
 120     {
 121       pending_stack_adjust = save->x_pending_stack_adjust;
 122       stack_pointer_delta = save->x_stack_pointer_delta;
 123     }
 124 }
 125 \f
 126 /* Expand conditional expressions.  */
 127
 128 /* Generate code to evaluate EXP and jump to LABEL if the value is zero.  */
 129
 130 void
 131 jumpifnot (tree exp, rtx_code_label *label, int prob)
 132 {
 133   do_jump (exp, label, NULL, inv (prob));
 134 }
 135
 136 void
 137 jumpifnot_1 (enum tree_code code, tree op0, tree op1, rtx_code_label *label,
 138              int prob)
 139 {
 140   do_jump_1 (code, op0, op1, label, NULL, inv (prob));
 141 }
 142
 143 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.  */
 144
 145 void
 146 jumpif (tree exp, rtx_code_label *label, int prob)
 147 {
 148   do_jump (exp, NULL, label, prob);
 149 }
 150
 151 void
 152 jumpif_1 (enum tree_code code, tree op0, tree op1,
 153           rtx_code_label *label, int prob)
 154 {
 155   do_jump_1 (code, op0, op1, NULL, label, prob);
 156 }
 157
 158 /* Used internally by prefer_and_bit_test.  */
 159
 160 static GTY(()) rtx and_reg;
 161 static GTY(()) rtx and_test;
 162 static GTY(()) rtx shift_test;
 163
 164 /* Compare the relative costs of "(X & (1 << BITNUM))" and "(X >> BITNUM) & 1",
 165    where X is an arbitrary register of mode MODE.  Return true if the former
 166    is preferred.  */
 167
 168 static bool
 169 prefer_and_bit_test (machine_mode mode, int bitnum)
 170 {
 171   bool speed_p;
 172   wide_int mask = wi::set_bit_in_zero (bitnum, GET_MODE_PRECISION (mode));
 173
 174   if (and_test == 0)
 175     {
 176       /* Set up rtxes for the two variations.  Use NULL as a placeholder
 177          for the BITNUM-based constants.  */
 178       and_reg = gen_rtx_REG (mode, LAST_VIRTUAL_REGISTER + 1);
 179       and_test = gen_rtx_AND (mode, and_reg, NULL);
 180       shift_test = gen_rtx_AND (mode, gen_rtx_ASHIFTRT (mode, and_reg, NULL),
 181                                 const1_rtx);
 182     }
 183   else
 184     {
 185       /* Change the mode of the previously-created rtxes.  */
 186       PUT_MODE (and_reg, mode);
 187       PUT_MODE (and_test, mode);
 188       PUT_MODE (shift_test, mode);
 189       PUT_MODE (XEXP (shift_test, 0), mode);
 190     }
 191
 192   /* Fill in the integers.  */
 193   XEXP (and_test, 1) = immed_wide_int_const (mask, mode);
 194   XEXP (XEXP (shift_test, 0), 1) = GEN_INT (bitnum);
 195
 196   speed_p = optimize_insn_for_speed_p ();
 197   return (rtx_cost (and_test, mode, IF_THEN_ELSE, 0, speed_p)
 198           <= rtx_cost (shift_test, mode, IF_THEN_ELSE, 0, speed_p));
 199 }
 200
 201 /* Subroutine of do_jump, dealing with exploded comparisons of the type
 202    OP0 CODE OP1 .  IF_FALSE_LABEL and IF_TRUE_LABEL like in do_jump.
 203    PROB is probability of jump to if_true_label, or -1 if unknown.  */
 204
 205 void
 206 do_jump_1 (enum tree_code code, tree op0, tree op1,
 207            rtx_code_label *if_false_label, rtx_code_label *if_true_label,
 208            int prob)
 209 {
 210   machine_mode mode;
 211   rtx_code_label *drop_through_label = 0;
 212
 213   switch (code)
 214     {
 215     case EQ_EXPR:
 216       {
 217         tree inner_type = TREE_TYPE (op0);
 218
 219         gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
 220                     != MODE_COMPLEX_FLOAT);
 221         gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
 222                     != MODE_COMPLEX_INT);
 223
 224         if (integer_zerop (op1))
 225           do_jump (op0, if_true_label, if_false_label, inv (prob));
 226         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
 227                  && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
 228           do_jump_by_parts_equality (op0, op1, if_false_label, if_true_label,
 229                                      prob);
 230         else
 231           do_compare_and_jump (op0, op1, EQ, EQ, if_false_label, if_true_label,
 232                                prob);
 233         break;
 234       }
 235
 236     case NE_EXPR:
 237       {
 238         tree inner_type = TREE_TYPE (op0);
 239
 240         gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
 241                     != MODE_COMPLEX_FLOAT);
 242         gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
 243                     != MODE_COMPLEX_INT);
 244
 245         if (integer_zerop (op1))
 246           do_jump (op0, if_false_label, if_true_label, prob);
 247         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
 248            && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
 249           do_jump_by_parts_equality (op0, op1, if_true_label, if_false_label,
 250                                      inv (prob));
 251         else
 252           do_compare_and_jump (op0, op1, NE, NE, if_false_label, if_true_label,
 253                                prob);
 254         break;
 255       }
 256
 257     case LT_EXPR:
 258       mode = TYPE_MODE (TREE_TYPE (op0));
 259       if (GET_MODE_CLASS (mode) == MODE_INT
 260           && ! can_compare_p (LT, mode, ccp_jump))
 261         do_jump_by_parts_greater (op0, op1, 1, if_false_label, if_true_label,
 262                                   prob);
 263       else
 264         do_compare_and_jump (op0, op1, LT, LTU, if_false_label, if_true_label,
 265                              prob);
 266       break;
 267
 268     case LE_EXPR:
 269       mode = TYPE_MODE (TREE_TYPE (op0));
 270       if (GET_MODE_CLASS (mode) == MODE_INT
 271           && ! can_compare_p (LE, mode, ccp_jump))
 272         do_jump_by_parts_greater (op0, op1, 0, if_true_label, if_false_label,
 273                                   inv (prob));
 274       else
 275         do_compare_and_jump (op0, op1, LE, LEU, if_false_label, if_true_label,
 276                              prob);
 277       break;
 278
 279     case GT_EXPR:
 280       mode = TYPE_MODE (TREE_TYPE (op0));
 281       if (GET_MODE_CLASS (mode) == MODE_INT
 282           && ! can_compare_p (GT, mode, ccp_jump))
 283         do_jump_by_parts_greater (op0, op1, 0, if_false_label, if_true_label,
 284                                   prob);
 285       else
 286         do_compare_and_jump (op0, op1, GT, GTU, if_false_label, if_true_label,
 287                              prob);
 288       break;
 289
 290     case GE_EXPR:
 291       mode = TYPE_MODE (TREE_TYPE (op0));
 292       if (GET_MODE_CLASS (mode) == MODE_INT
 293           && ! can_compare_p (GE, mode, ccp_jump))
 294         do_jump_by_parts_greater (op0, op1, 1, if_true_label, if_false_label,
 295                                   inv (prob));
 296       else
 297         do_compare_and_jump (op0, op1, GE, GEU, if_false_label, if_true_label,
 298                              prob);
 299       break;
 300
 301     case ORDERED_EXPR:
 302       do_compare_and_jump (op0, op1, ORDERED, ORDERED,
 303                            if_false_label, if_true_label, prob);
 304       break;
 305
 306     case UNORDERED_EXPR:
 307       do_compare_and_jump (op0, op1, UNORDERED, UNORDERED,
 308                            if_false_label, if_true_label, prob);
 309       break;
 310
 311     case UNLT_EXPR:
 312       do_compare_and_jump (op0, op1, UNLT, UNLT, if_false_label, if_true_label,
 313                            prob);
 314       break;
 315
 316     case UNLE_EXPR:
 317       do_compare_and_jump (op0, op1, UNLE, UNLE, if_false_label, if_true_label,
 318                            prob);
 319       break;
 320
 321     case UNGT_EXPR:
 322       do_compare_and_jump (op0, op1, UNGT, UNGT, if_false_label, if_true_label,
 323                            prob);
 324       break;
 325
 326     case UNGE_EXPR:
 327       do_compare_and_jump (op0, op1, UNGE, UNGE, if_false_label, if_true_label,
 328                            prob);
 329       break;
 330
 331     case UNEQ_EXPR:
 332       do_compare_and_jump (op0, op1, UNEQ, UNEQ, if_false_label, if_true_label,
 333                            prob);
 334       break;
 335
 336     case LTGT_EXPR:
 337       do_compare_and_jump (op0, op1, LTGT, LTGT, if_false_label, if_true_label,
 338                            prob);
 339       break;
 340
 341     case TRUTH_ANDIF_EXPR:
 342       {
 343         /* Spread the probability that the expression is false evenly between
 344            the two conditions. So the first condition is false half the total
 345            probability of being false. The second condition is false the other
 346            half of the total probability of being false, so its jump has a false
 347            probability of half the total, relative to the probability we
 348            reached it (i.e. the first condition was true).  */
 349         int op0_prob = -1;
 350         int op1_prob = -1;
 351         if (prob != -1)
 352           {
 353             int false_prob = inv (prob);
 354             int op0_false_prob = false_prob / 2;
 355             int op1_false_prob = GCOV_COMPUTE_SCALE ((false_prob / 2),
 356                                                      inv (op0_false_prob));
 357             /* Get the probability that each jump below is true.  */
 358             op0_prob = inv (op0_false_prob);
 359             op1_prob = inv (op1_false_prob);
 360           }
 361         if (if_false_label == NULL)
 362           {
 363             drop_through_label = gen_label_rtx ();
 364             do_jump (op0, drop_through_label, NULL, op0_prob);
 365             do_jump (op1, NULL, if_true_label, op1_prob);
 366           }
 367         else
 368           {
 369             do_jump (op0, if_false_label, NULL, op0_prob);
 370             do_jump (op1, if_false_label, if_true_label, op1_prob);
 371           }
 372         break;
 373       }
 374
 375     case TRUTH_ORIF_EXPR:
 376       {
 377         /* Spread the probability evenly between the two conditions. So
 378            the first condition has half the total probability of being true.
 379            The second condition has the other half of the total probability,
 380            so its jump has a probability of half the total, relative to
 381            the probability we reached it (i.e. the first condition was false).  */
 382         int op0_prob = -1;
 383         int op1_prob = -1;
 384         if (prob != -1)
 385           {
 386             op0_prob = prob / 2;
 387             op1_prob = GCOV_COMPUTE_SCALE ((prob / 2), inv (op0_prob));
 388           }
 389         if (if_true_label == NULL)
 390           {
 391             drop_through_label = gen_label_rtx ();
 392             do_jump (op0, NULL, drop_through_label, op0_prob);
 393             do_jump (op1, if_false_label, NULL, op1_prob);
 394           }
 395         else
 396           {
 397             do_jump (op0, NULL, if_true_label, op0_prob);
 398             do_jump (op1, if_false_label, if_true_label, op1_prob);
 399           }
 400         break;
 401       }
 402
 403     default:
 404       gcc_unreachable ();
 405     }
 406
 407   if (drop_through_label)
 408     {
 409       do_pending_stack_adjust ();
 410       emit_label (drop_through_label);
 411     }
 412 }
 413
 414 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
 415    the result is zero, or IF_TRUE_LABEL if the result is one.
 416    Either of IF_FALSE_LABEL and IF_TRUE_LABEL may be zero,
 417    meaning fall through in that case.
 418
 419    do_jump always does any pending stack adjust except when it does not
 420    actually perform a jump.  An example where there is no jump
 421    is when EXP is `(foo (), 0)' and IF_FALSE_LABEL is null.
 422
 423    PROB is probability of jump to if_true_label, or -1 if unknown.  */
 424
 425 void
 426 do_jump (tree exp, rtx_code_label *if_false_label,
 427          rtx_code_label *if_true_label, int prob)
 428 {
 429   enum tree_code code = TREE_CODE (exp);
 430   rtx temp;
 431   int i;
 432   tree type;
 433   machine_mode mode;
 434   rtx_code_label *drop_through_label = NULL;
 435
 436   switch (code)
 437     {
 438     case ERROR_MARK:
 439       break;
 440
 441     case INTEGER_CST:
 442       {
 443         rtx_code_label *lab = integer_zerop (exp) ? if_false_label
 444                                                   : if_true_label;
 445         if (lab)
 446           emit_jump (lab);
 447         break;
 448       }
 449
 450 #if 0
 451       /* This is not true with #pragma weak  */
 452     case ADDR_EXPR:
 453       /* The address of something can never be zero.  */
 454       if (if_true_label)
 455         emit_jump (if_true_label);
 456       break;
 457 #endif
 458
 459     case NOP_EXPR:
 460       if (TREE_CODE (TREE_OPERAND (exp, 0)) == COMPONENT_REF
 461           || TREE_CODE (TREE_OPERAND (exp, 0)) == BIT_FIELD_REF
 462           || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_REF
 463           || TREE_CODE (TREE_OPERAND (exp, 0)) == ARRAY_RANGE_REF)
 464         goto normal;
 465       /* FALLTHRU */
 466     case CONVERT_EXPR:
 467       /* If we are narrowing the operand, we have to do the compare in the
 468          narrower mode.  */
 469       if ((TYPE_PRECISION (TREE_TYPE (exp))
 470            < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0)))))
 471         goto normal;
 472       /* FALLTHRU */
 473     case NON_LVALUE_EXPR:
 474     case ABS_EXPR:
 475     case NEGATE_EXPR:
 476     case LROTATE_EXPR:
 477     case RROTATE_EXPR:
 478       /* These cannot change zero->nonzero or vice versa.  */
 479       do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label, prob);
 480       break;
 481
 482     case TRUTH_NOT_EXPR:
 483       do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label,
 484                inv (prob));
 485       break;
 486
 487     case COND_EXPR:
 488       {
 489         rtx_code_label *label1 = gen_label_rtx ();
 490         if (!if_true_label || !if_false_label)
 491           {
 492             drop_through_label = gen_label_rtx ();
 493             if (!if_true_label)
 494               if_true_label = drop_through_label;
 495             if (!if_false_label)
 496               if_false_label = drop_through_label;
 497           }
 498
 499         do_pending_stack_adjust ();
 500         do_jump (TREE_OPERAND (exp, 0), label1, NULL, -1);
 501         do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label, prob);
 502         emit_label (label1);
 503         do_jump (TREE_OPERAND (exp, 2), if_false_label, if_true_label, prob);
 504         break;
 505       }
 506
 507     case COMPOUND_EXPR:
 508       /* Lowered by gimplify.c.  */
 509       gcc_unreachable ();
 510
 511     case MINUS_EXPR:
 512       /* Nonzero iff operands of minus differ.  */
 513       code = NE_EXPR;
 514
 515       /* FALLTHRU */
 516     case EQ_EXPR:
 517     case NE_EXPR:
 518     case LT_EXPR:
 519     case LE_EXPR:
 520     case GT_EXPR:
 521     case GE_EXPR:
 522     case ORDERED_EXPR:
 523     case UNORDERED_EXPR:
 524     case UNLT_EXPR:
 525     case UNLE_EXPR:
 526     case UNGT_EXPR:
 527     case UNGE_EXPR:
 528     case UNEQ_EXPR:
 529     case LTGT_EXPR:
 530     case TRUTH_ANDIF_EXPR:
 531     case TRUTH_ORIF_EXPR:
 532     other_code:
 533       do_jump_1 (code, TREE_OPERAND (exp, 0), TREE_OPERAND (exp, 1),
 534                  if_false_label, if_true_label, prob);
 535       break;
 536
 537     case BIT_AND_EXPR:
 538       /* fold_single_bit_test() converts (X & (1 << C)) into (X >> C) & 1.
 539          See if the former is preferred for jump tests and restore it
 540          if so.  */
 541       if (integer_onep (TREE_OPERAND (exp, 1)))
 542         {
 543           tree exp0 = TREE_OPERAND (exp, 0);
 544           rtx_code_label *set_label, *clr_label;
 545           int setclr_prob = prob;
 546
 547           /* Strip narrowing integral type conversions.  */
 548           while (CONVERT_EXPR_P (exp0)
 549                  && TREE_OPERAND (exp0, 0) != error_mark_node
 550                  && TYPE_PRECISION (TREE_TYPE (exp0))
 551                     <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp0, 0))))
 552             exp0 = TREE_OPERAND (exp0, 0);
 553
 554           /* "exp0 ^ 1" inverts the sense of the single bit test.  */
 555           if (TREE_CODE (exp0) == BIT_XOR_EXPR
 556               && integer_onep (TREE_OPERAND (exp0, 1)))
 557             {
 558               exp0 = TREE_OPERAND (exp0, 0);
 559               clr_label = if_true_label;
 560               set_label = if_false_label;
 561               setclr_prob = inv (prob);
 562             }
 563           else
 564             {
 565               clr_label = if_false_label;
 566               set_label = if_true_label;
 567             }
 568
 569           if (TREE_CODE (exp0) == RSHIFT_EXPR)
 570             {
 571               tree arg = TREE_OPERAND (exp0, 0);
 572               tree shift = TREE_OPERAND (exp0, 1);
 573               tree argtype = TREE_TYPE (arg);
 574               if (TREE_CODE (shift) == INTEGER_CST
 575                   && compare_tree_int (shift, 0) >= 0
 576                   && compare_tree_int (shift, HOST_BITS_PER_WIDE_INT) < 0
 577                   && prefer_and_bit_test (TYPE_MODE (argtype),
 578                                           TREE_INT_CST_LOW (shift)))
 579                 {
 580                   unsigned HOST_WIDE_INT mask
 581                     = HOST_WIDE_INT_1U << TREE_INT_CST_LOW (shift);
 582                   do_jump (build2 (BIT_AND_EXPR, argtype, arg,
 583                                    build_int_cstu (argtype, mask)),
 584                            clr_label, set_label, setclr_prob);
 585                   break;
 586                 }
 587             }
 588         }
 589
 590       /* If we are AND'ing with a small constant, do this comparison in the
 591          smallest type that fits.  If the machine doesn't have comparisons
 592          that small, it will be converted back to the wider comparison.
 593          This helps if we are testing the sign bit of a narrower object.
 594          combine can't do this for us because it can't know whether a
 595          ZERO_EXTRACT or a compare in a smaller mode exists, but we do.  */
 596
 597       if (! SLOW_BYTE_ACCESS
 598           && TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST
 599           && TYPE_PRECISION (TREE_TYPE (exp)) <= HOST_BITS_PER_WIDE_INT
 600           && (i = tree_floor_log2 (TREE_OPERAND (exp, 1))) >= 0
 601           && (mode = mode_for_size (i + 1, MODE_INT, 0)) != BLKmode
 602           && (type = lang_hooks.types.type_for_mode (mode, 1)) != 0
 603           && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (exp))
 604           && have_insn_for (COMPARE, TYPE_MODE (type)))
 605         {
 606           do_jump (fold_convert (type, exp), if_false_label, if_true_label,
 607                    prob);
 608           break;
 609         }
 610
 611       if (TYPE_PRECISION (TREE_TYPE (exp)) > 1
 612           || TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
 613         goto normal;
 614
 615       /* Boolean comparisons can be compiled as TRUTH_AND_EXPR.  */
 616       /* FALLTHRU */
 617
 618     case TRUTH_AND_EXPR:
 619       /* High branch cost, expand as the bitwise AND of the conditions.
 620          Do the same if the RHS has side effects, because we're effectively
 621          turning a TRUTH_AND_EXPR into a TRUTH_ANDIF_EXPR.  */
 622       if (BRANCH_COST (optimize_insn_for_speed_p (),
 623                        false) >= 4
 624           || TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
 625         goto normal;
 626       code = TRUTH_ANDIF_EXPR;
 627       goto other_code;
 628
 629     case BIT_IOR_EXPR:
 630     case TRUTH_OR_EXPR:
 631       /* High branch cost, expand as the bitwise OR of the conditions.
 632          Do the same if the RHS has side effects, because we're effectively
 633          turning a TRUTH_OR_EXPR into a TRUTH_ORIF_EXPR.  */
 634       if (BRANCH_COST (optimize_insn_for_speed_p (), false) >= 4
 635           || TREE_SIDE_EFFECTS (TREE_OPERAND (exp, 1)))
 636         goto normal;
 637       code = TRUTH_ORIF_EXPR;
 638       goto other_code;
 639
 640       /* Fall through and generate the normal code.  */
 641     default:
 642     normal:
 643       temp = expand_normal (exp);
 644       do_pending_stack_adjust ();
 645       /* The RTL optimizers prefer comparisons against pseudos.  */
 646       if (GET_CODE (temp) == SUBREG)
 647         {
 648           /* Compare promoted variables in their promoted mode.  */
 649           if (SUBREG_PROMOTED_VAR_P (temp)
 650               && REG_P (XEXP (temp, 0)))
 651             temp = XEXP (temp, 0);
 652           else
 653             temp = copy_to_reg (temp);
 654         }
 655       do_compare_rtx_and_jump (temp, CONST0_RTX (GET_MODE (temp)),
 656                                NE, TYPE_UNSIGNED (TREE_TYPE (exp)),
 657                                GET_MODE (temp), NULL_RTX,
 658                                if_false_label, if_true_label, prob);
 659     }
 660
 661   if (drop_through_label)
 662     {
 663       do_pending_stack_adjust ();
 664       emit_label (drop_through_label);
 665     }
 666 }
 667 \f
 668 /* Compare OP0 with OP1, word at a time, in mode MODE.
 669    UNSIGNEDP says to do unsigned comparison.
 670    Jump to IF_TRUE_LABEL if OP0 is greater, IF_FALSE_LABEL otherwise.  */
 671
 672 static void
 673 do_jump_by_parts_greater_rtx (machine_mode mode, int unsignedp, rtx op0,
 674                               rtx op1, rtx_code_label *if_false_label,
 675                               rtx_code_label *if_true_label,
 676                               int prob)
 677 {
 678   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
 679   rtx_code_label *drop_through_label = 0;
 680   bool drop_through_if_true = false, drop_through_if_false = false;
 681   enum rtx_code code = GT;
 682   int i;
 683
 684   if (! if_true_label || ! if_false_label)
 685     drop_through_label = gen_label_rtx ();
 686   if (! if_true_label)
 687     {
 688       if_true_label = drop_through_label;
 689       drop_through_if_true = true;
 690     }
 691   if (! if_false_label)
 692     {
 693       if_false_label = drop_through_label;
 694       drop_through_if_false = true;
 695     }
 696
 697   /* Deal with the special case 0 > x: only one comparison is necessary and
 698      we reverse it to avoid jumping to the drop-through label.  */
 699   if (op0 == const0_rtx && drop_through_if_true && !drop_through_if_false)
 700     {
 701       code = LE;
 702       if_true_label = if_false_label;
 703       if_false_label = drop_through_label;
 704       drop_through_if_true = false;
 705       drop_through_if_false = true;
 706       prob = inv (prob);
 707     }
 708
 709   /* Compare a word at a time, high order first.  */
 710   for (i = 0; i < nwords; i++)
 711     {
 712       rtx op0_word, op1_word;
 713
 714       if (WORDS_BIG_ENDIAN)
 715         {
 716           op0_word = operand_subword_force (op0, i, mode);
 717           op1_word = operand_subword_force (op1, i, mode);
 718         }
 719       else
 720         {
 721           op0_word = operand_subword_force (op0, nwords - 1 - i, mode);
 722           op1_word = operand_subword_force (op1, nwords - 1 - i, mode);
 723         }
 724
 725       /* All but high-order word must be compared as unsigned.  */
 726       do_compare_rtx_and_jump (op0_word, op1_word, code, (unsignedp || i > 0),
 727                                word_mode, NULL_RTX, NULL, if_true_label,
 728                                prob);
 729
 730       /* Emit only one comparison for 0.  Do not emit the last cond jump.  */
 731       if (op0 == const0_rtx || i == nwords - 1)
 732         break;
 733
 734       /* Consider lower words only if these are equal.  */
 735       do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
 736                                NULL_RTX, NULL, if_false_label, inv (prob));
 737     }
 738
 739   if (!drop_through_if_false)
 740     emit_jump (if_false_label);
 741   if (drop_through_label)
 742     emit_label (drop_through_label);
 743 }
 744
 745 /* Given a comparison expression EXP for values too wide to be compared
 746    with one insn, test the comparison and jump to the appropriate label.
 747    The code of EXP is ignored; we always test GT if SWAP is 0,
 748    and LT if SWAP is 1.  */
 749
 750 static void
 751 do_jump_by_parts_greater (tree treeop0, tree treeop1, int swap,
 752                           rtx_code_label *if_false_label,
 753                           rtx_code_label *if_true_label, int prob)
 754 {
 755   rtx op0 = expand_normal (swap ? treeop1 : treeop0);
 756   rtx op1 = expand_normal (swap ? treeop0 : treeop1);
 757   machine_mode mode = TYPE_MODE (TREE_TYPE (treeop0));
 758   int unsignedp = TYPE_UNSIGNED (TREE_TYPE (treeop0));
 759
 760   do_jump_by_parts_greater_rtx (mode, unsignedp, op0, op1, if_false_label,
 761                                 if_true_label, prob);
 762 }
 763 \f
 764 /* Jump according to whether OP0 is 0.  We assume that OP0 has an integer
 765    mode, MODE, that is too wide for the available compare insns.  Either
 766    Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL
 767    to indicate drop through.  */
 768
 769 static void
 770 do_jump_by_parts_zero_rtx (machine_mode mode, rtx op0,
 771                            rtx_code_label *if_false_label,
 772                            rtx_code_label *if_true_label, int prob)
 773 {
 774   int nwords = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
 775   rtx part;
 776   int i;
 777   rtx_code_label *drop_through_label = NULL;
 778
 779   /* The fastest way of doing this comparison on almost any machine is to
 780      "or" all the words and compare the result.  If all have to be loaded
 781      from memory and this is a very wide item, it's possible this may
 782      be slower, but that's highly unlikely.  */
 783
 784   part = gen_reg_rtx (word_mode);
 785   emit_move_insn (part, operand_subword_force (op0, 0, mode));
 786   for (i = 1; i < nwords && part != 0; i++)
 787     part = expand_binop (word_mode, ior_optab, part,
 788                          operand_subword_force (op0, i, mode),
 789                          part, 1, OPTAB_WIDEN);
 790
 791   if (part != 0)
 792     {
 793       do_compare_rtx_and_jump (part, const0_rtx, EQ, 1, word_mode,
 794                                NULL_RTX, if_false_label, if_true_label, prob);
 795       return;
 796     }
 797
 798   /* If we couldn't do the "or" simply, do this with a series of compares.  */
 799   if (! if_false_label)
 800     if_false_label = drop_through_label = gen_label_rtx ();
 801
 802   for (i = 0; i < nwords; i++)
 803     do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
 804                              const0_rtx, EQ, 1, word_mode, NULL_RTX,
 805                              if_false_label, NULL, prob);
 806
 807   if (if_true_label)
 808     emit_jump (if_true_label);
 809
 810   if (drop_through_label)
 811     emit_label (drop_through_label);
 812 }
 813
 814 /* Test for the equality of two RTX expressions OP0 and OP1 in mode MODE,
 815    where MODE is an integer mode too wide to be compared with one insn.
 816    Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL_RTX
 817    to indicate drop through.  */
 818
 819 static void
 820 do_jump_by_parts_equality_rtx (machine_mode mode, rtx op0, rtx op1,
 821                                rtx_code_label *if_false_label,
 822                                rtx_code_label *if_true_label, int prob)
 823 {
 824   int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
 825   rtx_code_label *drop_through_label = NULL;
 826   int i;
 827
 828   if (op1 == const0_rtx)
 829     {
 830       do_jump_by_parts_zero_rtx (mode, op0, if_false_label, if_true_label,
 831                                  prob);
 832       return;
 833     }
 834   else if (op0 == const0_rtx)
 835     {
 836       do_jump_by_parts_zero_rtx (mode, op1, if_false_label, if_true_label,
 837                                  prob);
 838       return;
 839     }
 840
 841   if (! if_false_label)
 842     drop_through_label = if_false_label = gen_label_rtx ();
 843
 844   for (i = 0; i < nwords; i++)
 845     do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
 846                              operand_subword_force (op1, i, mode),
 847                              EQ, 0, word_mode, NULL_RTX,
 848                              if_false_label, NULL, prob);
 849
 850   if (if_true_label)
 851     emit_jump (if_true_label);
 852   if (drop_through_label)
 853     emit_label (drop_through_label);
 854 }
 855
 856 /* Given an EQ_EXPR expression EXP for values too wide to be compared
 857    with one insn, test the comparison and jump to the appropriate label.  */
 858
 859 static void
 860 do_jump_by_parts_equality (tree treeop0, tree treeop1,
 861                            rtx_code_label *if_false_label,
 862                            rtx_code_label *if_true_label, int prob)
 863 {
 864   rtx op0 = expand_normal (treeop0);
 865   rtx op1 = expand_normal (treeop1);
 866   machine_mode mode = TYPE_MODE (TREE_TYPE (treeop0));
 867   do_jump_by_parts_equality_rtx (mode, op0, op1, if_false_label,
 868                                  if_true_label, prob);
 869 }
 870 \f
 871 /* Split a comparison into two others, the second of which has the other
 872    "orderedness".  The first is always ORDERED or UNORDERED if MODE
 873    does not honor NaNs (which means that it can be skipped in that case;
 874    see do_compare_rtx_and_jump).
 875
 876    The two conditions are written in *CODE1 and *CODE2.  Return true if
 877    the conditions must be ANDed, false if they must be ORed.  */
 878
 879 bool
 880 split_comparison (enum rtx_code code, machine_mode mode,
 881                   enum rtx_code *code1, enum rtx_code *code2)
 882 {
 883   switch (code)
 884     {
 885     case LT:
 886       *code1 = ORDERED;
 887       *code2 = UNLT;
 888       return true;
 889     case LE:
 890       *code1 = ORDERED;
 891       *code2 = UNLE;
 892       return true;
 893     case GT:
 894       *code1 = ORDERED;
 895       *code2 = UNGT;
 896       return true;
 897     case GE:
 898       *code1 = ORDERED;
 899       *code2 = UNGE;
 900       return true;
 901     case EQ:
 902       *code1 = ORDERED;
 903       *code2 = UNEQ;
 904       return true;
 905     case NE:
 906       *code1 = UNORDERED;
 907       *code2 = LTGT;
 908       return false;
 909     case UNLT:
 910       *code1 = UNORDERED;
 911       *code2 = LT;
 912       return false;
 913     case UNLE:
 914       *code1 = UNORDERED;
 915       *code2 = LE;
 916       return false;
 917     case UNGT:
 918       *code1 = UNORDERED;
 919       *code2 = GT;
 920       return false;
 921     case UNGE:
 922       *code1 = UNORDERED;
 923       *code2 = GE;
 924       return false;
 925     case UNEQ:
 926       *code1 = UNORDERED;
 927       *code2 = EQ;
 928       return false;
 929     case LTGT:
 930       /* Do not turn a trapping comparison into a non-trapping one.  */
 931       if (HONOR_SNANS (mode))
 932         {
 933           *code1 = LT;
 934           *code2 = GT;
 935           return false;
 936         }
 937       else
 938         {
 939           *code1 = ORDERED;
 940           *code2 = NE;
 941           return true;
 942         }
 943     default:
 944       gcc_unreachable ();
 945     }
 946 }
 947
 948
 949 /* Like do_compare_and_jump but expects the values to compare as two rtx's.
 950    The decision as to signed or unsigned comparison must be made by the caller.
 951
 952    If MODE is BLKmode, SIZE is an RTX giving the size of the objects being
 953    compared.  */
 954
 955 void
 956 do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
 957                          machine_mode mode, rtx size,
 958                          rtx_code_label *if_false_label,
 959                          rtx_code_label *if_true_label, int prob)
 960 {
 961   rtx tem;
 962   rtx_code_label *dummy_label = NULL;
 963
 964   /* Reverse the comparison if that is safe and we want to jump if it is
 965      false.  Also convert to the reverse comparison if the target can
 966      implement it.  */
 967   if ((! if_true_label
 968        || ! can_compare_p (code, mode, ccp_jump))
 969       && (! FLOAT_MODE_P (mode)
 970           || code == ORDERED || code == UNORDERED
 971           || (! HONOR_NANS (mode) && (code == LTGT || code == UNEQ))
 972           || (! HONOR_SNANS (mode) && (code == EQ || code == NE))))
 973     {
 974       enum rtx_code rcode;
 975       if (FLOAT_MODE_P (mode))
 976         rcode = reverse_condition_maybe_unordered (code);
 977       else
 978         rcode = reverse_condition (code);
 979
 980       /* Canonicalize to UNORDERED for the libcall.  */
 981       if (can_compare_p (rcode, mode, ccp_jump)
 982           || (code == ORDERED && ! can_compare_p (ORDERED, mode, ccp_jump)))
 983         {
 984           std::swap (if_true_label, if_false_label);
 985           code = rcode;
 986           prob = inv (prob);
 987         }
 988     }
 989
 990   /* If one operand is constant, make it the second one.  Only do this
 991      if the other operand is not constant as well.  */
 992
 993   if (swap_commutative_operands_p (op0, op1))
 994     {
 995       std::swap (op0, op1);
 996       code = swap_condition (code);
 997     }
 998
 999   do_pending_stack_adjust ();
1000
1001   code = unsignedp ? unsigned_condition (code) : code;
1002   if (0 != (tem = simplify_relational_operation (code, mode, VOIDmode,
1003                                                  op0, op1)))
1004     {
1005       if (CONSTANT_P (tem))
1006         {
1007           rtx_code_label *label = (tem == const0_rtx
1008                                    || tem == CONST0_RTX (mode))
1009                                         ? if_false_label : if_true_label;
1010           if (label)
1011             emit_jump (label);
1012           return;
1013         }
1014
1015       code = GET_CODE (tem);
1016       mode = GET_MODE (tem);
1017       op0 = XEXP (tem, 0);
1018       op1 = XEXP (tem, 1);
1019       unsignedp = (code == GTU || code == LTU || code == GEU || code == LEU);
1020     }
1021
1022   if (! if_true_label)
1023     dummy_label = if_true_label = gen_label_rtx ();
1024
1025   if (GET_MODE_CLASS (mode) == MODE_INT
1026       && ! can_compare_p (code, mode, ccp_jump))
1027     {
1028       switch (code)
1029         {
1030         case LTU:
1031           do_jump_by_parts_greater_rtx (mode, 1, op1, op0,
1032                                         if_false_label, if_true_label, prob);
1033           break;
1034
1035         case LEU:
1036           do_jump_by_parts_greater_rtx (mode, 1, op0, op1,
1037                                         if_true_label, if_false_label,
1038                                         inv (prob));
1039           break;
1040
1041         case GTU:
1042           do_jump_by_parts_greater_rtx (mode, 1, op0, op1,
1043                                         if_false_label, if_true_label, prob);
1044           break;
1045
1046         case GEU:
1047           do_jump_by_parts_greater_rtx (mode, 1, op1, op0,
1048                                         if_true_label, if_false_label,
1049                                         inv (prob));
1050           break;
1051
1052         case LT:
1053           do_jump_by_parts_greater_rtx (mode, 0, op1, op0,
1054                                         if_false_label, if_true_label, prob);
1055           break;
1056
1057         case LE:
1058           do_jump_by_parts_greater_rtx (mode, 0, op0, op1,
1059                                         if_true_label, if_false_label,
1060                                         inv (prob));
1061           break;
1062
1063         case GT:
1064           do_jump_by_parts_greater_rtx (mode, 0, op0, op1,
1065                                         if_false_label, if_true_label, prob);
1066           break;
1067
1068         case GE:
1069           do_jump_by_parts_greater_rtx (mode, 0, op1, op0,
1070                                         if_true_label, if_false_label,
1071                                         inv (prob));
1072           break;
1073
1074         case EQ:
1075           do_jump_by_parts_equality_rtx (mode, op0, op1, if_false_label,
1076                                          if_true_label, prob);
1077           break;
1078
1079         case NE:
1080           do_jump_by_parts_equality_rtx (mode, op0, op1, if_true_label,
1081                                          if_false_label, inv (prob));
1082           break;
1083
1084         default:
1085           gcc_unreachable ();
1086         }
1087     }
1088   else
1089     {
1090       if (SCALAR_FLOAT_MODE_P (mode)
1091           && ! can_compare_p (code, mode, ccp_jump)
1092           && can_compare_p (swap_condition (code), mode, ccp_jump))
1093         {
1094           code = swap_condition (code);
1095           std::swap (op0, op1);
1096         }
1097       else if (SCALAR_FLOAT_MODE_P (mode)
1098                && ! can_compare_p (code, mode, ccp_jump)
1099                /* Never split ORDERED and UNORDERED.
1100                   These must be implemented.  */
1101                && (code != ORDERED && code != UNORDERED)
1102                /* Split a floating-point comparison if
1103                   we can jump on other conditions...  */
1104                && (have_insn_for (COMPARE, mode)
1105                    /* ... or if there is no libcall for it.  */
1106                    || code_to_optab (code) == unknown_optab))
1107         {
1108           enum rtx_code first_code;
1109           bool and_them = split_comparison (code, mode, &first_code, &code);
1110
1111           /* If there are no NaNs, the first comparison should always fall
1112              through.  */
1113           if (!HONOR_NANS (mode))
1114             gcc_assert (first_code == (and_them ? ORDERED : UNORDERED));
1115
1116           else
1117             {
1118               int first_prob = prob;
1119               if (first_code == UNORDERED)
1120                 first_prob = REG_BR_PROB_BASE / 100;
1121               else if (first_code == ORDERED)
1122                 first_prob = REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100;
1123               if (and_them)
1124                 {
1125                   rtx_code_label *dest_label;
1126                   /* If we only jump if true, just bypass the second jump.  */
1127                   if (! if_false_label)
1128                     {
1129                       if (! dummy_label)
1130                         dummy_label = gen_label_rtx ();
1131                       dest_label = dummy_label;
1132                     }
1133                   else
1134                     dest_label = if_false_label;
1135                   do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode,
1136                                            size, dest_label, NULL, first_prob);
1137                 }
1138               else
1139                 do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode,
1140                                          size, NULL, if_true_label, first_prob);
1141             }
1142         }
1143
1144       emit_cmp_and_jump_insns (op0, op1, code, size, mode, unsignedp,
1145                                if_true_label, prob);
1146     }
1147
1148   if (if_false_label)
1149     emit_jump (if_false_label);
1150   if (dummy_label)
1151     emit_label (dummy_label);
1152 }
1153
1154 /* Generate code for a comparison expression EXP (including code to compute
1155    the values to be compared) and a conditional jump to IF_FALSE_LABEL and/or
1156    IF_TRUE_LABEL.  One of the labels can be NULL_RTX, in which case the
1157    generated code will drop through.
1158    SIGNED_CODE should be the rtx operation for this comparison for
1159    signed data; UNSIGNED_CODE, likewise for use if data is unsigned.
1160
1161    We force a stack adjustment unless there are currently
1162    things pushed on the stack that aren't yet used.  */
1163
1164 static void
1165 do_compare_and_jump (tree treeop0, tree treeop1, enum rtx_code signed_code,
1166                      enum rtx_code unsigned_code,
1167                      rtx_code_label *if_false_label,
1168                      rtx_code_label *if_true_label, int prob)
1169 {
1170   rtx op0, op1;
1171   tree type;
1172   machine_mode mode;
1173   int unsignedp;
1174   enum rtx_code code;
1175
1176   /* Don't crash if the comparison was erroneous.  */
1177   op0 = expand_normal (treeop0);
1178   if (TREE_CODE (treeop0) == ERROR_MARK)
1179     return;
1180
1181   op1 = expand_normal (treeop1);
1182   if (TREE_CODE (treeop1) == ERROR_MARK)
1183     return;
1184
1185   type = TREE_TYPE (treeop0);
1186   mode = TYPE_MODE (type);
1187   if (TREE_CODE (treeop0) == INTEGER_CST
1188       && (TREE_CODE (treeop1) != INTEGER_CST
1189           || (GET_MODE_BITSIZE (mode)
1190               > GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (treeop1))))))
1191     {
1192       /* op0 might have been replaced by promoted constant, in which
1193          case the type of second argument should be used.  */
1194       type = TREE_TYPE (treeop1);
1195       mode = TYPE_MODE (type);
1196     }
1197   unsignedp = TYPE_UNSIGNED (type);
1198   code = unsignedp ? unsigned_code : signed_code;
1199
1200   /* If function pointers need to be "canonicalized" before they can
1201      be reliably compared, then canonicalize them.
1202      Only do this if *both* sides of the comparison are function pointers.
1203      If one side isn't, we want a noncanonicalized comparison.  See PR
1204      middle-end/17564.  */
1205   if (targetm.have_canonicalize_funcptr_for_compare ()
1206       && POINTER_TYPE_P (TREE_TYPE (treeop0))
1207       && POINTER_TYPE_P (TREE_TYPE (treeop1))
1208       && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (treeop0)))
1209       && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (treeop1))))
1210     {
1211       rtx new_op0 = gen_reg_rtx (mode);
1212       rtx new_op1 = gen_reg_rtx (mode);
1213
1214       emit_insn (targetm.gen_canonicalize_funcptr_for_compare (new_op0, op0));
1215       op0 = new_op0;
1216
1217       emit_insn (targetm.gen_canonicalize_funcptr_for_compare (new_op1, op1));
1218       op1 = new_op1;
1219     }
1220
1221   do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode,
1222                            ((mode == BLKmode)
1223                             ? expr_size (treeop0) : NULL_RTX),
1224                            if_false_label, if_true_label, prob);
1225 }
1226
1227 #include "gt-dojump.h"