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