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