gcc/dojump.c

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