LCOV - code coverage report
Current view: top level - gcc - ifcvt.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1730 2375 72.8 %
Date: 2020-04-04 11:58:09 Functions: 54 69 78.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* If-conversion support.
       2                 :            :    Copyright (C) 2000-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    This file is part of GCC.
       5                 :            : 
       6                 :            :    GCC is free software; you can redistribute it and/or modify it
       7                 :            :    under the terms of the GNU General Public License as published by
       8                 :            :    the Free Software Foundation; either version 3, or (at your option)
       9                 :            :    any later version.
      10                 :            : 
      11                 :            :    GCC is distributed in the hope that it will be useful, but WITHOUT
      12                 :            :    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      13                 :            :    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      14                 :            :    License for more details.
      15                 :            : 
      16                 :            :    You should have received a copy of the GNU General Public License
      17                 :            :    along with GCC; see the file COPYING3.  If not see
      18                 :            :    <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "target.h"
      25                 :            : #include "rtl.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "cfghooks.h"
      28                 :            : #include "df.h"
      29                 :            : #include "memmodel.h"
      30                 :            : #include "tm_p.h"
      31                 :            : #include "expmed.h"
      32                 :            : #include "optabs.h"
      33                 :            : #include "regs.h"
      34                 :            : #include "emit-rtl.h"
      35                 :            : #include "recog.h"
      36                 :            : 
      37                 :            : #include "cfgrtl.h"
      38                 :            : #include "cfganal.h"
      39                 :            : #include "cfgcleanup.h"
      40                 :            : #include "expr.h"
      41                 :            : #include "output.h"
      42                 :            : #include "cfgloop.h"
      43                 :            : #include "tree-pass.h"
      44                 :            : #include "dbgcnt.h"
      45                 :            : #include "shrink-wrap.h"
      46                 :            : #include "rtl-iter.h"
      47                 :            : #include "ifcvt.h"
      48                 :            : 
      49                 :            : #ifndef MAX_CONDITIONAL_EXECUTE
      50                 :            : #define MAX_CONDITIONAL_EXECUTE \
      51                 :            :   (BRANCH_COST (optimize_function_for_speed_p (cfun), false) \
      52                 :            :    + 1)
      53                 :            : #endif
      54                 :            : 
      55                 :            : #define IFCVT_MULTIPLE_DUMPS 1
      56                 :            : 
      57                 :            : #define NULL_BLOCK      ((basic_block) NULL)
      58                 :            : 
      59                 :            : /* True if after combine pass.  */
      60                 :            : static bool ifcvt_after_combine;
      61                 :            : 
      62                 :            : /* True if the target has the cbranchcc4 optab.  */
      63                 :            : static bool have_cbranchcc4;
      64                 :            : 
      65                 :            : /* # of IF-THEN or IF-THEN-ELSE blocks we looked at  */
      66                 :            : static int num_possible_if_blocks;
      67                 :            : 
      68                 :            : /* # of IF-THEN or IF-THEN-ELSE blocks were converted to conditional
      69                 :            :    execution.  */
      70                 :            : static int num_updated_if_blocks;
      71                 :            : 
      72                 :            : /* # of changes made.  */
      73                 :            : static int num_true_changes;
      74                 :            : 
      75                 :            : /* Whether conditional execution changes were made.  */
      76                 :            : static int cond_exec_changed_p;
      77                 :            : 
      78                 :            : /* Forward references.  */
      79                 :            : static int count_bb_insns (const_basic_block);
      80                 :            : static bool cheap_bb_rtx_cost_p (const_basic_block, profile_probability, int);
      81                 :            : static rtx_insn *first_active_insn (basic_block);
      82                 :            : static rtx_insn *last_active_insn (basic_block, int);
      83                 :            : static rtx_insn *find_active_insn_before (basic_block, rtx_insn *);
      84                 :            : static rtx_insn *find_active_insn_after (basic_block, rtx_insn *);
      85                 :            : static basic_block block_fallthru (basic_block);
      86                 :            : static rtx cond_exec_get_condition (rtx_insn *);
      87                 :            : static rtx noce_get_condition (rtx_insn *, rtx_insn **, bool);
      88                 :            : static int noce_operand_ok (const_rtx);
      89                 :            : static void merge_if_block (ce_if_block *);
      90                 :            : static int find_cond_trap (basic_block, edge, edge);
      91                 :            : static basic_block find_if_header (basic_block, int);
      92                 :            : static int block_jumps_and_fallthru_p (basic_block, basic_block);
      93                 :            : static int noce_find_if_block (basic_block, edge, edge, int);
      94                 :            : static int cond_exec_find_if_block (ce_if_block *);
      95                 :            : static int find_if_case_1 (basic_block, edge, edge);
      96                 :            : static int find_if_case_2 (basic_block, edge, edge);
      97                 :            : static int dead_or_predicable (basic_block, basic_block, basic_block,
      98                 :            :                                edge, int);
      99                 :            : static void noce_emit_move_insn (rtx, rtx);
     100                 :            : static rtx_insn *block_has_only_trap (basic_block);
     101                 :            : 
     102                 :            : /* Count the number of non-jump active insns in BB.  */
     103                 :            : 
     104                 :            : static int
     105                 :          0 : count_bb_insns (const_basic_block bb)
     106                 :            : {
     107                 :          0 :   int count = 0;
     108                 :          0 :   rtx_insn *insn = BB_HEAD (bb);
     109                 :            : 
     110                 :          0 :   while (1)
     111                 :            :     {
     112                 :          0 :       if (active_insn_p (insn) && !JUMP_P (insn))
     113                 :          0 :         count++;
     114                 :            : 
     115                 :          0 :       if (insn == BB_END (bb))
     116                 :            :         break;
     117                 :          0 :       insn = NEXT_INSN (insn);
     118                 :            :     }
     119                 :            : 
     120                 :          0 :   return count;
     121                 :            : }
     122                 :            : 
     123                 :            : /* Determine whether the total insn_cost on non-jump insns in
     124                 :            :    basic block BB is less than MAX_COST.  This function returns
     125                 :            :    false if the cost of any instruction could not be estimated. 
     126                 :            : 
     127                 :            :    The cost of the non-jump insns in BB is scaled by REG_BR_PROB_BASE
     128                 :            :    as those insns are being speculated.  MAX_COST is scaled with SCALE
     129                 :            :    plus a small fudge factor.  */
     130                 :            : 
     131                 :            : static bool
     132                 :    2257660 : cheap_bb_rtx_cost_p (const_basic_block bb,
     133                 :            :                      profile_probability prob, int max_cost)
     134                 :            : {
     135                 :    2257660 :   int count = 0;
     136                 :    2257660 :   rtx_insn *insn = BB_HEAD (bb);
     137                 :    2257660 :   bool speed = optimize_bb_for_speed_p (bb);
     138                 :    2257660 :   int scale = prob.initialized_p () ? prob.to_reg_br_prob_base ()
     139                 :    2257660 :               : REG_BR_PROB_BASE;
     140                 :            : 
     141                 :            :   /* Set scale to REG_BR_PROB_BASE to void the identical scaling
     142                 :            :      applied to insn_cost when optimizing for size.  Only do
     143                 :            :      this after combine because if-conversion might interfere with
     144                 :            :      passes before combine.
     145                 :            : 
     146                 :            :      Use optimize_function_for_speed_p instead of the pre-defined
     147                 :            :      variable speed to make sure it is set to same value for all
     148                 :            :      basic blocks in one if-conversion transformation.  */
     149                 :    2257660 :   if (!optimize_function_for_speed_p (cfun) && ifcvt_after_combine)
     150                 :            :     scale = REG_BR_PROB_BASE;
     151                 :            :   /* Our branch probability/scaling factors are just estimates and don't
     152                 :            :      account for cases where we can get speculation for free and other
     153                 :            :      secondary benefits.  So we fudge the scale factor to make speculating
     154                 :            :      appear a little more profitable when optimizing for performance.  */
     155                 :            :   else
     156                 :    2215040 :     scale += REG_BR_PROB_BASE / 8;
     157                 :            : 
     158                 :            : 
     159                 :    2257660 :   max_cost *= scale;
     160                 :            : 
     161                 :    7926000 :   while (1)
     162                 :            :     {
     163                 :   10183700 :       if (NONJUMP_INSN_P (insn))
     164                 :            :         {
     165                 :    3278080 :           int cost = insn_cost (insn, speed) * REG_BR_PROB_BASE;
     166                 :    3278080 :           if (cost == 0)
     167                 :            :             return false;
     168                 :            : 
     169                 :            :           /* If this instruction is the load or set of a "stack" register,
     170                 :            :              such as a floating point register on x87, then the cost of
     171                 :            :              speculatively executing this insn may need to include
     172                 :            :              the additional cost of popping its result off of the
     173                 :            :              register stack.  Unfortunately, correctly recognizing and
     174                 :            :              accounting for this additional overhead is tricky, so for
     175                 :            :              now we simply prohibit such speculative execution.  */
     176                 :            : #ifdef STACK_REGS
     177                 :    3243170 :           {
     178                 :    3243170 :             rtx set = single_set (insn);
     179                 :    3243170 :             if (set && STACK_REG_P (SET_DEST (set)))
     180                 :            :               return false;
     181                 :            :           }
     182                 :            : #endif
     183                 :            : 
     184                 :    3239460 :           count += cost;
     185                 :    3239460 :           if (count >= max_cost)
     186                 :            :             return false;
     187                 :            :         }
     188                 :    6905580 :       else if (CALL_P (insn))
     189                 :            :         return false;
     190                 :            : 
     191                 :    8352790 :       if (insn == BB_END (bb))
     192                 :            :         break;
     193                 :    7926000 :       insn = NEXT_INSN (insn);
     194                 :    7926000 :     }
     195                 :            : 
     196                 :            :   return true;
     197                 :            : }
     198                 :            : 
     199                 :            : /* Return the first non-jump active insn in the basic block.  */
     200                 :            : 
     201                 :            : static rtx_insn *
     202                 :    1156640 : first_active_insn (basic_block bb)
     203                 :            : {
     204                 :    1156640 :   rtx_insn *insn = BB_HEAD (bb);
     205                 :            : 
     206                 :    1156640 :   if (LABEL_P (insn))
     207                 :            :     {
     208                 :     208241 :       if (insn == BB_END (bb))
     209                 :            :         return NULL;
     210                 :     208241 :       insn = NEXT_INSN (insn);
     211                 :            :     }
     212                 :            : 
     213                 :    3472250 :   while (NOTE_P (insn) || DEBUG_INSN_P (insn))
     214                 :            :     {
     215                 :    2315610 :       if (insn == BB_END (bb))
     216                 :            :         return NULL;
     217                 :    2315610 :       insn = NEXT_INSN (insn);
     218                 :            :     }
     219                 :            : 
     220                 :    1156640 :   if (JUMP_P (insn))
     221                 :          0 :     return NULL;
     222                 :            : 
     223                 :            :   return insn;
     224                 :            : }
     225                 :            : 
     226                 :            : /* Return the last non-jump active (non-jump) insn in the basic block.  */
     227                 :            : 
     228                 :            : static rtx_insn *
     229                 :    1919520 : last_active_insn (basic_block bb, int skip_use_p)
     230                 :            : {
     231                 :    1919520 :   rtx_insn *insn = BB_END (bb);
     232                 :    1919520 :   rtx_insn *head = BB_HEAD (bb);
     233                 :            : 
     234                 :    3231440 :   while (NOTE_P (insn)
     235                 :    3231440 :          || JUMP_P (insn)
     236                 :    3218450 :          || DEBUG_INSN_P (insn)
     237                 :    5142220 :          || (skip_use_p
     238                 :          0 :              && NONJUMP_INSN_P (insn)
     239                 :          0 :              && GET_CODE (PATTERN (insn)) == USE))
     240                 :            :     {
     241                 :    1320660 :       if (insn == head)
     242                 :            :         return NULL;
     243                 :    1311920 :       insn = PREV_INSN (insn);
     244                 :            :     }
     245                 :            : 
     246                 :    1910780 :   if (LABEL_P (insn))
     247                 :         47 :     return NULL;
     248                 :            : 
     249                 :            :   return insn;
     250                 :            : }
     251                 :            : 
     252                 :            : /* Return the active insn before INSN inside basic block CURR_BB. */
     253                 :            : 
     254                 :            : static rtx_insn *
     255                 :          0 : find_active_insn_before (basic_block curr_bb, rtx_insn *insn)
     256                 :            : {
     257                 :          0 :   if (!insn || insn == BB_HEAD (curr_bb))
     258                 :            :     return NULL;
     259                 :            : 
     260                 :          0 :   while ((insn = PREV_INSN (insn)) != NULL_RTX)
     261                 :            :     {
     262                 :          0 :       if (NONJUMP_INSN_P (insn) || JUMP_P (insn) || CALL_P (insn))
     263                 :            :         break;
     264                 :            : 
     265                 :            :       /* No other active insn all the way to the start of the basic block. */
     266                 :          0 :       if (insn == BB_HEAD (curr_bb))
     267                 :            :         return NULL;
     268                 :            :     }
     269                 :            : 
     270                 :            :   return insn;
     271                 :            : }
     272                 :            : 
     273                 :            : /* Return the active insn after INSN inside basic block CURR_BB. */
     274                 :            : 
     275                 :            : static rtx_insn *
     276                 :          0 : find_active_insn_after (basic_block curr_bb, rtx_insn *insn)
     277                 :            : {
     278                 :          0 :   if (!insn || insn == BB_END (curr_bb))
     279                 :            :     return NULL;
     280                 :            : 
     281                 :          0 :   while ((insn = NEXT_INSN (insn)) != NULL_RTX)
     282                 :            :     {
     283                 :          0 :       if (NONJUMP_INSN_P (insn) || JUMP_P (insn) || CALL_P (insn))
     284                 :            :         break;
     285                 :            : 
     286                 :            :       /* No other active insn all the way to the end of the basic block. */
     287                 :          0 :       if (insn == BB_END (curr_bb))
     288                 :            :         return NULL;
     289                 :            :     }
     290                 :            : 
     291                 :            :   return insn;
     292                 :            : }
     293                 :            : 
     294                 :            : /* Return the basic block reached by falling though the basic block BB.  */
     295                 :            : 
     296                 :            : static basic_block
     297                 :          0 : block_fallthru (basic_block bb)
     298                 :            : {
     299                 :          0 :   edge e = find_fallthru_edge (bb->succs);
     300                 :            : 
     301                 :          0 :   return (e) ? e->dest : NULL_BLOCK;
     302                 :            : }
     303                 :            : 
     304                 :            : /* Return true if RTXs A and B can be safely interchanged.  */
     305                 :            : 
     306                 :            : static bool
     307                 :     365794 : rtx_interchangeable_p (const_rtx a, const_rtx b)
     308                 :            : {
     309                 :     365794 :   if (!rtx_equal_p (a, b))
     310                 :            :     return false;
     311                 :            : 
     312                 :     125340 :   if (GET_CODE (a) != MEM)
     313                 :            :     return true;
     314                 :            : 
     315                 :            :   /* A dead type-unsafe memory reference is legal, but a live type-unsafe memory
     316                 :            :      reference is not.  Interchanging a dead type-unsafe memory reference with
     317                 :            :      a live type-safe one creates a live type-unsafe memory reference, in other
     318                 :            :      words, it makes the program illegal.
     319                 :            :      We check here conservatively whether the two memory references have equal
     320                 :            :      memory attributes.  */
     321                 :            : 
     322                 :       3912 :   return mem_attrs_eq_p (get_mem_attrs (a), get_mem_attrs (b));
     323                 :            : }
     324                 :            : 
     325                 :            : 
     326                 :            : /* Go through a bunch of insns, converting them to conditional
     327                 :            :    execution format if possible.  Return TRUE if all of the non-note
     328                 :            :    insns were processed.  */
     329                 :            : 
     330                 :            : static int
     331                 :          0 : cond_exec_process_insns (ce_if_block *ce_info ATTRIBUTE_UNUSED,
     332                 :            :                          /* if block information */rtx_insn *start,
     333                 :            :                          /* first insn to look at */rtx end,
     334                 :            :                          /* last insn to look at */rtx test,
     335                 :            :                          /* conditional execution test */profile_probability
     336                 :            :                                                             prob_val,
     337                 :            :                          /* probability of branch taken. */int mod_ok)
     338                 :            : {
     339                 :          0 :   int must_be_last = FALSE;
     340                 :          0 :   rtx_insn *insn;
     341                 :          0 :   rtx xtest;
     342                 :          0 :   rtx pattern;
     343                 :            : 
     344                 :          0 :   if (!start || !end)
     345                 :            :     return FALSE;
     346                 :            : 
     347                 :          0 :   for (insn = start; ; insn = NEXT_INSN (insn))
     348                 :            :     {
     349                 :            :       /* dwarf2out can't cope with conditional prologues.  */
     350                 :          0 :       if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_PROLOGUE_END)
     351                 :            :         return FALSE;
     352                 :            : 
     353                 :          0 :       if (NOTE_P (insn) || DEBUG_INSN_P (insn))
     354                 :          0 :         goto insn_done;
     355                 :            : 
     356                 :          0 :       gcc_assert (NONJUMP_INSN_P (insn) || CALL_P (insn));
     357                 :            : 
     358                 :            :       /* dwarf2out can't cope with conditional unwind info.  */
     359                 :          0 :       if (RTX_FRAME_RELATED_P (insn))
     360                 :            :         return FALSE;
     361                 :            : 
     362                 :            :       /* Remove USE insns that get in the way.  */
     363                 :          0 :       if (reload_completed && GET_CODE (PATTERN (insn)) == USE)
     364                 :            :         {
     365                 :            :           /* ??? Ug.  Actually unlinking the thing is problematic,
     366                 :            :              given what we'd have to coordinate with our callers.  */
     367                 :          0 :           SET_INSN_DELETED (insn);
     368                 :          0 :           goto insn_done;
     369                 :            :         }
     370                 :            : 
     371                 :            :       /* Last insn wasn't last?  */
     372                 :          0 :       if (must_be_last)
     373                 :            :         return FALSE;
     374                 :            : 
     375                 :          0 :       if (modified_in_p (test, insn))
     376                 :            :         {
     377                 :          0 :           if (!mod_ok)
     378                 :            :             return FALSE;
     379                 :            :           must_be_last = TRUE;
     380                 :            :         }
     381                 :            : 
     382                 :            :       /* Now build the conditional form of the instruction.  */
     383                 :          0 :       pattern = PATTERN (insn);
     384                 :          0 :       xtest = copy_rtx (test);
     385                 :            : 
     386                 :            :       /* If this is already a COND_EXEC, rewrite the test to be an AND of the
     387                 :            :          two conditions.  */
     388                 :          0 :       if (GET_CODE (pattern) == COND_EXEC)
     389                 :            :         {
     390                 :          0 :           if (GET_MODE (xtest) != GET_MODE (COND_EXEC_TEST (pattern)))
     391                 :            :             return FALSE;
     392                 :            : 
     393                 :          0 :           xtest = gen_rtx_AND (GET_MODE (xtest), xtest,
     394                 :            :                                COND_EXEC_TEST (pattern));
     395                 :          0 :           pattern = COND_EXEC_CODE (pattern);
     396                 :            :         }
     397                 :            : 
     398                 :          0 :       pattern = gen_rtx_COND_EXEC (VOIDmode, xtest, pattern);
     399                 :            : 
     400                 :            :       /* If the machine needs to modify the insn being conditionally executed,
     401                 :            :          say for example to force a constant integer operand into a temp
     402                 :            :          register, do so here.  */
     403                 :            : #ifdef IFCVT_MODIFY_INSN
     404                 :            :       IFCVT_MODIFY_INSN (ce_info, pattern, insn);
     405                 :            :       if (! pattern)
     406                 :            :         return FALSE;
     407                 :            : #endif
     408                 :            : 
     409                 :          0 :       validate_change (insn, &PATTERN (insn), pattern, 1);
     410                 :            : 
     411                 :          0 :       if (CALL_P (insn) && prob_val.initialized_p ())
     412                 :          0 :         validate_change (insn, &REG_NOTES (insn),
     413                 :            :                          gen_rtx_INT_LIST ((machine_mode) REG_BR_PROB,
     414                 :            :                                            prob_val.to_reg_br_prob_note (),
     415                 :            :                                            REG_NOTES (insn)), 1);
     416                 :            : 
     417                 :          0 :     insn_done:
     418                 :          0 :       if (insn == end)
     419                 :            :         break;
     420                 :          0 :     }
     421                 :            : 
     422                 :            :   return TRUE;
     423                 :            : }
     424                 :            : 
     425                 :            : /* Return the condition for a jump.  Do not do any special processing.  */
     426                 :            : 
     427                 :            : static rtx
     428                 :          0 : cond_exec_get_condition (rtx_insn *jump)
     429                 :            : {
     430                 :          0 :   rtx test_if, cond;
     431                 :            : 
     432                 :          0 :   if (any_condjump_p (jump))
     433                 :          0 :     test_if = SET_SRC (pc_set (jump));
     434                 :            :   else
     435                 :            :     return NULL_RTX;
     436                 :          0 :   cond = XEXP (test_if, 0);
     437                 :            : 
     438                 :            :   /* If this branches to JUMP_LABEL when the condition is false,
     439                 :            :      reverse the condition.  */
     440                 :          0 :   if (GET_CODE (XEXP (test_if, 2)) == LABEL_REF
     441                 :          0 :       && label_ref_label (XEXP (test_if, 2)) == JUMP_LABEL (jump))
     442                 :            :     {
     443                 :          0 :       enum rtx_code rev = reversed_comparison_code (cond, jump);
     444                 :          0 :       if (rev == UNKNOWN)
     445                 :            :         return NULL_RTX;
     446                 :            : 
     447                 :          0 :       cond = gen_rtx_fmt_ee (rev, GET_MODE (cond), XEXP (cond, 0),
     448                 :            :                              XEXP (cond, 1));
     449                 :            :     }
     450                 :            : 
     451                 :            :   return cond;
     452                 :            : }
     453                 :            : 
     454                 :            : /* Given a simple IF-THEN or IF-THEN-ELSE block, attempt to convert it
     455                 :            :    to conditional execution.  Return TRUE if we were successful at
     456                 :            :    converting the block.  */
     457                 :            : 
     458                 :            : static int
     459                 :          0 : cond_exec_process_if_block (ce_if_block * ce_info,
     460                 :            :                             /* if block information */int do_multiple_p)
     461                 :            : {
     462                 :          0 :   basic_block test_bb = ce_info->test_bb;    /* last test block */
     463                 :          0 :   basic_block then_bb = ce_info->then_bb;    /* THEN */
     464                 :          0 :   basic_block else_bb = ce_info->else_bb;    /* ELSE or NULL */
     465                 :          0 :   rtx test_expr;                /* expression in IF_THEN_ELSE that is tested */
     466                 :          0 :   rtx_insn *then_start;         /* first insn in THEN block */
     467                 :          0 :   rtx_insn *then_end;           /* last insn + 1 in THEN block */
     468                 :          0 :   rtx_insn *else_start = NULL;  /* first insn in ELSE block or NULL */
     469                 :          0 :   rtx_insn *else_end = NULL;    /* last insn + 1 in ELSE block */
     470                 :          0 :   int max;                      /* max # of insns to convert.  */
     471                 :          0 :   int then_mod_ok;              /* whether conditional mods are ok in THEN */
     472                 :          0 :   rtx true_expr;                /* test for else block insns */
     473                 :          0 :   rtx false_expr;               /* test for then block insns */
     474                 :          0 :   profile_probability true_prob_val;/* probability of else block */
     475                 :          0 :   profile_probability false_prob_val;/* probability of then block */
     476                 :          0 :   rtx_insn *then_last_head = NULL;      /* Last match at the head of THEN */
     477                 :          0 :   rtx_insn *else_last_head = NULL;      /* Last match at the head of ELSE */
     478                 :          0 :   rtx_insn *then_first_tail = NULL;     /* First match at the tail of THEN */
     479                 :          0 :   rtx_insn *else_first_tail = NULL;     /* First match at the tail of ELSE */
     480                 :          0 :   int then_n_insns, else_n_insns, n_insns;
     481                 :          0 :   enum rtx_code false_code;
     482                 :          0 :   rtx note;
     483                 :            : 
     484                 :            :   /* If test is comprised of && or || elements, and we've failed at handling
     485                 :            :      all of them together, just use the last test if it is the special case of
     486                 :            :      && elements without an ELSE block.  */
     487                 :          0 :   if (!do_multiple_p && ce_info->num_multiple_test_blocks)
     488                 :            :     {
     489                 :          0 :       if (else_bb || ! ce_info->and_and_p)
     490                 :            :         return FALSE;
     491                 :            : 
     492                 :          0 :       ce_info->test_bb = test_bb = ce_info->last_test_bb;
     493                 :          0 :       ce_info->num_multiple_test_blocks = 0;
     494                 :          0 :       ce_info->num_and_and_blocks = 0;
     495                 :          0 :       ce_info->num_or_or_blocks = 0;
     496                 :            :     }
     497                 :            : 
     498                 :            :   /* Find the conditional jump to the ELSE or JOIN part, and isolate
     499                 :            :      the test.  */
     500                 :          0 :   test_expr = cond_exec_get_condition (BB_END (test_bb));
     501                 :          0 :   if (! test_expr)
     502                 :            :     return FALSE;
     503                 :            : 
     504                 :            :   /* If the conditional jump is more than just a conditional jump,
     505                 :            :      then we cannot do conditional execution conversion on this block.  */
     506                 :          0 :   if (! onlyjump_p (BB_END (test_bb)))
     507                 :            :     return FALSE;
     508                 :            : 
     509                 :            :   /* Collect the bounds of where we're to search, skipping any labels, jumps
     510                 :            :      and notes at the beginning and end of the block.  Then count the total
     511                 :            :      number of insns and see if it is small enough to convert.  */
     512                 :          0 :   then_start = first_active_insn (then_bb);
     513                 :          0 :   then_end = last_active_insn (then_bb, TRUE);
     514                 :          0 :   then_n_insns = ce_info->num_then_insns = count_bb_insns (then_bb);
     515                 :          0 :   n_insns = then_n_insns;
     516                 :          0 :   max = MAX_CONDITIONAL_EXECUTE;
     517                 :            : 
     518                 :          0 :   if (else_bb)
     519                 :            :     {
     520                 :          0 :       int n_matching;
     521                 :            : 
     522                 :          0 :       max *= 2;
     523                 :          0 :       else_start = first_active_insn (else_bb);
     524                 :          0 :       else_end = last_active_insn (else_bb, TRUE);
     525                 :          0 :       else_n_insns = ce_info->num_else_insns = count_bb_insns (else_bb);
     526                 :          0 :       n_insns += else_n_insns;
     527                 :            : 
     528                 :            :       /* Look for matching sequences at the head and tail of the two blocks,
     529                 :            :          and limit the range of insns to be converted if possible.  */
     530                 :          0 :       n_matching = flow_find_cross_jump (then_bb, else_bb,
     531                 :            :                                          &then_first_tail, &else_first_tail,
     532                 :            :                                          NULL);
     533                 :          0 :       if (then_first_tail == BB_HEAD (then_bb))
     534                 :          0 :         then_start = then_end = NULL;
     535                 :          0 :       if (else_first_tail == BB_HEAD (else_bb))
     536                 :          0 :         else_start = else_end = NULL;
     537                 :            : 
     538                 :          0 :       if (n_matching > 0)
     539                 :            :         {
     540                 :          0 :           if (then_end)
     541                 :          0 :             then_end = find_active_insn_before (then_bb, then_first_tail);
     542                 :          0 :           if (else_end)
     543                 :          0 :             else_end = find_active_insn_before (else_bb, else_first_tail);
     544                 :          0 :           n_insns -= 2 * n_matching;
     545                 :            :         }
     546                 :            : 
     547                 :          0 :       if (then_start
     548                 :          0 :           && else_start
     549                 :            :           && then_n_insns > n_matching
     550                 :          0 :           && else_n_insns > n_matching)
     551                 :            :         {
     552                 :          0 :           int longest_match = MIN (then_n_insns - n_matching,
     553                 :            :                                    else_n_insns - n_matching);
     554                 :          0 :           n_matching
     555                 :          0 :             = flow_find_head_matching_sequence (then_bb, else_bb,
     556                 :            :                                                 &then_last_head,
     557                 :            :                                                 &else_last_head,
     558                 :            :                                                 longest_match);
     559                 :            : 
     560                 :          0 :           if (n_matching > 0)
     561                 :            :             {
     562                 :          0 :               rtx_insn *insn;
     563                 :            : 
     564                 :            :               /* We won't pass the insns in the head sequence to
     565                 :            :                  cond_exec_process_insns, so we need to test them here
     566                 :            :                  to make sure that they don't clobber the condition.  */
     567                 :          0 :               for (insn = BB_HEAD (then_bb);
     568                 :          0 :                    insn != NEXT_INSN (then_last_head);
     569                 :          0 :                    insn = NEXT_INSN (insn))
     570                 :          0 :                 if (!LABEL_P (insn) && !NOTE_P (insn)
     571                 :          0 :                     && !DEBUG_INSN_P (insn)
     572                 :          0 :                     && modified_in_p (test_expr, insn))
     573                 :            :                   return FALSE;
     574                 :            :             }
     575                 :            : 
     576                 :          0 :           if (then_last_head == then_end)
     577                 :          0 :             then_start = then_end = NULL;
     578                 :          0 :           if (else_last_head == else_end)
     579                 :          0 :             else_start = else_end = NULL;
     580                 :            : 
     581                 :          0 :           if (n_matching > 0)
     582                 :            :             {
     583                 :          0 :               if (then_start)
     584                 :          0 :                 then_start = find_active_insn_after (then_bb, then_last_head);
     585                 :          0 :               if (else_start)
     586                 :          0 :                 else_start = find_active_insn_after (else_bb, else_last_head);
     587                 :          0 :               n_insns -= 2 * n_matching;
     588                 :            :             }
     589                 :            :         }
     590                 :            :     }
     591                 :            : 
     592                 :          0 :   if (n_insns > max)
     593                 :            :     return FALSE;
     594                 :            : 
     595                 :            :   /* Map test_expr/test_jump into the appropriate MD tests to use on
     596                 :            :      the conditionally executed code.  */
     597                 :            : 
     598                 :          0 :   true_expr = test_expr;
     599                 :            : 
     600                 :          0 :   false_code = reversed_comparison_code (true_expr, BB_END (test_bb));
     601                 :          0 :   if (false_code != UNKNOWN)
     602                 :          0 :     false_expr = gen_rtx_fmt_ee (false_code, GET_MODE (true_expr),
     603                 :            :                                  XEXP (true_expr, 0), XEXP (true_expr, 1));
     604                 :            :   else
     605                 :            :     false_expr = NULL_RTX;
     606                 :            : 
     607                 :            : #ifdef IFCVT_MODIFY_TESTS
     608                 :            :   /* If the machine description needs to modify the tests, such as setting a
     609                 :            :      conditional execution register from a comparison, it can do so here.  */
     610                 :            :   IFCVT_MODIFY_TESTS (ce_info, true_expr, false_expr);
     611                 :            : 
     612                 :            :   /* See if the conversion failed.  */
     613                 :            :   if (!true_expr || !false_expr)
     614                 :            :     goto fail;
     615                 :            : #endif
     616                 :            : 
     617                 :          0 :   note = find_reg_note (BB_END (test_bb), REG_BR_PROB, NULL_RTX);
     618                 :          0 :   if (note)
     619                 :            :     {
     620                 :          0 :       true_prob_val = profile_probability::from_reg_br_prob_note (XINT (note, 0));
     621                 :          0 :       false_prob_val = true_prob_val.invert ();
     622                 :            :     }
     623                 :            :   else
     624                 :            :     {
     625                 :          0 :       true_prob_val = profile_probability::uninitialized ();
     626                 :          0 :       false_prob_val = profile_probability::uninitialized ();
     627                 :            :     }
     628                 :            : 
     629                 :            :   /* If we have && or || tests, do them here.  These tests are in the adjacent
     630                 :            :      blocks after the first block containing the test.  */
     631                 :          0 :   if (ce_info->num_multiple_test_blocks > 0)
     632                 :            :     {
     633                 :          0 :       basic_block bb = test_bb;
     634                 :          0 :       basic_block last_test_bb = ce_info->last_test_bb;
     635                 :            : 
     636                 :          0 :       if (! false_expr)
     637                 :          0 :         goto fail;
     638                 :            : 
     639                 :          0 :       do
     640                 :            :         {
     641                 :          0 :           rtx_insn *start, *end;
     642                 :          0 :           rtx t, f;
     643                 :          0 :           enum rtx_code f_code;
     644                 :            : 
     645                 :          0 :           bb = block_fallthru (bb);
     646                 :          0 :           start = first_active_insn (bb);
     647                 :          0 :           end = last_active_insn (bb, TRUE);
     648                 :          0 :           if (start
     649                 :          0 :               && ! cond_exec_process_insns (ce_info, start, end, false_expr,
     650                 :            :                                             false_prob_val, FALSE))
     651                 :          0 :             goto fail;
     652                 :            : 
     653                 :            :           /* If the conditional jump is more than just a conditional jump, then
     654                 :            :              we cannot do conditional execution conversion on this block.  */
     655                 :          0 :           if (! onlyjump_p (BB_END (bb)))
     656                 :          0 :             goto fail;
     657                 :            : 
     658                 :            :           /* Find the conditional jump and isolate the test.  */
     659                 :          0 :           t = cond_exec_get_condition (BB_END (bb));
     660                 :          0 :           if (! t)
     661                 :          0 :             goto fail;
     662                 :            : 
     663                 :          0 :           f_code = reversed_comparison_code (t, BB_END (bb));
     664                 :          0 :           if (f_code == UNKNOWN)
     665                 :          0 :             goto fail;
     666                 :            : 
     667                 :          0 :           f = gen_rtx_fmt_ee (f_code, GET_MODE (t), XEXP (t, 0), XEXP (t, 1));
     668                 :          0 :           if (ce_info->and_and_p)
     669                 :            :             {
     670                 :          0 :               t = gen_rtx_AND (GET_MODE (t), true_expr, t);
     671                 :          0 :               f = gen_rtx_IOR (GET_MODE (t), false_expr, f);
     672                 :            :             }
     673                 :            :           else
     674                 :            :             {
     675                 :          0 :               t = gen_rtx_IOR (GET_MODE (t), true_expr, t);
     676                 :          0 :               f = gen_rtx_AND (GET_MODE (t), false_expr, f);
     677                 :            :             }
     678                 :            : 
     679                 :            :           /* If the machine description needs to modify the tests, such as
     680                 :            :              setting a conditional execution register from a comparison, it can
     681                 :            :              do so here.  */
     682                 :            : #ifdef IFCVT_MODIFY_MULTIPLE_TESTS
     683                 :            :           IFCVT_MODIFY_MULTIPLE_TESTS (ce_info, bb, t, f);
     684                 :            : 
     685                 :            :           /* See if the conversion failed.  */
     686                 :            :           if (!t || !f)
     687                 :            :             goto fail;
     688                 :            : #endif
     689                 :            : 
     690                 :          0 :           true_expr = t;
     691                 :          0 :           false_expr = f;
     692                 :            :         }
     693                 :          0 :       while (bb != last_test_bb);
     694                 :            :     }
     695                 :            : 
     696                 :            :   /* For IF-THEN-ELSE blocks, we don't allow modifications of the test
     697                 :            :      on then THEN block.  */
     698                 :          0 :   then_mod_ok = (else_bb == NULL_BLOCK);
     699                 :            : 
     700                 :            :   /* Go through the THEN and ELSE blocks converting the insns if possible
     701                 :            :      to conditional execution.  */
     702                 :            : 
     703                 :          0 :   if (then_end
     704                 :          0 :       && (! false_expr
     705                 :          0 :           || ! cond_exec_process_insns (ce_info, then_start, then_end,
     706                 :            :                                         false_expr, false_prob_val,
     707                 :            :                                         then_mod_ok)))
     708                 :          0 :     goto fail;
     709                 :            : 
     710                 :          0 :   if (else_bb && else_end
     711                 :          0 :       && ! cond_exec_process_insns (ce_info, else_start, else_end,
     712                 :            :                                     true_expr, true_prob_val, TRUE))
     713                 :          0 :     goto fail;
     714                 :            : 
     715                 :            :   /* If we cannot apply the changes, fail.  Do not go through the normal fail
     716                 :            :      processing, since apply_change_group will call cancel_changes.  */
     717                 :          0 :   if (! apply_change_group ())
     718                 :            :     {
     719                 :            : #ifdef IFCVT_MODIFY_CANCEL
     720                 :            :       /* Cancel any machine dependent changes.  */
     721                 :            :       IFCVT_MODIFY_CANCEL (ce_info);
     722                 :            : #endif
     723                 :            :       return FALSE;
     724                 :            :     }
     725                 :            : 
     726                 :            : #ifdef IFCVT_MODIFY_FINAL
     727                 :            :   /* Do any machine dependent final modifications.  */
     728                 :            :   IFCVT_MODIFY_FINAL (ce_info);
     729                 :            : #endif
     730                 :            : 
     731                 :            :   /* Conversion succeeded.  */
     732                 :          0 :   if (dump_file)
     733                 :          0 :     fprintf (dump_file, "%d insn%s converted to conditional execution.\n",
     734                 :            :              n_insns, (n_insns == 1) ? " was" : "s were");
     735                 :            : 
     736                 :            :   /* Merge the blocks!  If we had matching sequences, make sure to delete one
     737                 :            :      copy at the appropriate location first: delete the copy in the THEN branch
     738                 :            :      for a tail sequence so that the remaining one is executed last for both
     739                 :            :      branches, and delete the copy in the ELSE branch for a head sequence so
     740                 :            :      that the remaining one is executed first for both branches.  */
     741                 :          0 :   if (then_first_tail)
     742                 :            :     {
     743                 :          0 :       rtx_insn *from = then_first_tail;
     744                 :          0 :       if (!INSN_P (from))
     745                 :          0 :         from = find_active_insn_after (then_bb, from);
     746                 :          0 :       delete_insn_chain (from, get_last_bb_insn (then_bb), false);
     747                 :            :     }
     748                 :          0 :   if (else_last_head)
     749                 :          0 :     delete_insn_chain (first_active_insn (else_bb), else_last_head, false);
     750                 :            : 
     751                 :          0 :   merge_if_block (ce_info);
     752                 :          0 :   cond_exec_changed_p = TRUE;
     753                 :          0 :   return TRUE;
     754                 :            : 
     755                 :          0 :  fail:
     756                 :            : #ifdef IFCVT_MODIFY_CANCEL
     757                 :            :   /* Cancel any machine dependent changes.  */
     758                 :            :   IFCVT_MODIFY_CANCEL (ce_info);
     759                 :            : #endif
     760                 :            : 
     761                 :          0 :   cancel_changes (0);
     762                 :          0 :   return FALSE;
     763                 :            : }
     764                 :            : 
     765                 :            : static rtx noce_emit_store_flag (struct noce_if_info *, rtx, int, int);
     766                 :            : static int noce_try_move (struct noce_if_info *);
     767                 :            : static int noce_try_ifelse_collapse (struct noce_if_info *);
     768                 :            : static int noce_try_store_flag (struct noce_if_info *);
     769                 :            : static int noce_try_addcc (struct noce_if_info *);
     770                 :            : static int noce_try_store_flag_constants (struct noce_if_info *);
     771                 :            : static int noce_try_store_flag_mask (struct noce_if_info *);
     772                 :            : static rtx noce_emit_cmove (struct noce_if_info *, rtx, enum rtx_code, rtx,
     773                 :            :                             rtx, rtx, rtx);
     774                 :            : static int noce_try_cmove (struct noce_if_info *);
     775                 :            : static int noce_try_cmove_arith (struct noce_if_info *);
     776                 :            : static rtx noce_get_alt_condition (struct noce_if_info *, rtx, rtx_insn **);
     777                 :            : static int noce_try_minmax (struct noce_if_info *);
     778                 :            : static int noce_try_abs (struct noce_if_info *);
     779                 :            : static int noce_try_sign_mask (struct noce_if_info *);
     780                 :            : 
     781                 :            : /* Return the comparison code for reversed condition for IF_INFO,
     782                 :            :    or UNKNOWN if reversing the condition is not possible.  */
     783                 :            : 
     784                 :            : static inline enum rtx_code
     785                 :     269728 : noce_reversed_cond_code (struct noce_if_info *if_info)
     786                 :            : {
     787                 :     160486 :   if (if_info->rev_cond)
     788                 :     269728 :     return GET_CODE (if_info->rev_cond);
     789                 :          0 :   return reversed_comparison_code (if_info->cond, if_info->jump);
     790                 :            : }
     791                 :            : 
     792                 :            : /* Return true if SEQ is a good candidate as a replacement for the
     793                 :            :    if-convertible sequence described in IF_INFO.
     794                 :            :    This is the default implementation that targets can override
     795                 :            :    through a target hook.  */
     796                 :            : 
     797                 :            : bool
     798                 :     133847 : default_noce_conversion_profitable_p (rtx_insn *seq,
     799                 :            :                                       struct noce_if_info *if_info)
     800                 :            : {
     801                 :     133847 :   bool speed_p = if_info->speed_p;
     802                 :            : 
     803                 :            :   /* Cost up the new sequence.  */
     804                 :     133847 :   unsigned int cost = seq_cost (seq, speed_p);
     805                 :            : 
     806                 :     133847 :   if (cost <= if_info->original_cost)
     807                 :            :     return true;
     808                 :            : 
     809                 :            :   /* When compiling for size, we can make a reasonably accurately guess
     810                 :            :      at the size growth.  When compiling for speed, use the maximum.  */
     811                 :     126647 :   return speed_p && cost <= if_info->max_seq_cost;
     812                 :            : }
     813                 :            : 
     814                 :            : /* Helper function for noce_try_store_flag*.  */
     815                 :            : 
     816                 :            : static rtx
     817                 :      28823 : noce_emit_store_flag (struct noce_if_info *if_info, rtx x, int reversep,
     818                 :            :                       int normalize)
     819                 :            : {
     820                 :      28823 :   rtx cond = if_info->cond;
     821                 :      28823 :   int cond_complex;
     822                 :      28823 :   enum rtx_code code;
     823                 :            : 
     824                 :      28823 :   cond_complex = (! general_operand (XEXP (cond, 0), VOIDmode)
     825                 :      28823 :                   || ! general_operand (XEXP (cond, 1), VOIDmode));
     826                 :            : 
     827                 :            :   /* If earliest == jump, or when the condition is complex, try to
     828                 :            :      build the store_flag insn directly.  */
     829                 :            : 
     830                 :      28823 :   if (cond_complex)
     831                 :            :     {
     832                 :      17786 :       rtx set = pc_set (if_info->jump);
     833                 :      17786 :       cond = XEXP (SET_SRC (set), 0);
     834                 :      17786 :       if (GET_CODE (XEXP (SET_SRC (set), 2)) == LABEL_REF
     835                 :      17786 :           && label_ref_label (XEXP (SET_SRC (set), 2)) == JUMP_LABEL (if_info->jump))
     836                 :          0 :         reversep = !reversep;
     837                 :      17786 :       if (if_info->then_else_reversed)
     838                 :      15404 :         reversep = !reversep;
     839                 :            :     }
     840                 :      11037 :   else if (reversep
     841                 :       8502 :            && if_info->rev_cond
     842                 :       8502 :            && general_operand (XEXP (if_info->rev_cond, 0), VOIDmode)
     843                 :      19539 :            && general_operand (XEXP (if_info->rev_cond, 1), VOIDmode))
     844                 :            :     {
     845                 :       8502 :       cond = if_info->rev_cond;
     846                 :       8502 :       reversep = false;
     847                 :            :     }
     848                 :            : 
     849                 :      28823 :   if (reversep)
     850                 :       2807 :     code = reversed_comparison_code (cond, if_info->jump);
     851                 :            :   else
     852                 :      26016 :     code = GET_CODE (cond);
     853                 :            : 
     854                 :      28823 :   if ((if_info->cond_earliest == if_info->jump || cond_complex)
     855                 :      17786 :       && (normalize == 0 || STORE_FLAG_VALUE == normalize))
     856                 :            :     {
     857                 :      14426 :       rtx src = gen_rtx_fmt_ee (code, GET_MODE (x), XEXP (cond, 0),
     858                 :            :                                 XEXP (cond, 1));
     859                 :      14426 :       rtx set = gen_rtx_SET (x, src);
     860                 :            : 
     861                 :      14426 :       start_sequence ();
     862                 :      14426 :       rtx_insn *insn = emit_insn (set);
     863                 :            : 
     864                 :      28852 :       if (recog_memoized (insn) >= 0)
     865                 :            :         {
     866                 :       8372 :           rtx_insn *seq = get_insns ();
     867                 :       8372 :           end_sequence ();
     868                 :       8372 :           emit_insn (seq);
     869                 :            : 
     870                 :       8372 :           if_info->cond_earliest = if_info->jump;
     871                 :            : 
     872                 :       8372 :           return x;
     873                 :            :         }
     874                 :            : 
     875                 :       6054 :       end_sequence ();
     876                 :            :     }
     877                 :            : 
     878                 :            :   /* Don't even try if the comparison operands or the mode of X are weird.  */
     879                 :      20451 :   if (cond_complex || !SCALAR_INT_MODE_P (GET_MODE (x)))
     880                 :            :     return NULL_RTX;
     881                 :            : 
     882                 :      11037 :   return emit_store_flag (x, code, XEXP (cond, 0),
     883                 :            :                           XEXP (cond, 1), VOIDmode,
     884                 :      11037 :                           (code == LTU || code == LEU
     885                 :      22074 :                            || code == GEU || code == GTU), normalize);
     886                 :            : }
     887                 :            : 
     888                 :            : /* Emit instruction to move an rtx, possibly into STRICT_LOW_PART.
     889                 :            :    X is the destination/target and Y is the value to copy.  */
     890                 :            : 
     891                 :            : static void
     892                 :      44906 : noce_emit_move_insn (rtx x, rtx y)
     893                 :            : {
     894                 :      44906 :   machine_mode outmode;
     895                 :      44906 :   rtx outer, inner;
     896                 :      44906 :   poly_int64 bitpos;
     897                 :            : 
     898                 :      44906 :   if (GET_CODE (x) != STRICT_LOW_PART)
     899                 :            :     {
     900                 :      44902 :       rtx_insn *seq, *insn;
     901                 :      44902 :       rtx target;
     902                 :      44902 :       optab ot;
     903                 :            : 
     904                 :      44902 :       start_sequence ();
     905                 :            :       /* Check that the SET_SRC is reasonable before calling emit_move_insn,
     906                 :            :          otherwise construct a suitable SET pattern ourselves.  */
     907                 :      15449 :       insn = (OBJECT_P (y) || CONSTANT_P (y) || GET_CODE (y) == SUBREG)
     908                 :      44917 :              ? emit_move_insn (x, y)
     909                 :      15434 :              : emit_insn (gen_rtx_SET (x, y));
     910                 :      44902 :       seq = get_insns ();
     911                 :      44902 :       end_sequence ();
     912                 :            : 
     913                 :      89804 :       if (recog_memoized (insn) <= 0)
     914                 :            :         {
     915                 :      14062 :           if (GET_CODE (x) == ZERO_EXTRACT)
     916                 :            :             {
     917                 :          0 :               rtx op = XEXP (x, 0);
     918                 :          0 :               unsigned HOST_WIDE_INT size = INTVAL (XEXP (x, 1));
     919                 :          0 :               unsigned HOST_WIDE_INT start = INTVAL (XEXP (x, 2));
     920                 :            : 
     921                 :            :               /* store_bit_field expects START to be relative to
     922                 :            :                  BYTES_BIG_ENDIAN and adjusts this value for machines with
     923                 :            :                  BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN.  In order to be able to
     924                 :            :                  invoke store_bit_field again it is necessary to have the START
     925                 :            :                  value from the first call.  */
     926                 :          0 :               if (BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
     927                 :            :                 {
     928                 :            :                   if (MEM_P (op))
     929                 :            :                     start = BITS_PER_UNIT - start - size;
     930                 :            :                   else
     931                 :            :                     {
     932                 :            :                       gcc_assert (REG_P (op));
     933                 :            :                       start = BITS_PER_WORD - start - size;
     934                 :            :                     }
     935                 :            :                 }
     936                 :            : 
     937                 :          0 :               gcc_assert (start < (MEM_P (op) ? BITS_PER_UNIT : BITS_PER_WORD));
     938                 :          0 :               store_bit_field (op, size, start, 0, 0, GET_MODE (x), y, false);
     939                 :          0 :               return;
     940                 :            :             }
     941                 :            : 
     942                 :      14062 :           switch (GET_RTX_CLASS (GET_CODE (y)))
     943                 :            :             {
     944                 :          0 :             case RTX_UNARY:
     945                 :          0 :               ot = code_to_optab (GET_CODE (y));
     946                 :          0 :               if (ot)
     947                 :            :                 {
     948                 :          0 :                   start_sequence ();
     949                 :          0 :                   target = expand_unop (GET_MODE (y), ot, XEXP (y, 0), x, 0);
     950                 :          0 :                   if (target != NULL_RTX)
     951                 :            :                     {
     952                 :          0 :                       if (target != x)
     953                 :          0 :                         emit_move_insn (x, target);
     954                 :          0 :                       seq = get_insns ();
     955                 :            :                     }
     956                 :          0 :                   end_sequence ();
     957                 :            :                 }
     958                 :            :               break;
     959                 :            : 
     960                 :          0 :             case RTX_BIN_ARITH:
     961                 :          0 :             case RTX_COMM_ARITH:
     962                 :          0 :               ot = code_to_optab (GET_CODE (y));
     963                 :          0 :               if (ot)
     964                 :            :                 {
     965                 :          0 :                   start_sequence ();
     966                 :          0 :                   target = expand_binop (GET_MODE (y), ot,
     967                 :            :                                          XEXP (y, 0), XEXP (y, 1),
     968                 :            :                                          x, 0, OPTAB_DIRECT);
     969                 :          0 :                   if (target != NULL_RTX)
     970                 :            :                     {
     971                 :          0 :                       if (target != x)
     972                 :          0 :                           emit_move_insn (x, target);
     973                 :          0 :                       seq = get_insns ();
     974                 :            :                     }
     975                 :          0 :                   end_sequence ();
     976                 :            :                 }
     977                 :            :               break;
     978                 :            : 
     979                 :            :             default:
     980                 :            :               break;
     981                 :            :             }
     982                 :            :         }
     983                 :            : 
     984                 :      44902 :       emit_insn (seq);
     985                 :      44902 :       return;
     986                 :            :     }
     987                 :            : 
     988                 :          4 :   outer = XEXP (x, 0);
     989                 :          4 :   inner = XEXP (outer, 0);
     990                 :          4 :   outmode = GET_MODE (outer);
     991                 :          4 :   bitpos = SUBREG_BYTE (outer) * BITS_PER_UNIT;
     992                 :          4 :   store_bit_field (inner, GET_MODE_BITSIZE (outmode), bitpos,
     993                 :          4 :                    0, 0, outmode, y, false);
     994                 :            : }
     995                 :            : 
     996                 :            : /* Return the CC reg if it is used in COND.  */
     997                 :            : 
     998                 :            : static rtx
     999                 :    3159430 : cc_in_cond (rtx cond)
    1000                 :            : {
    1001                 :    3159430 :   if (have_cbranchcc4 && cond
    1002                 :    3159430 :       && GET_MODE_CLASS (GET_MODE (XEXP (cond, 0))) == MODE_CC)
    1003                 :      47243 :     return XEXP (cond, 0);
    1004                 :            : 
    1005                 :            :   return NULL_RTX;
    1006                 :            : }
    1007                 :            : 
    1008                 :            : /* Return sequence of instructions generated by if conversion.  This
    1009                 :            :    function calls end_sequence() to end the current stream, ensures
    1010                 :            :    that the instructions are unshared, recognizable non-jump insns.
    1011                 :            :    On failure, this function returns a NULL_RTX.  */
    1012                 :            : 
    1013                 :            : static rtx_insn *
    1014                 :     170282 : end_ifcvt_sequence (struct noce_if_info *if_info)
    1015                 :            : {
    1016                 :     170282 :   rtx_insn *insn;
    1017                 :     170282 :   rtx_insn *seq = get_insns ();
    1018                 :     170282 :   rtx cc = cc_in_cond (if_info->cond);
    1019                 :            : 
    1020                 :     170282 :   set_used_flags (if_info->x);
    1021                 :     170282 :   set_used_flags (if_info->cond);
    1022                 :     170282 :   set_used_flags (if_info->a);
    1023                 :     170282 :   set_used_flags (if_info->b);
    1024                 :            : 
    1025                 :    1384740 :   for (insn = seq; insn; insn = NEXT_INSN (insn))
    1026                 :     607231 :     set_used_flags (insn);
    1027                 :            : 
    1028                 :     170282 :   unshare_all_rtl_in_chain (seq);
    1029                 :     170282 :   end_sequence ();
    1030                 :            : 
    1031                 :            :   /* Make sure that all of the instructions emitted are recognizable,
    1032                 :            :      and that we haven't introduced a new jump instruction.
    1033                 :            :      As an exercise for the reader, build a general mechanism that
    1034                 :            :      allows proper placement of required clobbers.  */
    1035                 :    1344360 :   for (insn = seq; insn; insn = NEXT_INSN (insn))
    1036                 :     602658 :     if (JUMP_P (insn)
    1037                 :     602658 :         || recog_memoized (insn) == -1
    1038                 :            :            /* Make sure new generated code does not clobber CC.  */
    1039                 :    1189760 :         || (cc && set_of (cc, insn)))
    1040                 :      15620 :       return NULL;
    1041                 :            : 
    1042                 :            :   return seq;
    1043                 :            : }
    1044                 :            : 
    1045                 :            : /* Return true iff the then and else basic block (if it exists)
    1046                 :            :    consist of a single simple set instruction.  */
    1047                 :            : 
    1048                 :            : static bool
    1049                 :    2317050 : noce_simple_bbs (struct noce_if_info *if_info)
    1050                 :            : {
    1051                 :          0 :   if (!if_info->then_simple)
    1052                 :            :     return false;
    1053                 :            : 
    1054                 :    2073970 :   if (if_info->else_bb)
    1055                 :          0 :     return if_info->else_simple;
    1056                 :            : 
    1057                 :            :   return true;
    1058                 :            : }
    1059                 :            : 
    1060                 :            : /* Convert "if (a != b) x = a; else x = b" into "x = a" and
    1061                 :            :    "if (a == b) x = a; else x = b" into "x = b".  */
    1062                 :            : 
    1063                 :            : static int
    1064                 :     201582 : noce_try_move (struct noce_if_info *if_info)
    1065                 :            : {
    1066                 :     201582 :   rtx cond = if_info->cond;
    1067                 :     201582 :   enum rtx_code code = GET_CODE (cond);
    1068                 :     201582 :   rtx y;
    1069                 :     201582 :   rtx_insn *seq;
    1070                 :            : 
    1071                 :     201582 :   if (code != NE && code != EQ)
    1072                 :            :     return FALSE;
    1073                 :            : 
    1074                 :     182099 :   if (!noce_simple_bbs (if_info))
    1075                 :            :     return FALSE;
    1076                 :            : 
    1077                 :            :   /* This optimization isn't valid if either A or B could be a NaN
    1078                 :            :      or a signed zero.  */
    1079                 :     138383 :   if (HONOR_NANS (if_info->x)
    1080                 :     138383 :       || HONOR_SIGNED_ZEROS (if_info->x))
    1081                 :      43230 :     return FALSE;
    1082                 :            : 
    1083                 :            :   /* Check whether the operands of the comparison are A and in
    1084                 :            :      either order.  */
    1085                 :      95153 :   if ((rtx_equal_p (if_info->a, XEXP (cond, 0))
    1086                 :       2273 :        && rtx_equal_p (if_info->b, XEXP (cond, 1)))
    1087                 :      97385 :       || (rtx_equal_p (if_info->a, XEXP (cond, 1))
    1088                 :       2325 :           && rtx_equal_p (if_info->b, XEXP (cond, 0))))
    1089                 :            :     {
    1090                 :         50 :       if (!rtx_interchangeable_p (if_info->a, if_info->b))
    1091                 :            :         return FALSE;
    1092                 :            : 
    1093                 :          0 :       y = (code == EQ) ? if_info->a : if_info->b;
    1094                 :            : 
    1095                 :            :       /* Avoid generating the move if the source is the destination.  */
    1096                 :          0 :       if (! rtx_equal_p (if_info->x, y))
    1097                 :            :         {
    1098                 :          0 :           start_sequence ();
    1099                 :          0 :           noce_emit_move_insn (if_info->x, y);
    1100                 :          0 :           seq = end_ifcvt_sequence (if_info);
    1101                 :          0 :           if (!seq)
    1102                 :            :             return FALSE;
    1103                 :            : 
    1104                 :          0 :           emit_insn_before_setloc (seq, if_info->jump,
    1105                 :          0 :                                    INSN_LOCATION (if_info->insn_a));
    1106                 :            :         }
    1107                 :          0 :       if_info->transform_name = "noce_try_move";
    1108                 :          0 :       return TRUE;
    1109                 :            :     }
    1110                 :            :   return FALSE;
    1111                 :            : }
    1112                 :            : 
    1113                 :            : /* Try forming an IF_THEN_ELSE (cond, b, a) and collapsing that
    1114                 :            :    through simplify_rtx.  Sometimes that can eliminate the IF_THEN_ELSE.
    1115                 :            :    If that is the case, emit the result into x.  */
    1116                 :            : 
    1117                 :            : static int
    1118                 :     201582 : noce_try_ifelse_collapse (struct noce_if_info * if_info)
    1119                 :            : {
    1120                 :     242867 :   if (!noce_simple_bbs (if_info))
    1121                 :            :     return FALSE;
    1122                 :            : 
    1123                 :     179848 :   machine_mode mode = GET_MODE (if_info->x);
    1124                 :     179848 :   rtx if_then_else = simplify_gen_ternary (IF_THEN_ELSE, mode, mode,
    1125                 :            :                                             if_info->cond, if_info->b,
    1126                 :            :                                             if_info->a);
    1127                 :            : 
    1128                 :     179848 :   if (GET_CODE (if_then_else) == IF_THEN_ELSE)
    1129                 :            :     return FALSE;
    1130                 :            : 
    1131                 :      15486 :   rtx_insn *seq;
    1132                 :      15486 :   start_sequence ();
    1133                 :      15486 :   noce_emit_move_insn (if_info->x, if_then_else);
    1134                 :      15486 :   seq = end_ifcvt_sequence (if_info);
    1135                 :      15486 :   if (!seq)
    1136                 :            :     return FALSE;
    1137                 :            : 
    1138                 :       1424 :   emit_insn_before_setloc (seq, if_info->jump,
    1139                 :       1424 :                           INSN_LOCATION (if_info->insn_a));
    1140                 :            : 
    1141                 :       1424 :   if_info->transform_name = "noce_try_ifelse_collapse";
    1142                 :       1424 :   return TRUE;
    1143                 :            : }
    1144                 :            : 
    1145                 :            : 
    1146                 :            : /* Convert "if (test) x = 1; else x = 0".
    1147                 :            : 
    1148                 :            :    Only try 0 and STORE_FLAG_VALUE here.  Other combinations will be
    1149                 :            :    tried in noce_try_store_flag_constants after noce_try_cmove has had
    1150                 :            :    a go at the conversion.  */
    1151                 :            : 
    1152                 :            : static int
    1153                 :     200158 : noce_try_store_flag (struct noce_if_info *if_info)
    1154                 :            : {
    1155                 :     200158 :   int reversep;
    1156                 :     200158 :   rtx target;
    1157                 :     200158 :   rtx_insn *seq;
    1158                 :            : 
    1159                 :     241403 :   if (!noce_simple_bbs (if_info))
    1160                 :            :     return FALSE;
    1161                 :            : 
    1162                 :     178424 :   if (CONST_INT_P (if_info->b)
    1163                 :      44539 :       && INTVAL (if_info->b) == STORE_FLAG_VALUE
    1164                 :       2968 :       && if_info->a == const0_rtx)
    1165                 :            :     reversep = 0;
    1166                 :     177634 :   else if (if_info->b == const0_rtx
    1167                 :      28166 :            && CONST_INT_P (if_info->a)
    1168                 :      13976 :            && INTVAL (if_info->a) == STORE_FLAG_VALUE
    1169                 :     190907 :            && noce_reversed_cond_code (if_info) != UNKNOWN)
    1170                 :            :     reversep = 1;
    1171                 :            :   else
    1172                 :     164361 :     return FALSE;
    1173                 :            : 
    1174                 :      14063 :   start_sequence ();
    1175                 :            : 
    1176                 :      14063 :   target = noce_emit_store_flag (if_info, if_info->x, reversep, 0);
    1177                 :      14063 :   if (target)
    1178                 :            :     {
    1179                 :      11305 :       if (target != if_info->x)
    1180                 :       1221 :         noce_emit_move_insn (if_info->x, target);
    1181                 :            : 
    1182                 :      11305 :       seq = end_ifcvt_sequence (if_info);
    1183                 :      11305 :       if (! seq)
    1184                 :            :         return FALSE;
    1185                 :            : 
    1186                 :      11305 :       emit_insn_before_setloc (seq, if_info->jump,
    1187                 :      11305 :                                INSN_LOCATION (if_info->insn_a));
    1188                 :      11305 :       if_info->transform_name = "noce_try_store_flag";
    1189                 :      11305 :       return TRUE;
    1190                 :            :     }
    1191                 :            :   else
    1192                 :            :     {
    1193                 :       2758 :       end_sequence ();
    1194                 :       2758 :       return FALSE;
    1195                 :            :     }
    1196                 :            : }
    1197                 :            : 
    1198                 :            : 
    1199                 :            : /* Convert "if (test) x = -A; else x = A" into
    1200                 :            :    x = A; if (test) x = -x if the machine can do the
    1201                 :            :    conditional negate form of this cheaply.
    1202                 :            :    Try this before noce_try_cmove that will just load the
    1203                 :            :    immediates into two registers and do a conditional select
    1204                 :            :    between them.  If the target has a conditional negate or
    1205                 :            :    conditional invert operation we can save a potentially
    1206                 :            :    expensive constant synthesis.  */
    1207                 :            : 
    1208                 :            : static bool
    1209                 :     188744 : noce_try_inverse_constants (struct noce_if_info *if_info)
    1210                 :            : {
    1211                 :     229885 :   if (!noce_simple_bbs (if_info))
    1212                 :            :     return false;
    1213                 :            : 
    1214                 :     167010 :   if (!CONST_INT_P (if_info->a)
    1215                 :      28395 :       || !CONST_INT_P (if_info->b)
    1216                 :       8165 :       || !REG_P (if_info->x))
    1217                 :            :     return false;
    1218                 :            : 
    1219                 :       8165 :   machine_mode mode = GET_MODE (if_info->x);
    1220                 :            : 
    1221                 :       8165 :   HOST_WIDE_INT val_a = INTVAL (if_info->a);
    1222                 :       8165 :   HOST_WIDE_INT val_b = INTVAL (if_info->b);
    1223                 :            : 
    1224                 :       8165 :   rtx cond = if_info->cond;
    1225                 :            : 
    1226                 :       8165 :   rtx x = if_info->x;
    1227                 :       8165 :   rtx target;
    1228                 :            : 
    1229                 :       8165 :   start_sequence ();
    1230                 :            : 
    1231                 :       8165 :   rtx_code code;
    1232                 :       8165 :   if (val_b != HOST_WIDE_INT_MIN && val_a == -val_b)
    1233                 :            :     code = NEG;
    1234                 :       7383 :   else if (val_a == ~val_b)
    1235                 :            :     code = NOT;
    1236                 :            :   else
    1237                 :            :     {
    1238                 :       7004 :       end_sequence ();
    1239                 :       7004 :       return false;
    1240                 :            :     }
    1241                 :            : 
    1242                 :       1161 :   rtx tmp = gen_reg_rtx (mode);
    1243                 :       1161 :   noce_emit_move_insn (tmp, if_info->a);
    1244                 :            : 
    1245                 :       1161 :   target = emit_conditional_neg_or_complement (x, code, mode, cond, tmp, tmp);
    1246                 :            : 
    1247                 :       1161 :   if (target)
    1248                 :            :     {
    1249                 :          0 :       rtx_insn *seq = get_insns ();
    1250                 :            : 
    1251                 :          0 :       if (!seq)
    1252                 :            :         {
    1253                 :          0 :           end_sequence ();
    1254                 :          0 :           return false;
    1255                 :            :         }
    1256                 :            : 
    1257                 :          0 :       if (target != if_info->x)
    1258                 :          0 :         noce_emit_move_insn (if_info->x, target);
    1259                 :            : 
    1260                 :          0 :       seq = end_ifcvt_sequence (if_info);
    1261                 :            : 
    1262                 :          0 :       if (!seq)
    1263                 :            :         return false;
    1264                 :            : 
    1265                 :          0 :       emit_insn_before_setloc (seq, if_info->jump,
    1266                 :          0 :                                INSN_LOCATION (if_info->insn_a));
    1267                 :          0 :       if_info->transform_name = "noce_try_inverse_constants";
    1268                 :          0 :       return true;
    1269                 :            :     }
    1270                 :            : 
    1271                 :       1161 :   end_sequence ();
    1272                 :       1161 :   return false;
    1273                 :            : }
    1274                 :            : 
    1275                 :            : 
    1276                 :            : /* Convert "if (test) x = a; else x = b", for A and B constant.
    1277                 :            :    Also allow A = y + c1, B = y + c2, with a common y between A
    1278                 :            :    and B.  */
    1279                 :            : 
    1280                 :            : static int
    1281                 :     188744 : noce_try_store_flag_constants (struct noce_if_info *if_info)
    1282                 :            : {
    1283                 :     188744 :   rtx target;
    1284                 :     188744 :   rtx_insn *seq;
    1285                 :     188744 :   bool reversep;
    1286                 :     188744 :   HOST_WIDE_INT itrue, ifalse, diff, tmp;
    1287                 :     188744 :   int normalize;
    1288                 :     188744 :   bool can_reverse;
    1289                 :     188744 :   machine_mode mode = GET_MODE (if_info->x);
    1290                 :     188744 :   rtx common = NULL_RTX;
    1291                 :            : 
    1292                 :     188744 :   rtx a = if_info->a;
    1293                 :     188744 :   rtx b = if_info->b;
    1294                 :            : 
    1295                 :            :   /* Handle cases like x := test ? y + 3 : y + 4.  */
    1296                 :     188744 :   if (GET_CODE (a) == PLUS
    1297                 :      29670 :       && GET_CODE (b) == PLUS
    1298                 :       1431 :       && CONST_INT_P (XEXP (a, 1))
    1299                 :        780 :       && CONST_INT_P (XEXP (b, 1))
    1300                 :        668 :       && rtx_equal_p (XEXP (a, 0), XEXP (b, 0))
    1301                 :            :       /* Allow expressions that are not using the result or plain
    1302                 :            :          registers where we handle overlap below.  */
    1303                 :     189303 :       && (REG_P (XEXP (a, 0))
    1304                 :         25 :           || (noce_operand_ok (XEXP (a, 0))
    1305                 :         25 :               && ! reg_overlap_mentioned_p (if_info->x, XEXP (a, 0)))))
    1306                 :            :     {
    1307                 :        559 :       common = XEXP (a, 0);
    1308                 :        559 :       a = XEXP (a, 1);
    1309                 :        559 :       b = XEXP (b, 1);
    1310                 :            :     }
    1311                 :            : 
    1312                 :     229885 :   if (!noce_simple_bbs (if_info))
    1313                 :            :     return FALSE;
    1314                 :            : 
    1315                 :     167010 :   if (CONST_INT_P (a)
    1316                 :      28954 :       && CONST_INT_P (b))
    1317                 :            :     {
    1318                 :       8724 :       ifalse = INTVAL (a);
    1319                 :       8724 :       itrue = INTVAL (b);
    1320                 :       8724 :       bool subtract_flag_p = false;
    1321                 :            : 
    1322                 :       8724 :       diff = (unsigned HOST_WIDE_INT) itrue - ifalse;
    1323                 :            :       /* Make sure we can represent the difference between the two values.  */
    1324                 :       8724 :       if ((diff > 0)
    1325                 :       8724 :           != ((ifalse < 0) != (itrue < 0) ? ifalse < 0 : ifalse < itrue))
    1326                 :            :         return FALSE;
    1327                 :            : 
    1328                 :       8598 :       diff = trunc_int_for_mode (diff, mode);
    1329                 :            : 
    1330                 :       8598 :       can_reverse = noce_reversed_cond_code (if_info) != UNKNOWN;
    1331                 :       8598 :       reversep = false;
    1332                 :       8598 :       if (diff == STORE_FLAG_VALUE || diff == -STORE_FLAG_VALUE)
    1333                 :            :         {
    1334                 :       4735 :           normalize = 0;
    1335                 :            :           /* We could collapse these cases but it is easier to follow the
    1336                 :            :              diff/STORE_FLAG_VALUE combinations when they are listed
    1337                 :            :              explicitly.  */
    1338                 :            : 
    1339                 :            :           /* test ? 3 : 4
    1340                 :            :              => 4 + (test != 0).  */
    1341                 :       4735 :           if (diff < 0 && STORE_FLAG_VALUE < 0)
    1342                 :            :               reversep = false;
    1343                 :            :           /* test ? 4 : 3
    1344                 :            :              => can_reverse  | 4 + (test == 0)
    1345                 :            :                 !can_reverse | 3 - (test != 0).  */
    1346                 :       4735 :           else if (diff > 0 && STORE_FLAG_VALUE < 0)
    1347                 :            :             {
    1348                 :            :               reversep = can_reverse;
    1349                 :            :               subtract_flag_p = !can_reverse;
    1350                 :            :               /* If we need to subtract the flag and we have PLUS-immediate
    1351                 :            :                  A and B then it is unlikely to be beneficial to play tricks
    1352                 :            :                  here.  */
    1353                 :            :               if (subtract_flag_p && common)
    1354                 :            :                 return FALSE;
    1355                 :            :             }
    1356                 :            :           /* test ? 3 : 4
    1357                 :            :              => can_reverse  | 3 + (test == 0)
    1358                 :            :                 !can_reverse | 4 - (test != 0).  */
    1359                 :       4735 :           else if (diff < 0 && STORE_FLAG_VALUE > 0)
    1360                 :            :             {
    1361                 :       3030 :               reversep = can_reverse;
    1362                 :       3030 :               subtract_flag_p = !can_reverse;
    1363                 :            :               /* If we need to subtract the flag and we have PLUS-immediate
    1364                 :            :                  A and B then it is unlikely to be beneficial to play tricks
    1365                 :            :                  here.  */
    1366                 :       3030 :               if (subtract_flag_p && common)
    1367                 :            :                 return FALSE;
    1368                 :            :             }
    1369                 :            :           /* test ? 4 : 3
    1370                 :            :              => 4 + (test != 0).  */
    1371                 :       1705 :           else if (diff > 0 && STORE_FLAG_VALUE > 0)
    1372                 :            :             reversep = false;
    1373                 :            :           else
    1374                 :          0 :             gcc_unreachable ();
    1375                 :            :         }
    1376                 :            :       /* Is this (cond) ? 2^n : 0?  */
    1377                 :        350 :       else if (ifalse == 0 && pow2p_hwi (itrue)
    1378                 :       3863 :                && STORE_FLAG_VALUE == 1)
    1379                 :            :         normalize = 1;
    1380                 :            :       /* Is this (cond) ? 0 : 2^n?  */
    1381                 :        479 :       else if (itrue == 0 && pow2p_hwi (ifalse) && can_reverse
    1382                 :       3962 :                && STORE_FLAG_VALUE == 1)
    1383                 :            :         {
    1384                 :            :           normalize = 1;
    1385                 :            :           reversep = true;
    1386                 :            :         }
    1387                 :            :       /* Is this (cond) ? -1 : x?  */
    1388                 :            :       else if (itrue == -1
    1389                 :            :                && STORE_FLAG_VALUE == -1)
    1390                 :            :         normalize = -1;
    1391                 :            :       /* Is this (cond) ? x : -1?  */
    1392                 :            :       else if (ifalse == -1 && can_reverse
    1393                 :            :                && STORE_FLAG_VALUE == -1)
    1394                 :            :         {
    1395                 :            :           normalize = -1;
    1396                 :            :           reversep = true;
    1397                 :            :         }
    1398                 :            :       else
    1399                 :            :         return FALSE;
    1400                 :            : 
    1401                 :       5190 :       if (reversep)
    1402                 :            :         {
    1403                 :       3307 :           std::swap (itrue, ifalse);
    1404                 :       3307 :           diff = trunc_int_for_mode (-(unsigned HOST_WIDE_INT) diff, mode);
    1405                 :            :         }
    1406                 :            : 
    1407                 :       5190 :       start_sequence ();
    1408                 :            : 
    1409                 :            :       /* If we have x := test ? x + 3 : x + 4 then move the original
    1410                 :            :          x out of the way while we store flags.  */
    1411                 :       5190 :       if (common && rtx_equal_p (common, if_info->x))
    1412                 :            :         {
    1413                 :         10 :           common = gen_reg_rtx (mode);
    1414                 :         10 :           noce_emit_move_insn (common, if_info->x);
    1415                 :            :         }
    1416                 :            : 
    1417                 :       5190 :       target = noce_emit_store_flag (if_info, if_info->x, reversep, normalize);
    1418                 :       5190 :       if (! target)
    1419                 :            :         {
    1420                 :       2882 :           end_sequence ();
    1421                 :       2882 :           return FALSE;
    1422                 :            :         }
    1423                 :            : 
    1424                 :            :       /* if (test) x = 3; else x = 4;
    1425                 :            :          =>   x = 3 + (test == 0);  */
    1426                 :       2308 :       if (diff == STORE_FLAG_VALUE || diff == -STORE_FLAG_VALUE)
    1427                 :            :         {
    1428                 :            :           /* Add the common part now.  This may allow combine to merge this
    1429                 :            :              with the store flag operation earlier into some sort of conditional
    1430                 :            :              increment/decrement if the target allows it.  */
    1431                 :       1853 :           if (common)
    1432                 :         94 :             target = expand_simple_binop (mode, PLUS,
    1433                 :            :                                            target, common,
    1434                 :            :                                            target, 0, OPTAB_WIDEN);
    1435                 :            : 
    1436                 :            :           /* Always use ifalse here.  It should have been swapped with itrue
    1437                 :            :              when appropriate when reversep is true.  */
    1438                 :       3706 :           target = expand_simple_binop (mode, subtract_flag_p ? MINUS : PLUS,
    1439                 :            :                                         gen_int_mode (ifalse, mode), target,
    1440                 :            :                                         if_info->x, 0, OPTAB_WIDEN);
    1441                 :            :         }
    1442                 :            :       /* Other cases are not beneficial when the original A and B are PLUS
    1443                 :            :          expressions.  */
    1444                 :        455 :       else if (common)
    1445                 :            :         {
    1446                 :          0 :           end_sequence ();
    1447                 :          0 :           return FALSE;
    1448                 :            :         }
    1449                 :            :       /* if (test) x = 8; else x = 0;
    1450                 :            :          =>   x = (test != 0) << 3;  */
    1451                 :        910 :       else if (ifalse == 0 && (tmp = exact_log2 (itrue)) >= 0)
    1452                 :            :         {
    1453                 :        455 :           target = expand_simple_binop (mode, ASHIFT,
    1454                 :            :                                         target, GEN_INT (tmp), if_info->x, 0,
    1455                 :            :                                         OPTAB_WIDEN);
    1456                 :            :         }
    1457                 :            : 
    1458                 :            :       /* if (test) x = -1; else x = b;
    1459                 :            :          =>   x = -(test != 0) | b;  */
    1460                 :          0 :       else if (itrue == -1)
    1461                 :            :         {
    1462                 :          0 :           target = expand_simple_binop (mode, IOR,
    1463                 :            :                                         target, gen_int_mode (ifalse, mode),
    1464                 :            :                                         if_info->x, 0, OPTAB_WIDEN);
    1465                 :            :         }
    1466                 :            :       else
    1467                 :            :         {
    1468                 :          0 :           end_sequence ();
    1469                 :          0 :           return FALSE;
    1470                 :            :         }
    1471                 :            : 
    1472                 :       2308 :       if (! target)
    1473                 :            :         {
    1474                 :          0 :           end_sequence ();
    1475                 :          0 :           return FALSE;
    1476                 :            :         }
    1477                 :            : 
    1478                 :       2308 :       if (target != if_info->x)
    1479                 :          0 :         noce_emit_move_insn (if_info->x, target);
    1480                 :            : 
    1481                 :       2308 :       seq = end_ifcvt_sequence (if_info);
    1482                 :       2308 :       if (!seq || !targetm.noce_conversion_profitable_p (seq, if_info))
    1483                 :        652 :         return FALSE;
    1484                 :            : 
    1485                 :       1656 :       emit_insn_before_setloc (seq, if_info->jump,
    1486                 :       1656 :                                INSN_LOCATION (if_info->insn_a));
    1487                 :       1656 :       if_info->transform_name = "noce_try_store_flag_constants";
    1488                 :            : 
    1489                 :       1656 :       return TRUE;
    1490                 :            :     }
    1491                 :            : 
    1492                 :            :   return FALSE;
    1493                 :            : }
    1494                 :            : 
    1495                 :            : /* Convert "if (test) foo++" into "foo += (test != 0)", and
    1496                 :            :    similarly for "foo--".  */
    1497                 :            : 
    1498                 :            : static int
    1499                 :     157395 : noce_try_addcc (struct noce_if_info *if_info)
    1500                 :            : {
    1501                 :     157395 :   rtx target;
    1502                 :     157395 :   rtx_insn *seq;
    1503                 :     157395 :   int subtract, normalize;
    1504                 :            : 
    1505                 :     187103 :   if (!noce_simple_bbs (if_info))
    1506                 :            :     return FALSE;
    1507                 :            : 
    1508                 :     135661 :   if (GET_CODE (if_info->a) == PLUS
    1509                 :      24358 :       && rtx_equal_p (XEXP (if_info->a, 0), if_info->b)
    1510                 :     153174 :       && noce_reversed_cond_code (if_info) != UNKNOWN)
    1511                 :            :     {
    1512                 :      17513 :       rtx cond = if_info->rev_cond;
    1513                 :      17513 :       enum rtx_code code;
    1514                 :            : 
    1515                 :      17513 :       if (cond == NULL_RTX)
    1516                 :            :         {
    1517                 :          0 :           cond = if_info->cond;
    1518                 :          0 :           code = reversed_comparison_code (cond, if_info->jump);
    1519                 :            :         }
    1520                 :            :       else
    1521                 :      17513 :         code = GET_CODE (cond);
    1522                 :            : 
    1523                 :            :       /* First try to use addcc pattern.  */
    1524                 :      17513 :       if (general_operand (XEXP (cond, 0), VOIDmode)
    1525                 :      17513 :           && general_operand (XEXP (cond, 1), VOIDmode))
    1526                 :            :         {
    1527                 :      16224 :           start_sequence ();
    1528                 :      48672 :           target = emit_conditional_add (if_info->x, code,
    1529                 :            :                                          XEXP (cond, 0),
    1530                 :            :                                          XEXP (cond, 1),
    1531                 :            :                                          VOIDmode,
    1532                 :            :                                          if_info->b,
    1533                 :      16224 :                                          XEXP (if_info->a, 1),
    1534                 :      16224 :                                          GET_MODE (if_info->x),
    1535                 :      16224 :                                          (code == LTU || code == GEU
    1536                 :      16224 :                                           || code == LEU || code == GTU));
    1537                 :      16224 :           if (target)
    1538                 :            :             {
    1539                 :       1386 :               if (target != if_info->x)
    1540                 :          0 :                 noce_emit_move_insn (if_info->x, target);
    1541                 :            : 
    1542                 :       1386 :               seq = end_ifcvt_sequence (if_info);
    1543                 :       1386 :               if (!seq || !targetm.noce_conversion_profitable_p (seq, if_info))
    1544                 :         74 :                 return FALSE;
    1545                 :            : 
    1546                 :       1312 :               emit_insn_before_setloc (seq, if_info->jump,
    1547                 :       1312 :                                        INSN_LOCATION (if_info->insn_a));
    1548                 :       1312 :               if_info->transform_name = "noce_try_addcc";
    1549                 :            : 
    1550                 :       1312 :               return TRUE;
    1551                 :            :             }
    1552                 :      14838 :           end_sequence ();
    1553                 :            :         }
    1554                 :            : 
    1555                 :            :       /* If that fails, construct conditional increment or decrement using
    1556                 :            :          setcc.  We're changing a branch and an increment to a comparison and
    1557                 :            :          an ADD/SUB.  */
    1558                 :      16127 :       if (XEXP (if_info->a, 1) == const1_rtx
    1559                 :      11121 :           || XEXP (if_info->a, 1) == constm1_rtx)
    1560                 :            :         {
    1561                 :       5363 :           start_sequence ();
    1562                 :       5363 :           if (STORE_FLAG_VALUE == INTVAL (XEXP (if_info->a, 1)))
    1563                 :            :             subtract = 0, normalize = 0;
    1564                 :        357 :           else if (-STORE_FLAG_VALUE == INTVAL (XEXP (if_info->a, 1)))
    1565                 :            :             subtract = 1, normalize = 0;
    1566                 :            :           else
    1567                 :          0 :             subtract = 0, normalize = INTVAL (XEXP (if_info->a, 1));
    1568                 :            : 
    1569                 :            : 
    1570                 :       5363 :           target = noce_emit_store_flag (if_info,
    1571                 :       5363 :                                          gen_reg_rtx (GET_MODE (if_info->x)),
    1572                 :            :                                          1, normalize);
    1573                 :            : 
    1574                 :       5363 :           if (target)
    1575                 :       4949 :             target = expand_simple_binop (GET_MODE (if_info->x),
    1576                 :            :                                           subtract ? MINUS : PLUS,
    1577                 :            :                                           if_info->b, target, if_info->x,
    1578                 :            :                                           0, OPTAB_WIDEN);
    1579                 :       5363 :           if (target)
    1580                 :            :             {
    1581                 :       4949 :               if (target != if_info->x)
    1582                 :          0 :                 noce_emit_move_insn (if_info->x, target);
    1583                 :            : 
    1584                 :       4949 :               seq = end_ifcvt_sequence (if_info);
    1585                 :       4949 :               if (!seq || !targetm.noce_conversion_profitable_p (seq, if_info))
    1586                 :       1432 :                 return FALSE;
    1587                 :            : 
    1588                 :       3517 :               emit_insn_before_setloc (seq, if_info->jump,
    1589                 :       3517 :                                        INSN_LOCATION (if_info->insn_a));
    1590                 :       3517 :               if_info->transform_name = "noce_try_addcc";
    1591                 :       3517 :               return TRUE;
    1592                 :            :             }
    1593                 :        414 :           end_sequence ();
    1594                 :            :         }
    1595                 :            :     }
    1596                 :            : 
    1597                 :            :   return FALSE;
    1598                 :            : }
    1599                 :            : 
    1600                 :            : /* Convert "if (test) x = 0;" to "x &= -(test == 0);"  */
    1601                 :            : 
    1602                 :            : static int
    1603                 :     152566 : noce_try_store_flag_mask (struct noce_if_info *if_info)
    1604                 :            : {
    1605                 :     152566 :   rtx target;
    1606                 :     152566 :   rtx_insn *seq;
    1607                 :     152566 :   int reversep;
    1608                 :            : 
    1609                 :     182154 :   if (!noce_simple_bbs (if_info))
    1610                 :            :     return FALSE;
    1611                 :            : 
    1612                 :     130832 :   reversep = 0;
    1613                 :            : 
    1614                 :     130832 :   if ((if_info->a == const0_rtx
    1615                 :       2408 :        && rtx_equal_p (if_info->b, if_info->x))
    1616                 :     260532 :       || ((reversep = (noce_reversed_cond_code (if_info) != UNKNOWN))
    1617                 :     129700 :           && if_info->b == const0_rtx
    1618                 :      14210 :           && rtx_equal_p (if_info->a, if_info->x)))
    1619                 :            :     {
    1620                 :       1132 :       start_sequence ();
    1621                 :       1132 :       target = noce_emit_store_flag (if_info,
    1622                 :       1132 :                                      gen_reg_rtx (GET_MODE (if_info->x)),
    1623                 :            :                                      reversep, -1);
    1624                 :       1132 :       if (target)
    1625                 :        656 :         target = expand_simple_binop (GET_MODE (if_info->x), AND,
    1626                 :            :                                       if_info->x,
    1627                 :            :                                       target, if_info->x, 0,
    1628                 :            :                                       OPTAB_WIDEN);
    1629                 :            : 
    1630                 :       1132 :       if (target)
    1631                 :            :         {
    1632                 :        656 :           if (target != if_info->x)
    1633                 :         22 :             noce_emit_move_insn (if_info->x, target);
    1634                 :            : 
    1635                 :        656 :           seq = end_ifcvt_sequence (if_info);
    1636                 :        656 :           if (!seq || !targetm.noce_conversion_profitable_p (seq, if_info))
    1637                 :        650 :             return FALSE;
    1638                 :            : 
    1639                 :          6 :           emit_insn_before_setloc (seq, if_info->jump,
    1640                 :          6 :                                    INSN_LOCATION (if_info->insn_a));
    1641                 :          6 :           if_info->transform_name = "noce_try_store_flag_mask";
    1642                 :            : 
    1643                 :          6 :           return TRUE;
    1644                 :            :         }
    1645                 :            : 
    1646                 :        476 :       end_sequence ();
    1647                 :            :     }
    1648                 :            : 
    1649                 :            :   return FALSE;
    1650                 :            : }
    1651                 :            : 
    1652                 :            : /* Helper function for noce_try_cmove and noce_try_cmove_arith.  */
    1653                 :            : 
    1654                 :            : static rtx
    1655                 :     196094 : noce_emit_cmove (struct noce_if_info *if_info, rtx x, enum rtx_code code,
    1656                 :            :                  rtx cmp_a, rtx cmp_b, rtx vfalse, rtx vtrue)
    1657                 :            : {
    1658                 :     196094 :   rtx target ATTRIBUTE_UNUSED;
    1659                 :     196094 :   int unsignedp ATTRIBUTE_UNUSED;
    1660                 :            : 
    1661                 :            :   /* If earliest == jump, try to build the cmove insn directly.
    1662                 :            :      This is helpful when combine has created some complex condition
    1663                 :            :      (like for alpha's cmovlbs) that we can't hope to regenerate
    1664                 :            :      through the normal interface.  */
    1665                 :            : 
    1666                 :     196094 :   if (if_info->cond_earliest == if_info->jump)
    1667                 :            :     {
    1668                 :       4393 :       rtx cond = gen_rtx_fmt_ee (code, GET_MODE (if_info->cond), cmp_a, cmp_b);
    1669                 :       4393 :       rtx if_then_else = gen_rtx_IF_THEN_ELSE (GET_MODE (x),
    1670                 :            :                                                cond, vtrue, vfalse);
    1671                 :       4393 :       rtx set = gen_rtx_SET (x, if_then_else);
    1672                 :            : 
    1673                 :       4393 :       start_sequence ();
    1674                 :       4393 :       rtx_insn *insn = emit_insn (set);
    1675                 :            : 
    1676                 :       8786 :       if (recog_memoized (insn) >= 0)
    1677                 :            :         {
    1678                 :       1349 :           rtx_insn *seq = get_insns ();
    1679                 :       1349 :           end_sequence ();
    1680                 :       1349 :           emit_insn (seq);
    1681                 :            : 
    1682                 :       1349 :           return x;
    1683                 :            :         }
    1684                 :            : 
    1685                 :       3044 :       end_sequence ();
    1686                 :            :     }
    1687                 :            : 
    1688                 :            :   /* Don't even try if the comparison operands are weird
    1689                 :            :      except that the target supports cbranchcc4.  */
    1690                 :     194745 :   if (! general_operand (cmp_a, GET_MODE (cmp_a))
    1691                 :     194745 :       || ! general_operand (cmp_b, GET_MODE (cmp_b)))
    1692                 :            :     {
    1693                 :      28178 :       if (!have_cbranchcc4
    1694                 :      28178 :           || GET_MODE_CLASS (GET_MODE (cmp_a)) != MODE_CC
    1695                 :       2959 :           || cmp_b != const0_rtx)
    1696                 :            :         return NULL_RTX;
    1697                 :            :     }
    1698                 :            : 
    1699                 :     339052 :   unsignedp = (code == LTU || code == GEU
    1700                 :     169526 :                || code == LEU || code == GTU);
    1701                 :            : 
    1702                 :     339052 :   target = emit_conditional_move (x, code, cmp_a, cmp_b, VOIDmode,
    1703                 :     169526 :                                   vtrue, vfalse, GET_MODE (x),
    1704                 :            :                                   unsignedp);
    1705                 :     169526 :   if (target)
    1706                 :            :     return target;
    1707                 :            : 
    1708                 :            :   /* We might be faced with a situation like:
    1709                 :            : 
    1710                 :            :      x = (reg:M TARGET)
    1711                 :            :      vtrue = (subreg:M (reg:N VTRUE) BYTE)
    1712                 :            :      vfalse = (subreg:M (reg:N VFALSE) BYTE)
    1713                 :            : 
    1714                 :            :      We can't do a conditional move in mode M, but it's possible that we
    1715                 :            :      could do a conditional move in mode N instead and take a subreg of
    1716                 :            :      the result.
    1717                 :            : 
    1718                 :            :      If we can't create new pseudos, though, don't bother.  */
    1719                 :       9877 :   if (reload_completed)
    1720                 :            :     return NULL_RTX;
    1721                 :            : 
    1722                 :       9877 :   if (GET_CODE (vtrue) == SUBREG && GET_CODE (vfalse) == SUBREG)
    1723                 :            :     {
    1724                 :         26 :       rtx reg_vtrue = SUBREG_REG (vtrue);
    1725                 :         26 :       rtx reg_vfalse = SUBREG_REG (vfalse);
    1726                 :         26 :       poly_uint64 byte_vtrue = SUBREG_BYTE (vtrue);
    1727                 :         26 :       poly_uint64 byte_vfalse = SUBREG_BYTE (vfalse);
    1728                 :         26 :       rtx promoted_target;
    1729                 :            : 
    1730                 :         26 :       if (GET_MODE (reg_vtrue) != GET_MODE (reg_vfalse)
    1731                 :         26 :           || maybe_ne (byte_vtrue, byte_vfalse)
    1732                 :         26 :           || (SUBREG_PROMOTED_VAR_P (vtrue)
    1733                 :         26 :               != SUBREG_PROMOTED_VAR_P (vfalse))
    1734                 :         26 :           || (SUBREG_PROMOTED_GET (vtrue)
    1735                 :         26 :               != SUBREG_PROMOTED_GET (vfalse)))
    1736                 :            :         return NULL_RTX;
    1737                 :            : 
    1738                 :         26 :       promoted_target = gen_reg_rtx (GET_MODE (reg_vtrue));
    1739                 :            : 
    1740                 :         52 :       target = emit_conditional_move (promoted_target, code, cmp_a, cmp_b,
    1741                 :            :                                       VOIDmode, reg_vtrue, reg_vfalse,
    1742                 :         26 :                                       GET_MODE (reg_vtrue), unsignedp);
    1743                 :            :       /* Nope, couldn't do it in that mode either.  */
    1744                 :         26 :       if (!target)
    1745                 :            :         return NULL_RTX;
    1746                 :            : 
    1747                 :          6 :       target = gen_rtx_SUBREG (GET_MODE (vtrue), promoted_target, byte_vtrue);
    1748                 :          6 :       SUBREG_PROMOTED_VAR_P (target) = SUBREG_PROMOTED_VAR_P (vtrue);
    1749                 :          6 :       SUBREG_PROMOTED_SET (target, SUBREG_PROMOTED_GET (vtrue));
    1750                 :          6 :       emit_move_insn (x, target);
    1751                 :          6 :       return x;
    1752                 :            :     }
    1753                 :            :   else
    1754                 :            :     return NULL_RTX;
    1755                 :            : }
    1756                 :            : 
    1757                 :            : /* Try only simple constants and registers here.  More complex cases
    1758                 :            :    are handled in noce_try_cmove_arith after noce_try_store_flag_arith
    1759                 :            :    has had a go at it.  */
    1760                 :            : 
    1761                 :            : static int
    1762                 :     187088 : noce_try_cmove (struct noce_if_info *if_info)
    1763                 :            : {
    1764                 :     187088 :   enum rtx_code code;
    1765                 :     187088 :   rtx target;
    1766                 :     187088 :   rtx_insn *seq;
    1767                 :            : 
    1768                 :     226608 :   if (!noce_simple_bbs (if_info))
    1769                 :            :     return FALSE;
    1770                 :            : 
    1771                 :     133241 :   if ((CONSTANT_P (if_info->a) || register_operand (if_info->a, VOIDmode))
    1772                 :     189024 :       && (CONSTANT_P (if_info->b) || register_operand (if_info->b, VOIDmode)))
    1773                 :            :     {
    1774                 :      50608 :       start_sequence ();
    1775                 :            : 
    1776                 :      50608 :       code = GET_CODE (if_info->cond);
    1777                 :      50608 :       target = noce_emit_cmove (if_info, if_info->x, code,
    1778                 :            :                                 XEXP (if_info->cond, 0),
    1779                 :            :                                 XEXP (if_info->cond, 1),
    1780                 :            :                                 if_info->a, if_info->b);
    1781                 :            : 
    1782                 :      50608 :       if (target)
    1783                 :            :         {
    1784                 :      39538 :           if (target != if_info->x)
    1785                 :          0 :             noce_emit_move_insn (if_info->x, target);
    1786                 :            : 
    1787                 :      39538 :           seq = end_ifcvt_sequence (if_info);
    1788                 :      39538 :           if (!seq || !targetm.noce_conversion_profitable_p (seq, if_info))
    1789                 :       9845 :             return FALSE;
    1790                 :            : 
    1791                 :      29693 :           emit_insn_before_setloc (seq, if_info->jump,
    1792                 :      29693 :                                    INSN_LOCATION (if_info->insn_a));
    1793                 :      29693 :           if_info->transform_name = "noce_try_cmove";
    1794                 :            : 
    1795                 :      29693 :           return TRUE;
    1796                 :            :         }
    1797                 :            :       /* If both a and b are constants try a last-ditch transformation:
    1798                 :            :          if (test) x = a; else x = b;
    1799                 :            :          =>   x = (-(test != 0) & (b - a)) + a;
    1800                 :            :          Try this only if the target-specific expansion above has failed.
    1801                 :            :          The target-specific expander may want to generate sequences that
    1802                 :            :          we don't know about, so give them a chance before trying this
    1803                 :            :          approach.  */
    1804                 :      11070 :       else if (!targetm.have_conditional_execution ()
    1805                 :      11070 :                 && CONST_INT_P (if_info->a) && CONST_INT_P (if_info->b))
    1806                 :            :         {
    1807                 :       3075 :           machine_mode mode = GET_MODE (if_info->x);
    1808                 :       3075 :           HOST_WIDE_INT ifalse = INTVAL (if_info->a);
    1809                 :       3075 :           HOST_WIDE_INT itrue = INTVAL (if_info->b);
    1810                 :       3075 :           rtx target = noce_emit_store_flag (if_info, if_info->x, false, -1);
    1811                 :       3075 :           if (!target)
    1812                 :            :             {
    1813                 :       2884 :               end_sequence ();
    1814                 :       2884 :               return FALSE;
    1815                 :            :             }
    1816                 :            : 
    1817                 :        191 :           HOST_WIDE_INT diff = (unsigned HOST_WIDE_INT) itrue - ifalse;
    1818                 :            :           /* Make sure we can represent the difference
    1819                 :            :              between the two values.  */
    1820                 :        191 :           if ((diff > 0)
    1821                 :        191 :               != ((ifalse < 0) != (itrue < 0) ? ifalse < 0 : ifalse < itrue))
    1822                 :            :             {
    1823                 :         41 :               end_sequence ();
    1824                 :         41 :               return FALSE;
    1825                 :            :             }
    1826                 :            : 
    1827                 :        150 :           diff = trunc_int_for_mode (diff, mode);
    1828                 :        150 :           target = expand_simple_binop (mode, AND,
    1829                 :            :                                         target, gen_int_mode (diff, mode),
    1830                 :            :                                         if_info->x, 0, OPTAB_WIDEN);
    1831                 :        150 :           if (target)
    1832                 :        150 :             target = expand_simple_binop (mode, PLUS,
    1833                 :            :                                           target, gen_int_mode (ifalse, mode),
    1834                 :            :                                           if_info->x, 0, OPTAB_WIDEN);
    1835                 :        150 :           if (target)
    1836                 :            :             {
    1837                 :        150 :               if (target != if_info->x)
    1838                 :          0 :                 noce_emit_move_insn (if_info->x, target);
    1839                 :            : 
    1840                 :        150 :               seq = end_ifcvt_sequence (if_info);
    1841                 :        150 :               if (!seq || !targetm.noce_conversion_profitable_p (seq, if_info))
    1842                 :        150 :                 return FALSE;
    1843                 :            : 
    1844                 :          0 :               emit_insn_before_setloc (seq, if_info->jump,
    1845                 :          0 :                                    INSN_LOCATION (if_info->insn_a));
    1846                 :          0 :               if_info->transform_name = "noce_try_cmove";
    1847                 :          0 :               return TRUE;
    1848                 :            :             }
    1849                 :            :           else
    1850                 :            :             {
    1851                 :          0 :               end_sequence ();
    1852                 :          0 :               return FALSE;
    1853                 :            :             }
    1854                 :            :         }
    1855                 :            :       else
    1856                 :       7995 :         end_sequence ();
    1857                 :            :     }
    1858                 :            : 
    1859                 :            :   return FALSE;
    1860                 :            : }
    1861                 :            : 
    1862                 :            : /* Return true if X contains a conditional code mode rtx.  */
    1863                 :            : 
    1864                 :            : static bool
    1865                 :    2146890 : contains_ccmode_rtx_p (rtx x)
    1866                 :            : {
    1867                 :    2146890 :   subrtx_iterator::array_type array;
    1868                 :    5510630 :   FOR_EACH_SUBRTX (iter, array, x, ALL)
    1869                 :    3412670 :     if (GET_MODE_CLASS (GET_MODE (*iter)) == MODE_CC)
    1870                 :      48929 :       return true;
    1871                 :            : 
    1872                 :    2097960 :   return false;
    1873                 :            : }
    1874                 :            : 
    1875                 :            : /* Helper for bb_valid_for_noce_process_p.  Validate that
    1876                 :            :    the rtx insn INSN is a single set that does not set
    1877                 :            :    the conditional register CC and is in general valid for
    1878                 :            :    if-conversion.  */
    1879                 :            : 
    1880                 :            : static bool
    1881                 :    2676600 : insn_valid_noce_process_p (rtx_insn *insn, rtx cc)
    1882                 :            : {
    1883                 :    2676600 :   if (!insn
    1884                 :    2667820 :       || !NONJUMP_INSN_P (insn)
    1885                 :    4845150 :       || (cc && set_of (cc, insn)))
    1886                 :     514238 :       return false;
    1887                 :            : 
    1888                 :    2162360 :   rtx sset = single_set (insn);
    1889                 :            : 
    1890                 :            :   /* Currently support only simple single sets in test_bb.  */
    1891                 :    2162360 :   if (!sset
    1892                 :    2159730 :       || !noce_operand_ok (SET_DEST (sset))
    1893                 :    2146890 :       || contains_ccmode_rtx_p (SET_DEST (sset))
    1894                 :    4260320 :       || !noce_operand_ok (SET_SRC (sset)))
    1895                 :     119235 :     return false;
    1896                 :            : 
    1897                 :            :   return true;
    1898                 :            : }
    1899                 :            : 
    1900                 :            : 
    1901                 :            : /* Return true iff the registers that the insns in BB_A set do not get
    1902                 :            :    used in BB_B.  If TO_RENAME is non-NULL then it is a location that will be
    1903                 :            :    renamed later by the caller and so conflicts on it should be ignored
    1904                 :            :    in this function.  */
    1905                 :            : 
    1906                 :            : static bool
    1907                 :      49463 : bbs_ok_for_cmove_arith (basic_block bb_a, basic_block bb_b, rtx to_rename)
    1908                 :            : {
    1909                 :      49463 :   rtx_insn *a_insn;
    1910                 :      49463 :   bitmap bba_sets = BITMAP_ALLOC (&reg_obstack);
    1911                 :            : 
    1912                 :      49463 :   df_ref def;
    1913                 :      49463 :   df_ref use;
    1914                 :            : 
    1915                 :     419519 :   FOR_BB_INSNS (bb_a, a_insn)
    1916                 :            :     {
    1917                 :     185028 :       if (!active_insn_p (a_insn))
    1918                 :     118413 :         continue;
    1919                 :            : 
    1920                 :      66615 :       rtx sset_a = single_set (a_insn);
    1921                 :            : 
    1922                 :      66615 :       if (!sset_a)
    1923                 :            :         {
    1924                 :          0 :           BITMAP_FREE (bba_sets);
    1925                 :          0 :           return false;
    1926                 :            :         }
    1927                 :            :       /* Record all registers that BB_A sets.  */
    1928                 :     163989 :       FOR_EACH_INSN_DEF (def, a_insn)
    1929                 :      97374 :         if (!(to_rename && DF_REF_REG (def) == to_rename))
    1930                 :      48599 :           bitmap_set_bit (bba_sets, DF_REF_REGNO (def));
    1931                 :            :     }
    1932                 :            : 
    1933                 :      49463 :   rtx_insn *b_insn;
    1934                 :            : 
    1935                 :     234452 :   FOR_BB_INSNS (bb_b, b_insn)
    1936                 :            :     {
    1937                 :     185008 :       if (!active_insn_p (b_insn))
    1938                 :     118412 :         continue;
    1939                 :            : 
    1940                 :      66596 :       rtx sset_b = single_set (b_insn);
    1941                 :            : 
    1942                 :      66596 :       if (!sset_b)
    1943                 :            :         {
    1944                 :          0 :           BITMAP_FREE (bba_sets);
    1945                 :          0 :           return false;
    1946                 :            :         }
    1947                 :            : 
    1948                 :            :       /* Make sure this is a REG and not some instance
    1949                 :            :          of ZERO_EXTRACT or SUBREG or other dangerous stuff.
    1950                 :            :          If we have a memory destination then we have a pair of simple
    1951                 :            :          basic blocks performing an operation of the form [addr] = c ? a : b.
    1952                 :            :          bb_valid_for_noce_process_p will have ensured that these are
    1953                 :            :          the only stores present.  In that case [addr] should be the location
    1954                 :            :          to be renamed.  Assert that the callers set this up properly.  */
    1955                 :      66596 :       if (MEM_P (SET_DEST (sset_b)))
    1956                 :        688 :         gcc_assert (rtx_equal_p (SET_DEST (sset_b), to_rename));
    1957                 :      65908 :       else if (!REG_P (SET_DEST (sset_b)))
    1958                 :            :         {
    1959                 :         13 :           BITMAP_FREE (bba_sets);
    1960                 :         13 :           return false;
    1961                 :            :         }
    1962                 :            : 
    1963                 :            :       /* If the insn uses a reg set in BB_A return false.  */
    1964                 :     134692 :       FOR_EACH_INSN_USE (use, b_insn)
    1965                 :            :         {
    1966                 :      68115 :           if (bitmap_bit_p (bba_sets, DF_REF_REGNO (use)))
    1967                 :            :             {
    1968                 :          6 :               BITMAP_FREE (bba_sets);
    1969                 :          6 :               return false;
    1970                 :            :             }
    1971                 :            :         }
    1972                 :            : 
    1973                 :            :     }
    1974                 :            : 
    1975                 :      49444 :   BITMAP_FREE (bba_sets);
    1976                 :      49444 :   return true;
    1977                 :            : }
    1978                 :            : 
    1979                 :            : /* Emit copies of all the active instructions in BB except the last.
    1980                 :            :    This is a helper for noce_try_cmove_arith.  */
    1981                 :            : 
    1982                 :            : static void
    1983                 :      19551 : noce_emit_all_but_last (basic_block bb)
    1984                 :            : {
    1985                 :      19551 :   rtx_insn *last = last_active_insn (bb, FALSE);
    1986                 :      19551 :   rtx_insn *insn;
    1987                 :     271999 :   FOR_BB_INSNS (bb, insn)
    1988                 :            :     {
    1989                 :     126224 :       if (insn != last && active_insn_p (insn))
    1990                 :            :         {
    1991                 :      42898 :           rtx_insn *to_emit = as_a <rtx_insn *> (copy_rtx (insn));
    1992                 :            : 
    1993                 :      42898 :           emit_insn (PATTERN (to_emit));
    1994                 :            :         }
    1995                 :            :     }
    1996                 :      19551 : }
    1997                 :            : 
    1998                 :            : /* Helper for noce_try_cmove_arith.  Emit the pattern TO_EMIT and return
    1999                 :            :    the resulting insn or NULL if it's not a valid insn.  */
    2000                 :            : 
    2001                 :            : static rtx_insn *
    2002                 :     198555 : noce_emit_insn (rtx to_emit)
    2003                 :            : {
    2004                 :     198555 :   gcc_assert (to_emit);
    2005                 :     198555 :   rtx_insn *insn = emit_insn (to_emit);
    2006                 :            : 
    2007                 :     397110 :   if (recog_memoized (insn) < 0)
    2008                 :         36 :     return NULL;
    2009                 :            : 
    2010                 :            :   return insn;
    2011                 :            : }
    2012                 :            : 
    2013                 :            : /* Helper for noce_try_cmove_arith.  Emit a copy of the insns up to
    2014                 :            :    and including the penultimate one in BB if it is not simple
    2015                 :            :    (as indicated by SIMPLE).  Then emit LAST_INSN as the last
    2016                 :            :    insn in the block.  The reason for that is that LAST_INSN may
    2017                 :            :    have been modified by the preparation in noce_try_cmove_arith.  */
    2018                 :            : 
    2019                 :            : static bool
    2020                 :     201236 : noce_emit_bb (rtx last_insn, basic_block bb, bool simple)
    2021                 :            : {
    2022                 :     201236 :   if (bb && !simple)
    2023                 :      19551 :     noce_emit_all_but_last (bb);
    2024                 :            : 
    2025                 :     201236 :   if (last_insn && !noce_emit_insn (last_insn))
    2026                 :         36 :     return false;
    2027                 :            : 
    2028                 :            :   return true;
    2029                 :            : }
    2030                 :            : 
    2031                 :            : /* Try more complex cases involving conditional_move.  */
    2032                 :            : 
    2033                 :            : static int
    2034                 :     152560 : noce_try_cmove_arith (struct noce_if_info *if_info)
    2035                 :            : {
    2036                 :     152560 :   rtx a = if_info->a;
    2037                 :     152560 :   rtx b = if_info->b;
    2038                 :     152560 :   rtx x = if_info->x;
    2039                 :     152560 :   rtx orig_a, orig_b;
    2040                 :     152560 :   rtx_insn *insn_a, *insn_b;
    2041                 :     152560 :   bool a_simple = if_info->then_simple;
    2042                 :     152560 :   bool b_simple = if_info->else_simple;
    2043                 :     152560 :   basic_block then_bb = if_info->then_bb;
    2044                 :     152560 :   basic_block else_bb = if_info->else_bb;
    2045                 :     152560 :   rtx target;
    2046                 :     152560 :   int is_mem = 0;
    2047                 :     152560 :   enum rtx_code code;
    2048                 :     152560 :   rtx cond = if_info->cond;
    2049                 :     152560 :   rtx_insn *ifcvt_seq;
    2050                 :            : 
    2051                 :            :   /* A conditional move from two memory sources is equivalent to a
    2052                 :            :      conditional on their addresses followed by a load.  Don't do this
    2053                 :            :      early because it'll screw alias analysis.  Note that we've
    2054                 :            :      already checked for no side effects.  */
    2055                 :     152560 :   if (cse_not_expected
    2056                 :      49664 :       && MEM_P (a) && MEM_P (b)
    2057                 :     156872 :       && MEM_ADDR_SPACE (a) == MEM_ADDR_SPACE (b))
    2058                 :            :     {
    2059                 :       4312 :       machine_mode address_mode = get_address_mode (a);
    2060                 :            : 
    2061                 :       4312 :       a = XEXP (a, 0);
    2062                 :       4312 :       b = XEXP (b, 0);
    2063                 :       4312 :       x = gen_reg_rtx (address_mode);
    2064                 :       4312 :       is_mem = 1;
    2065                 :            :     }
    2066                 :            : 
    2067                 :            :   /* ??? We could handle this if we knew that a load from A or B could
    2068                 :            :      not trap or fault.  This is also true if we've already loaded
    2069                 :            :      from the address along the path from ENTRY.  */
    2070                 :     148248 :   else if (may_trap_or_fault_p (a) || may_trap_or_fault_p (b))
    2071                 :      39146 :     return FALSE;
    2072                 :            : 
    2073                 :            :   /* if (test) x = a + b; else x = c - d;
    2074                 :            :      => y = a + b;
    2075                 :            :         x = c - d;
    2076                 :            :         if (test)
    2077                 :            :           x = y;
    2078                 :            :   */
    2079                 :            : 
    2080                 :     113414 :   code = GET_CODE (cond);
    2081                 :     113414 :   insn_a = if_info->insn_a;
    2082                 :     113414 :   insn_b = if_info->insn_b;
    2083                 :            : 
    2084                 :     113414 :   machine_mode x_mode = GET_MODE (x);
    2085                 :            : 
    2086                 :     113414 :   if (!can_conditionally_move_p (x_mode))
    2087                 :            :     return FALSE;
    2088                 :            : 
    2089                 :            :   /* Possibly rearrange operands to make things come out more natural.  */
    2090                 :     201288 :   if (noce_reversed_cond_code (if_info) != UNKNOWN)
    2091                 :            :     {
    2092                 :     100644 :       int reversep = 0;
    2093                 :     100644 :       if (rtx_equal_p (b, x))
    2094                 :            :         reversep = 1;
    2095                 :      50359 :       else if (general_operand (b, GET_MODE (b)))
    2096                 :            :         reversep = 1;
    2097                 :            : 
    2098                 :            :       if (reversep)
    2099                 :            :         {
    2100                 :      94071 :           if (if_info->rev_cond)
    2101                 :            :             {
    2102                 :      94071 :               cond = if_info->rev_cond;
    2103                 :      94071 :               code = GET_CODE (cond);
    2104                 :            :             }
    2105                 :            :           else
    2106                 :          0 :             code = reversed_comparison_code (cond, if_info->jump);
    2107                 :     100644 :           std::swap (a, b);
    2108                 :     100644 :           std::swap (insn_a, insn_b);
    2109                 :     100644 :           std::swap (a_simple, b_simple);
    2110                 :     100644 :           std::swap (then_bb, else_bb);
    2111                 :            :         }
    2112                 :            :     }
    2113                 :            : 
    2114                 :      25731 :   if (then_bb && else_bb
    2115                 :     125385 :       && (!bbs_ok_for_cmove_arith (then_bb, else_bb,  if_info->orig_x)
    2116                 :      24722 :           || !bbs_ok_for_cmove_arith (else_bb, then_bb,  if_info->orig_x)))
    2117                 :         19 :     return FALSE;
    2118                 :            : 
    2119                 :     100625 :   start_sequence ();
    2120                 :            : 
    2121                 :            :   /* If one of the blocks is empty then the corresponding B or A value
    2122                 :            :      came from the test block.  The non-empty complex block that we will
    2123                 :            :      emit might clobber the register used by B or A, so move it to a pseudo
    2124                 :            :      first.  */
    2125                 :            : 
    2126                 :     100625 :   rtx tmp_a = NULL_RTX;
    2127                 :     100625 :   rtx tmp_b = NULL_RTX;
    2128                 :            : 
    2129                 :     100625 :   if (b_simple || !else_bb)
    2130                 :      83102 :     tmp_b = gen_reg_rtx (x_mode);
    2131                 :            : 
    2132                 :     100625 :   if (a_simple || !then_bb)
    2133                 :      98597 :     tmp_a = gen_reg_rtx (x_mode);
    2134                 :            : 
    2135                 :     100625 :   orig_a = a;
    2136                 :     100625 :   orig_b = b;
    2137                 :            : 
    2138                 :     100625 :   rtx emit_a = NULL_RTX;
    2139                 :     100625 :   rtx emit_b = NULL_RTX;
    2140                 :     100625 :   rtx_insn *tmp_insn = NULL;
    2141                 :     100625 :   bool modified_in_a = false;
    2142                 :     100625 :   bool modified_in_b = false;
    2143                 :            :   /* If either operand is complex, load it into a register first.
    2144                 :            :      The best way to do this is to copy the original insn.  In this
    2145                 :            :      way we preserve any clobbers etc that the insn may have had.
    2146                 :            :      This is of course not possible in the IS_MEM case.  */
    2147                 :            : 
    2148                 :     100625 :   if (! general_operand (a, GET_MODE (a)) || tmp_a)
    2149                 :            :     {
    2150                 :            : 
    2151                 :     100095 :       if (is_mem)
    2152                 :            :         {
    2153                 :       4312 :           rtx reg = gen_reg_rtx (GET_MODE (a));
    2154                 :       4312 :           emit_a = gen_rtx_SET (reg, a);
    2155                 :            :         }
    2156                 :            :       else
    2157                 :            :         {
    2158                 :      95783 :           if (insn_a)
    2159                 :            :             {
    2160                 :      45438 :               a = tmp_a ? tmp_a : gen_reg_rtx (GET_MODE (a));
    2161                 :            : 
    2162                 :      45438 :               rtx_insn *copy_of_a = as_a <rtx_insn *> (copy_rtx (insn_a));
    2163                 :      45438 :               rtx set = single_set (copy_of_a);
    2164                 :      45438 :               SET_DEST (set) = a;
    2165                 :            : 
    2166                 :      45438 :               emit_a = PATTERN (copy_of_a);
    2167                 :            :             }
    2168                 :            :           else
    2169                 :            :             {
    2170                 :      50345 :               rtx tmp_reg = tmp_a ? tmp_a : gen_reg_rtx (GET_MODE (a));
    2171                 :      50345 :               emit_a = gen_rtx_SET (tmp_reg, a);
    2172                 :      50345 :               a = tmp_reg;
    2173                 :            :             }
    2174                 :            :         }
    2175                 :            :     }
    2176                 :            : 
    2177                 :     100625 :   if (! general_operand (b, GET_MODE (b)) || tmp_b)
    2178                 :            :     {
    2179                 :      98474 :       if (is_mem)
    2180                 :            :         {
    2181                 :       4312 :           rtx reg = gen_reg_rtx (GET_MODE (b));
    2182                 :       4312 :           emit_b = gen_rtx_SET (reg, b);
    2183                 :            :         }
    2184                 :            :       else
    2185                 :            :         {
    2186                 :      94162 :           if (insn_b)
    2187                 :            :             {
    2188                 :      94143 :               b = tmp_b ? tmp_b : gen_reg_rtx (GET_MODE (b));
    2189                 :      94143 :               rtx_insn *copy_of_b = as_a <rtx_insn *> (copy_rtx (insn_b));
    2190                 :      94143 :               rtx set = single_set (copy_of_b);
    2191                 :            : 
    2192                 :      94143 :               SET_DEST (set) = b;
    2193                 :      94143 :               emit_b = PATTERN (copy_of_b);
    2194                 :            :             }
    2195                 :            :           else
    2196                 :            :             {
    2197                 :         19 :               rtx tmp_reg = tmp_b ? tmp_b : gen_reg_rtx (GET_MODE (b));
    2198                 :         19 :               emit_b = gen_rtx_SET (tmp_reg, b);
    2199                 :         19 :               b = tmp_reg;
    2200                 :            :             }
    2201                 :            :         }
    2202                 :            :     }
    2203                 :            : 
    2204                 :     100625 :   modified_in_a = emit_a != NULL_RTX && modified_in_p (orig_b, emit_a);
    2205                 :     100625 :   if (tmp_b && then_bb)
    2206                 :            :     {
    2207                 :     141731 :       FOR_BB_INSNS (then_bb, tmp_insn)
    2208                 :            :         /* Don't check inside insn_a.  We will have changed it to emit_a
    2209                 :            :            with a destination that doesn't conflict.  */
    2210                 :      61504 :         if (!(insn_a && tmp_insn == insn_a)
    2211                 :     104285 :             && modified_in_p (orig_b, tmp_insn))
    2212                 :            :           {
    2213                 :            :             modified_in_a = true;
    2214                 :            :             break;
    2215                 :            :           }
    2216                 :            : 
    2217                 :            :     }
    2218                 :            : 
    2219                 :     100625 :   modified_in_b = emit_b != NULL_RTX && modified_in_p (orig_a, emit_b);
    2220                 :     100625 :   if (tmp_a && else_bb)
    2221                 :            :     {
    2222                 :     716006 :       FOR_BB_INSNS (else_bb, tmp_insn)
    2223                 :            :       /* Don't check inside insn_b.  We will have changed it to emit_b
    2224                 :            :          with a destination that doesn't conflict.  */
    2225                 :     309038 :       if (!(insn_b && tmp_insn == insn_b)
    2226                 :     520146 :           && modified_in_p (orig_a, tmp_insn))
    2227                 :            :         {
    2228                 :            :           modified_in_b = true;
    2229                 :            :           break;
    2230                 :            :         }
    2231                 :            :     }
    2232                 :            : 
    2233                 :            :   /* If insn to set up A clobbers any registers B depends on, try to
    2234                 :            :      swap insn that sets up A with the one that sets up B.  If even
    2235                 :            :      that doesn't help, punt.  */
    2236                 :     100625 :   if (modified_in_a && !modified_in_b)
    2237                 :            :     {
    2238                 :          0 :       if (!noce_emit_bb (emit_b, else_bb, b_simple))
    2239                 :          0 :         goto end_seq_and_fail;
    2240                 :            : 
    2241                 :          0 :       if (!noce_emit_bb (emit_a, then_bb, a_simple))
    2242                 :          0 :         goto end_seq_and_fail;
    2243                 :            :     }
    2244                 :     100625 :   else if (!modified_in_a)
    2245                 :            :     {
    2246                 :     100625 :       if (!noce_emit_bb (emit_a, then_bb, a_simple))
    2247                 :         14 :         goto end_seq_and_fail;
    2248                 :            : 
    2249                 :     100611 :       if (!noce_emit_bb (emit_b, else_bb, b_simple))
    2250                 :         22 :         goto end_seq_and_fail;
    2251                 :            :     }
    2252                 :            :   else
    2253                 :          0 :     goto end_seq_and_fail;
    2254                 :            : 
    2255                 :     100589 :   target = noce_emit_cmove (if_info, x, code, XEXP (cond, 0), XEXP (cond, 1),
    2256                 :            :                             a, b);
    2257                 :            : 
    2258                 :     100589 :   if (! target)
    2259                 :      17731 :     goto end_seq_and_fail;
    2260                 :            : 
    2261                 :            :   /* If we're handling a memory for above, emit the load now.  */
    2262                 :      82858 :   if (is_mem)
    2263                 :            :     {
    2264                 :       2265 :       rtx mem = gen_rtx_MEM (GET_MODE (if_info->x), target);
    2265                 :            : 
    2266                 :            :       /* Copy over flags as appropriate.  */
    2267                 :       2265 :       if (MEM_VOLATILE_P (if_info->a) || MEM_VOLATILE_P (if_info->b))
    2268                 :          0 :         MEM_VOLATILE_P (mem) = 1;
    2269                 :       2265 :       if (MEM_ALIAS_SET (if_info->a) == MEM_ALIAS_SET (if_info->b))
    2270                 :       2173 :         set_mem_alias_set (mem, MEM_ALIAS_SET (if_info->a));
    2271                 :       2265 :       set_mem_align (mem,
    2272                 :       2265 :                      MIN (MEM_ALIGN (if_info->a), MEM_ALIGN (if_info->b)));
    2273                 :            : 
    2274                 :       2265 :       gcc_assert (MEM_ADDR_SPACE (if_info->a) == MEM_ADDR_SPACE (if_info->b));
    2275                 :       2265 :       set_mem_addr_space (mem, MEM_ADDR_SPACE (if_info->a));
    2276                 :            : 
    2277                 :       2265 :       noce_emit_move_insn (if_info->x, mem);
    2278                 :            :     }
    2279                 :      80593 :   else if (target != x)
    2280                 :          0 :     noce_emit_move_insn (x, target);
    2281                 :            : 
    2282                 :      82858 :   ifcvt_seq = end_ifcvt_sequence (if_info);
    2283                 :      82858 :   if (!ifcvt_seq || !targetm.noce_conversion_profitable_p (ifcvt_seq, if_info))
    2284                 :      56953 :     return FALSE;
    2285                 :            : 
    2286                 :      25905 :   emit_insn_before_setloc (ifcvt_seq, if_info->jump,
    2287                 :      25905 :                            INSN_LOCATION (if_info->insn_a));
    2288                 :      25905 :   if_info->transform_name = "noce_try_cmove_arith";
    2289                 :      25905 :   return TRUE;
    2290                 :            : 
    2291                 :      17767 :  end_seq_and_fail:
    2292                 :      17767 :   end_sequence ();
    2293                 :      17767 :   return FALSE;
    2294                 :            : }
    2295                 :            : 
    2296                 :            : /* For most cases, the simplified condition we found is the best
    2297                 :            :    choice, but this is not the case for the min/max/abs transforms.
    2298                 :            :    For these we wish to know that it is A or B in the condition.  */
    2299                 :            : 
    2300                 :            : static rtx
    2301                 :     119055 : noce_get_alt_condition (struct noce_if_info *if_info, rtx target,
    2302                 :            :                         rtx_insn **earliest)
    2303                 :            : {
    2304                 :     119055 :   rtx cond, set;
    2305                 :     119055 :   rtx_insn *insn;
    2306                 :     119055 :   int reverse;
    2307                 :            : 
    2308                 :            :   /* If target is already mentioned in the known condition, return it.  */
    2309                 :     119055 :   if (reg_mentioned_p (target, if_info->cond))
    2310                 :            :     {
    2311                 :       9122 :       *earliest = if_info->cond_earliest;
    2312                 :       9122 :       return if_info->cond;
    2313                 :            :     }
    2314                 :            : 
    2315                 :     109933 :   set = pc_set (if_info->jump);
    2316                 :     109933 :   cond = XEXP (SET_SRC (set), 0);
    2317                 :     109933 :   reverse
    2318                 :     219866 :     = GET_CODE (XEXP (SET_SRC (set), 2)) == LABEL_REF
    2319                 :     109933 :       && label_ref_label (XEXP (SET_SRC (set), 2)) == JUMP_LABEL (if_info->jump);
    2320                 :     109933 :   if (if_info->then_else_reversed)
    2321                 :      11308 :     reverse = !reverse;
    2322                 :            : 
    2323                 :            :   /* If we're looking for a constant, try to make the conditional
    2324                 :            :      have that constant in it.  There are two reasons why it may
    2325                 :            :      not have the constant we want:
    2326                 :            : 
    2327                 :            :      1. GCC may have needed to put the constant in a register, because
    2328                 :            :         the target can't compare directly against that constant.  For
    2329                 :            :         this case, we look for a SET immediately before the comparison
    2330                 :            :         that puts a constant in that register.
    2331                 :            : 
    2332                 :            :      2. GCC may have canonicalized the conditional, for example
    2333                 :            :         replacing "if x < 4" with "if x <= 3".  We can undo that (or
    2334                 :            :         make equivalent types of changes) to get the constants we need
    2335                 :            :         if they're off by one in the right direction.  */
    2336                 :            : 
    2337                 :     109933 :   if (CONST_INT_P (target))
    2338                 :            :     {
    2339                 :      25141 :       enum rtx_code code = GET_CODE (if_info->cond);
    2340                 :      25141 :       rtx op_a = XEXP (if_info->cond, 0);
    2341                 :      25141 :       rtx op_b = XEXP (if_info->cond, 1);
    2342                 :      25141 :       rtx_insn *prev_insn;
    2343                 :            : 
    2344                 :            :       /* First, look to see if we put a constant in a register.  */
    2345                 :      25141 :       prev_insn = prev_nonnote_insn (if_info->cond_earliest);
    2346                 :      25141 :       if (prev_insn
    2347                 :      25054 :           && BLOCK_FOR_INSN (prev_insn)
    2348                 :      25054 :              == BLOCK_FOR_INSN (if_info->cond_earliest)
    2349                 :      22554 :           && INSN_P (prev_insn)
    2350                 :      46222 :           && GET_CODE (PATTERN (prev_insn)) == SET)
    2351                 :            :         {
    2352                 :       8940 :           rtx src = find_reg_equal_equiv_note (prev_insn);
    2353                 :       8940 :           if (!src)
    2354                 :       8902 :             src = SET_SRC (PATTERN (prev_insn));
    2355                 :       8940 :           if (CONST_INT_P (src))
    2356                 :            :             {
    2357                 :       2524 :               if (rtx_equal_p (op_a, SET_DEST (PATTERN (prev_insn))))
    2358                 :            :                 op_a = src;
    2359                 :       2520 :               else if (rtx_equal_p (op_b, SET_DEST (PATTERN (prev_insn))))
    2360                 :        313 :                 op_b = src;
    2361                 :            : 
    2362                 :       2524 :               if (CONST_INT_P (op_a))
    2363                 :            :                 {
    2364                 :          4 :                   std::swap (op_a, op_b);
    2365                 :          4 :                   code = swap_condition (code);
    2366                 :            :                 }
    2367                 :            :             }
    2368                 :            :         }
    2369                 :            : 
    2370                 :            :       /* Now, look to see if we can get the right constant by
    2371                 :            :          adjusting the conditional.  */
    2372                 :      25141 :       if (CONST_INT_P (op_b))
    2373                 :            :         {
    2374                 :      17333 :           HOST_WIDE_INT desired_val = INTVAL (target);
    2375                 :      17333 :           HOST_WIDE_INT actual_val = INTVAL (op_b);
    2376                 :            : 
    2377                 :      17333 :           switch (code)
    2378                 :            :             {
    2379                 :        803 :             case LT:
    2380                 :        803 :               if (desired_val != HOST_WIDE_INT_MAX
    2381                 :        797 :                   && actual_val == desired_val + 1)
    2382                 :            :                 {
    2383                 :        265 :                   code = LE;
    2384                 :        265 :                   op_b = GEN_INT (desired_val);
    2385                 :            :                 }
    2386                 :            :               break;
    2387                 :          3 :             case LE:
    2388                 :          3 :               if (desired_val != HOST_WIDE_INT_MIN
    2389                 :          3 :                   && actual_val == desired_val - 1)
    2390                 :            :                 {
    2391                 :          0 :                   code = LT;
    2392                 :          0 :                   op_b = GEN_INT (desired_val);
    2393                 :            :                 }
    2394                 :            :               break;
    2395                 :       1454 :             case GT:
    2396                 :       1454 :               if (desired_val != HOST_WIDE_INT_MIN
    2397                 :       1448 :                   && actual_val == desired_val - 1)
    2398                 :            :                 {
    2399                 :        431 :                   code = GE;
    2400                 :        431 :                   op_b = GEN_INT (desired_val);
    2401                 :            :                 }
    2402                 :            :               break;
    2403                 :        382 :             case GE:
    2404                 :        382 :               if (desired_val != HOST_WIDE_INT_MAX
    2405                 :        382 :                   && actual_val == desired_val + 1)
    2406                 :            :                 {
    2407                 :          3 :                   code = GT;
    2408                 :          3 :                   op_b = GEN_INT (desired_val);
    2409                 :            :                 }
    2410                 :            :               break;
    2411                 :            :             default:
    2412                 :            :               break;
    2413                 :            :             }
    2414                 :            :         }
    2415                 :            : 
    2416                 :            :       /* If we made any changes, generate a new conditional that is
    2417                 :            :          equivalent to what we started with, but has the right
    2418                 :            :          constants in it.  */
    2419                 :      25141 :       if (code != GET_CODE (if_info->cond)
    2420                 :      24442 :           || op_a != XEXP (if_info->cond, 0)
    2421                 :      24438 :           || op_b != XEXP (if_info->cond, 1))
    2422                 :            :         {
    2423                 :       1007 :           cond = gen_rtx_fmt_ee (code, GET_MODE (cond), op_a, op_b);
    2424                 :       1007 :           *earliest = if_info->cond_earliest;
    2425                 :       1007 :           return cond;
    2426                 :            :         }
    2427                 :            :     }
    2428                 :            : 
    2429                 :     108926 :   cond = canonicalize_condition (if_info->jump, cond, reverse,
    2430                 :            :                                  earliest, target, have_cbranchcc4, true);
    2431                 :     108926 :   if (! cond || ! reg_mentioned_p (target, cond))
    2432                 :     108926 :     return NULL;
    2433                 :            : 
    2434                 :            :   /* We almost certainly searched back to a different place.
    2435                 :            :      Need to re-verify correct lifetimes.  */
    2436                 :            : 
    2437                 :            :   /* X may not be mentioned in the range (cond_earliest, jump].  */
    2438                 :          0 :   for (insn = if_info->jump; insn != *earliest; insn = PREV_INSN (insn))
    2439                 :          0 :     if (INSN_P (insn) && reg_overlap_mentioned_p (if_info->x, PATTERN (insn)))
    2440                 :            :       return NULL;
    2441                 :            : 
    2442                 :            :   /* A and B may not be modified in the range [cond_earliest, jump).  */
    2443                 :          0 :   for (insn = *earliest; insn != if_info->jump; insn = NEXT_INSN (insn))
    2444                 :          0 :     if (INSN_P (insn)
    2445                 :          0 :         && (modified_in_p (if_info->a, insn)
    2446                 :          0 :             || modified_in_p (if_info->b, insn)))
    2447                 :          0 :       return NULL;
    2448                 :            : 
    2449                 :            :   return cond;
    2450                 :            : }
    2451                 :            : 
    2452                 :            : /* Convert "if (a < b) x = a; else x = b;" to "x = min(a, b);", etc.  */
    2453                 :            : 
    2454                 :            : static int
    2455                 :     188853 : noce_try_minmax (struct noce_if_info *if_info)
    2456                 :            : {
    2457                 :     188853 :   rtx cond, target;
    2458                 :     188853 :   rtx_insn *earliest, *seq;
    2459                 :     188853 :   enum rtx_code code, op;
    2460                 :     188853 :   int unsignedp;
    2461                 :            : 
    2462                 :     230019 :   if (!noce_simple_bbs (if_info))
    2463                 :            :     return FALSE;
    2464                 :            : 
    2465                 :            :   /* ??? Reject modes with NaNs or signed zeros since we don't know how
    2466                 :            :      they will be resolved with an SMIN/SMAX.  It wouldn't be too hard
    2467                 :            :      to get the target to tell us...  */
    2468                 :     167119 :   if (HONOR_SIGNED_ZEROS (if_info->x)
    2469                 :     167119 :       || HONOR_NANS (if_info->x))
    2470                 :      49366 :     return FALSE;
    2471                 :            : 
    2472                 :     117753 :   cond = noce_get_alt_condition (if_info, if_info->a, &earliest);
    2473                 :     117753 :   if (!cond)
    2474                 :            :     return FALSE;
    2475                 :            : 
    2476                 :            :   /* Verify the condition is of the form we expect, and canonicalize
    2477                 :            :      the comparison code.  */
    2478                 :       9973 :   code = GET_CODE (cond);
    2479                 :       9973 :   if (rtx_equal_p (XEXP (cond, 0), if_info->a))
    2480                 :            :     {
    2481                 :       4896 :       if (! rtx_equal_p (XEXP (cond, 1), if_info->b))
    2482                 :            :         return FALSE;
    2483                 :            :     }
    2484                 :       5077 :   else if (rtx_equal_p (XEXP (cond, 1), if_info->a))
    2485                 :            :     {
    2486                 :       4583 :       if (! rtx_equal_p (XEXP (cond, 0), if_info->b))
    2487                 :            :         return FALSE;
    2488                 :        406 :       code = swap_condition (code);
    2489                 :            :     }
    2490                 :            :   else
    2491                 :            :     return FALSE;
    2492                 :            : 
    2493                 :            :   /* Determine what sort of operation this is.  Note that the code is for
    2494                 :            :      a taken branch, so the code->operation mapping appears backwards.  */
    2495                 :       2396 :   switch (code)
    2496                 :            :     {
    2497                 :            :     case LT:
    2498                 :            :     case LE:
    2499                 :            :     case UNLT:
    2500                 :            :     case UNLE:
    2501                 :            :       op = SMAX;
    2502                 :            :       unsignedp = 0;
    2503                 :            :       break;
    2504                 :        163 :     case GT:
    2505                 :        163 :     case GE:
    2506                 :        163 :     case UNGT:
    2507                 :        163 :     case UNGE:
    2508                 :        163 :       op = SMIN;
    2509                 :        163 :       unsignedp = 0;
    2510                 :        163 :       break;
    2511                 :         86 :     case LTU:
    2512                 :         86 :     case LEU:
    2513                 :         86 :       op = UMAX;
    2514                 :         86 :       unsignedp = 1;
    2515                 :         86 :       break;
    2516                 :        186 :     case GTU:
    2517                 :        186 :     case GEU:
    2518                 :        186 :       op = UMIN;
    2519                 :        186 :       unsignedp = 1;
    2520                 :        186 :       break;
    2521                 :            :     default:
    2522                 :            :       return FALSE;
    2523                 :            :     }
    2524                 :            : 
    2525                 :       2396 :   start_sequence ();
    2526                 :            : 
    2527                 :       2396 :   target = expand_simple_binop (GET_MODE (if_info->x), op,
    2528                 :            :                                 if_info->a, if_info->b,
    2529                 :            :                                 if_info->x, unsignedp, OPTAB_WIDEN);
    2530                 :       2396 :   if (! target)
    2531                 :            :     {
    2532                 :       2395 :       end_sequence ();
    2533                 :       2395 :       return FALSE;
    2534                 :            :     }
    2535                 :          1 :   if (target != if_info->x)
    2536                 :          0 :     noce_emit_move_insn (if_info->x, target);
    2537                 :            : 
    2538                 :          1 :   seq = end_ifcvt_sequence (if_info);
    2539                 :          1 :   if (!seq)
    2540                 :            :     return FALSE;
    2541                 :            : 
    2542                 :          1 :   emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATION (if_info->insn_a));
    2543                 :          1 :   if_info->cond = cond;
    2544                 :          1 :   if_info->cond_earliest = earliest;
    2545                 :          1 :   if_info->rev_cond = NULL_RTX;
    2546                 :          1 :   if_info->transform_name = "noce_try_minmax";
    2547                 :            : 
    2548                 :          1 :   return TRUE;
    2549                 :            : }
    2550                 :            : 
    2551                 :            : /* Convert "if (a < 0) x = -a; else x = a;" to "x = abs(a);",
    2552                 :            :    "if (a < 0) x = ~a; else x = a;" to "x = one_cmpl_abs(a);",
    2553                 :            :    etc.  */
    2554                 :            : 
    2555                 :            : static int
    2556                 :     188852 : noce_try_abs (struct noce_if_info *if_info)
    2557                 :            : {
    2558                 :     188852 :   rtx cond, target, a, b, c;
    2559                 :     188852 :   rtx_insn *earliest, *seq;
    2560                 :     188852 :   int negate;
    2561                 :     188852 :   bool one_cmpl = false;
    2562                 :            : 
    2563                 :     230017 :   if (!noce_simple_bbs (if_info))
    2564                 :            :     return FALSE;
    2565                 :            : 
    2566                 :            :   /* Reject modes with signed zeros.  */
    2567                 :     167118 :   if (HONOR_SIGNED_ZEROS (if_info->x))
    2568                 :            :     return FALSE;
    2569                 :            : 
    2570                 :            :   /* Recognize A and B as constituting an ABS or NABS.  The canonical
    2571                 :            :      form is a branch around the negation, taken when the object is the
    2572                 :            :      first operand of a comparison against 0 that evaluates to true.  */
    2573                 :     117757 :   a = if_info->a;
    2574                 :     117757 :   b = if_info->b;
    2575                 :     117757 :   if (GET_CODE (a) == NEG && rtx_equal_p (XEXP (a, 0), b))
    2576                 :            :     negate = 0;
    2577                 :     116676 :   else if (GET_CODE (b) == NEG && rtx_equal_p (XEXP (b, 0), a))
    2578                 :            :     {
    2579                 :       1302 :       std::swap (a, b);
    2580                 :            :       negate = 1;
    2581                 :            :     }
    2582                 :     116664 :   else if (GET_CODE (a) == NOT && rtx_equal_p (XEXP (a, 0), b))
    2583                 :            :     {
    2584                 :            :       negate = 0;
    2585                 :            :       one_cmpl = true;
    2586                 :            :     }
    2587                 :     116459 :   else if (GET_CODE (b) == NOT && rtx_equal_p (XEXP (b, 0), a))
    2588                 :            :     {
    2589                 :       1302 :       std::swap (a, b);
    2590                 :            :       negate = 1;
    2591                 :            :       one_cmpl = true;
    2592                 :            :     }
    2593                 :            :   else
    2594                 :     116455 :     return FALSE;
    2595                 :            : 
    2596                 :       1302 :   cond = noce_get_alt_condition (if_info, b, &earliest);
    2597                 :       1302 :   if (!cond)
    2598                 :            :     return FALSE;
    2599                 :            : 
    2600                 :            :   /* Verify the condition is of the form we expect.  */
    2601                 :        156 :   if (rtx_equal_p (XEXP (cond, 0), b))
    2602                 :        154 :     c = XEXP (cond, 1);
    2603                 :          2 :   else if (rtx_equal_p (XEXP (cond, 1), b))
    2604                 :            :     {
    2605                 :          0 :       c = XEXP (cond, 0);
    2606                 :          0 :       negate = !negate;
    2607                 :            :     }
    2608                 :            :   else
    2609                 :            :     return FALSE;
    2610                 :            : 
    2611                 :            :   /* Verify that C is zero.  Search one step backward for a
    2612                 :            :      REG_EQUAL note or a simple source if necessary.  */
    2613                 :        154 :   if (REG_P (c))
    2614                 :            :     {
    2615                 :          0 :       rtx set;
    2616                 :          0 :       rtx_insn *insn = prev_nonnote_insn (earliest);
    2617                 :          0 :       if (insn
    2618                 :          0 :           && BLOCK_FOR_INSN (insn) == BLOCK_FOR_INSN (earliest)
    2619                 :          0 :           && (set = single_set (insn))
    2620                 :          0 :           && rtx_equal_p (SET_DEST (set), c))
    2621                 :            :         {
    2622                 :          0 :           rtx note = find_reg_equal_equiv_note (insn);
    2623                 :          0 :           if (note)
    2624                 :          0 :             c = XEXP (note, 0);
    2625                 :            :           else
    2626                 :          0 :             c = SET_SRC (set);
    2627                 :            :         }
    2628                 :            :       else
    2629                 :          0 :         return FALSE;
    2630                 :            :     }
    2631                 :        154 :   if (MEM_P (c)
    2632                 :          0 :       && GET_CODE (XEXP (c, 0)) == SYMBOL_REF
    2633                 :        154 :       && CONSTANT_POOL_ADDRESS_P (XEXP (c, 0)))
    2634                 :          0 :     c = get_pool_constant (XEXP (c, 0));
    2635                 :            : 
    2636                 :            :   /* Work around funny ideas get_condition has wrt canonicalization.
    2637                 :            :      Note that these rtx constants are known to be CONST_INT, and
    2638                 :            :      therefore imply integer comparisons.
    2639                 :            :      The one_cmpl case is more complicated, as we want to handle
    2640                 :            :      only x < 0 ? ~x : x or x >= 0 ? x : ~x to one_cmpl_abs (x)
    2641                 :            :      and x < 0 ? x : ~x or x >= 0 ? ~x : x to ~one_cmpl_abs (x),
    2642                 :            :      but not other cases (x > -1 is equivalent of x >= 0).  */
    2643                 :        154 :   if (c == constm1_rtx && GET_CODE (cond) == GT)
    2644                 :            :     ;
    2645                 :         73 :   else if (c == const1_rtx && GET_CODE (cond) == LT)
    2646                 :            :     {
    2647                 :         38 :       if (one_cmpl)
    2648                 :            :         return FALSE;
    2649                 :            :     }
    2650                 :         35 :   else if (c == CONST0_RTX (GET_MODE (b)))
    2651                 :            :     {
    2652                 :         34 :       if (one_cmpl
    2653                 :         32 :           && GET_CODE (cond) != GE
    2654                 :         32 :           && GET_CODE (cond) != LT)
    2655                 :            :         return FALSE;
    2656                 :            :     }
    2657                 :            :   else
    2658                 :            :     return FALSE;
    2659                 :            : 
    2660                 :            :   /* Determine what sort of operation this is.  */
    2661                 :        108 :   switch (GET_CODE (cond))
    2662                 :            :     {
    2663                 :         27 :     case LT:
    2664                 :         27 :     case LE:
    2665                 :         27 :     case UNLT:
    2666                 :         27 :     case UNLE:
    2667                 :         27 :       negate = !negate;
    2668                 :         27 :       break;
    2669                 :            :     case GT:
    2670                 :            :     case GE:
    2671                 :            :     case UNGT:
    2672                 :            :     case UNGE:
    2673                 :            :       break;
    2674                 :            :     default:
    2675                 :            :       return FALSE;
    2676                 :            :     }
    2677                 :            : 
    2678                 :        108 :   start_sequence ();
    2679                 :        108 :   if (one_cmpl)
    2680                 :         41 :     target = expand_one_cmpl_abs_nojump (GET_MODE (if_info->x), b,
    2681                 :            :                                          if_info->x);
    2682                 :            :   else
    2683                 :         67 :     target = expand_abs_nojump (GET_MODE (if_info->x), b, if_info->x, 1);
    2684                 :            : 
    2685                 :            :   /* ??? It's a quandary whether cmove would be better here, especially
    2686                 :            :      for integers.  Perhaps combine will clean things up.  */
    2687                 :        108 :   if (target && negate)
    2688                 :            :     {
    2689                 :         23 :       if (one_cmpl)
    2690                 :         15 :         target = expand_simple_unop (GET_MODE (target), NOT, target,
    2691                 :            :                                      if_info->x, 0);
    2692                 :            :       else
    2693                 :          8 :         target = expand_simple_unop (GET_MODE (target), NEG, target,
    2694                 :            :                                      if_info->x, 0);
    2695                 :            :     }
    2696                 :            : 
    2697                 :        108 :   if (! target)
    2698                 :            :     {
    2699                 :          0 :       end_sequence ();
    2700                 :          0 :       return FALSE;
    2701                 :            :     }
    2702                 :            : 
    2703                 :        108 :   if (target != if_info->x)
    2704                 :          0 :     noce_emit_move_insn (if_info->x, target);
    2705                 :            : 
    2706                 :        108 :   seq = end_ifcvt_sequence (if_info);
    2707                 :        108 :   if (!seq)
    2708                 :            :     return FALSE;
    2709                 :            : 
    2710                 :        108 :   emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATION (if_info->insn_a));
    2711                 :        108 :   if_info->cond = cond;
    2712                 :        108 :   if_info->cond_earliest = earliest;
    2713                 :        108 :   if_info->rev_cond = NULL_RTX;
    2714                 :        108 :   if_info->transform_name = "noce_try_abs";
    2715                 :            : 
    2716                 :        108 :   return TRUE;
    2717                 :            : }
    2718                 :            : 
    2719                 :            : /* Convert "if (m < 0) x = b; else x = 0;" to "x = (m >> C) & b;".  */
    2720                 :            : 
    2721                 :            : static int
    2722                 :     126655 : noce_try_sign_mask (struct noce_if_info *if_info)
    2723                 :            : {
    2724                 :     126655 :   rtx cond, t, m, c;
    2725                 :     126655 :   rtx_insn *seq;
    2726                 :     126655 :   machine_mode mode;
    2727                 :     126655 :   enum rtx_code code;
    2728                 :     126655 :   bool t_unconditional;
    2729                 :            : 
    2730                 :     145128 :   if (!noce_simple_bbs (if_info))
    2731                 :            :     return FALSE;
    2732                 :            : 
    2733                 :     110356 :   cond = if_info->cond;
    2734                 :     110356 :   code = GET_CODE (cond);
    2735                 :     110356 :   m = XEXP (cond, 0);
    2736                 :     110356 :   c = XEXP (cond, 1);
    2737                 :            : 
    2738                 :     110356 :   t = NULL_RTX;
    2739                 :     110356 :   if (if_info->a == const0_rtx)
    2740                 :            :     {
    2741                 :       2330 :       if ((code == LT && c == const0_rtx)
    2742                 :       2323 :           || (code == LE && c == constm1_rtx))
    2743                 :          7 :         t = if_info->b;
    2744                 :            :     }
    2745                 :     108026 :   else if (if_info->b == const0_rtx)
    2746                 :            :     {
    2747                 :      11864 :       if ((code == GE && c == const0_rtx)
    2748                 :      11864 :           || (code == GT && c == constm1_rtx))
    2749                 :            :         t = if_info->a;
    2750                 :            :     }
    2751                 :            : 
    2752                 :         52 :   if (! t || side_effects_p (t))
    2753                 :     110304 :     return FALSE;
    2754                 :            : 
    2755                 :            :   /* We currently don't handle different modes.  */
    2756                 :         52 :   mode = GET_MODE (t);
    2757                 :         52 :   if (GET_MODE (m) != mode)
    2758                 :            :     return FALSE;
    2759                 :            : 
    2760                 :            :   /* This is only profitable if T is unconditionally executed/evaluated in the
    2761                 :            :      original insn sequence or T is cheap.  The former happens if B is the
    2762                 :            :      non-zero (T) value and if INSN_B was taken from TEST_BB, or there was no
    2763                 :            :      INSN_B which can happen for e.g. conditional stores to memory.  For the
    2764                 :            :      cost computation use the block TEST_BB where the evaluation will end up
    2765                 :            :      after the transformation.  */
    2766                 :         38 :   t_unconditional =
    2767                 :         19 :     (t == if_info->b
    2768                 :         19 :      && (if_info->insn_b == NULL_RTX
    2769                 :          0 :          || BLOCK_FOR_INSN (if_info->insn_b) == if_info->test_bb));
    2770                 :         38 :   if (!(t_unconditional
    2771                 :         19 :         || (set_src_cost (t, mode, if_info->speed_p)
    2772                 :            :             < COSTS_N_INSNS (2))))
    2773                 :            :     return FALSE;
    2774                 :            : 
    2775                 :          0 :   start_sequence ();
    2776                 :            :   /* Use emit_store_flag to generate "m < 0 ? -1 : 0" instead of expanding
    2777                 :            :      "(signed) m >> 31" directly.  This benefits targets with specialized
    2778                 :            :      insns to obtain the signmask, but still uses ashr_optab otherwise.  */
    2779                 :          0 :   m = emit_store_flag (gen_reg_rtx (mode), LT, m, const0_rtx, mode, 0, -1);
    2780                 :          0 :   t = m ? expand_binop (mode, and_optab, m, t, NULL_RTX, 0, OPTAB_DIRECT)
    2781                 :            :         : NULL_RTX;
    2782                 :            : 
    2783                 :          0 :   if (!t)
    2784                 :            :     {
    2785                 :          0 :       end_sequence ();
    2786                 :          0 :       return FALSE;
    2787                 :            :     }
    2788                 :            : 
    2789                 :          0 :   noce_emit_move_insn (if_info->x, t);
    2790                 :            : 
    2791                 :          0 :   seq = end_ifcvt_sequence (if_info);
    2792                 :          0 :   if (!seq)
    2793                 :            :     return FALSE;
    2794                 :            : 
    2795                 :          0 :   emit_insn_before_setloc (seq, if_info->jump, INSN_LOCATION (if_info->insn_a));
    2796                 :          0 :   if_info->transform_name = "noce_try_sign_mask";
    2797                 :            : 
    2798                 :          0 :   return TRUE;
    2799                 :            : }
    2800                 :            : 
    2801                 :            : 
    2802                 :            : /* Optimize away "if (x & C) x |= C" and similar bit manipulation
    2803                 :            :    transformations.  */
    2804                 :            : 
    2805                 :            : static int
    2806                 :     188853 : noce_try_bitop (struct noce_if_info *if_info)
    2807                 :            : {
    2808                 :     188853 :   rtx cond, x, a, result;
    2809                 :     188853 :   rtx_insn *seq;
    2810                 :     188853 :   scalar_int_mode mode;
    2811                 :     188853 :   enum rtx_code code;
    2812                 :     188853 :   int bitnum;
    2813                 :            : 
    2814                 :     188853 :   x = if_info->x;
    2815                 :     188853 :   cond = if_info->cond;
    2816                 :     188853 :   code = GET_CODE (cond);
    2817                 :            : 
    2818                 :            :   /* Check for an integer operation.  */
    2819                 :     188853 :   if (!is_a <scalar_int_mode> (GET_MODE (x), &mode))
    2820                 :            :     return FALSE;
    2821                 :            : 
    2822                 :     177047 :   if (!noce_simple_bbs (if_info))
    2823                 :            :     return FALSE;
    2824                 :            : 
    2825                 :            :   /* Check for no else condition.  */
    2826                 :     117374 :   if (! rtx_equal_p (x, if_info->b))
    2827                 :            :     return FALSE;
    2828                 :            : 
    2829                 :            :   /* Check for a suitable condition.  */
    2830                 :      66913 :   if (code != NE && code != EQ)
    2831                 :            :     return FALSE;
    2832                 :      51243 :   if (XEXP (cond, 1) != const0_rtx)
    2833                 :            :     return FALSE;
    2834                 :      37628 :   cond = XEXP (cond, 0);
    2835                 :            : 
    2836                 :            :   /* ??? We could also handle AND here.  */
    2837                 :      37628 :   if (GET_CODE (cond) == ZERO_EXTRACT)
    2838                 :            :     {
    2839                 :        741 :       if (XEXP (cond, 1) != const1_rtx
    2840                 :        594 :           || !CONST_INT_P (XEXP (cond, 2))
    2841                 :       1335 :           || ! rtx_equal_p (x, XEXP (cond, 0)))
    2842                 :        738 :         return FALSE;
    2843                 :          3 :       bitnum = INTVAL (XEXP (cond, 2));
    2844                 :          3 :       if (BITS_BIG_ENDIAN)
    2845                 :            :         bitnum = GET_MODE_BITSIZE (mode) - 1 - bitnum;
    2846                 :          3 :       if (bitnum < 0 || bitnum >= HOST_BITS_PER_WIDE_INT)
    2847                 :            :         return FALSE;
    2848                 :            :     }
    2849                 :            :   else
    2850                 :            :     return FALSE;
    2851                 :            : 
    2852                 :          3 :   a = if_info->a;
    2853                 :          3 :   if (GET_CODE (a) == IOR || GET_CODE (a) == XOR)
    2854                 :            :     {
    2855                 :            :       /* Check for "if (X & C) x = x op C".  */
    2856                 :          1 :       if (! rtx_equal_p (x, XEXP (a, 0))
    2857                 :          1 :           || !CONST_INT_P (XEXP (a, 1))
    2858                 :          2 :           || (INTVAL (XEXP (a, 1)) & GET_MODE_MASK (mode))
    2859                 :          1 :              != HOST_WIDE_INT_1U << bitnum)
    2860                 :            :         return FALSE;
    2861                 :            : 
    2862                 :            :       /* if ((x & C) == 0) x |= C; is transformed to x |= C.   */
    2863                 :            :       /* if ((x & C) != 0) x |= C; is transformed to nothing.  */
    2864                 :          0 :       if (GET_CODE (a) == IOR)
    2865                 :          0 :         result = (code == NE) ? a : NULL_RTX;
    2866                 :          0 :       else if (code == NE)
    2867                 :            :         {
    2868                 :            :           /* if ((x & C) == 0) x ^= C; is transformed to x |= C.   */
    2869                 :          0 :           result = gen_int_mode (HOST_WIDE_INT_1 << bitnum, mode);
    2870                 :          0 :           result = simplify_gen_binary (IOR, mode, x, result);
    2871                 :            :         }
    2872                 :            :       else
    2873                 :            :         {
    2874                 :            :           /* if ((x & C) != 0) x ^= C; is transformed to x &= ~C.  */
    2875                 :          0 :           result = gen_int_mode (~(HOST_WIDE_INT_1 << bitnum), mode);
    2876                 :          0 :           result = simplify_gen_binary (AND, mode, x, result);
    2877                 :            :         }
    2878                 :            :     }
    2879                 :          2 :   else if (GET_CODE (a) == AND)
    2880                 :            :     {
    2881                 :            :       /* Check for "if (X & C) x &= ~C".  */
    2882                 :          0 :       if (! rtx_equal_p (x, XEXP (a, 0))
    2883                 :          0 :           || !CONST_INT_P (XEXP (a, 1))
    2884                 :          0 :           || (INTVAL (XEXP (a, 1)) & GET_MODE_MASK (mode))
    2885                 :          0 :              != (~(HOST_WIDE_INT_1 << bitnum) & GET_MODE_MASK (mode)))
    2886                 :            :         return FALSE;
    2887                 :            : 
    2888                 :            :       /* if ((x & C) == 0) x &= ~C; is transformed to nothing.  */
    2889                 :            :       /* if ((x & C) != 0) x &= ~C; is transformed to x &= ~C.  */
    2890                 :          0 :       result = (code == EQ) ? a : NULL_RTX;
    2891                 :            :     }
    2892                 :            :   else
    2893                 :            :     return FALSE;
    2894                 :            : 
    2895                 :          0 :   if (result)
    2896                 :            :     {
    2897                 :          0 :       start_sequence ();
    2898                 :          0 :       noce_emit_move_insn (x, result);
    2899                 :          0 :       seq = end_ifcvt_sequence (if_info);
    2900                 :          0 :       if (!seq)
    2901                 :            :         return FALSE;
    2902                 :            : 
    2903                 :          0 :       emit_insn_before_setloc (seq, if_info->jump,
    2904                 :          0 :                                INSN_LOCATION (if_info->insn_a));
    2905                 :            :     }
    2906                 :          0 :   if_info->transform_name = "noce_try_bitop";
    2907                 :          0 :   return TRUE;
    2908                 :            : }
    2909                 :            : 
    2910                 :            : 
    2911                 :            : /* Similar to get_condition, only the resulting condition must be
    2912                 :            :    valid at JUMP, instead of at EARLIEST.
    2913                 :            : 
    2914                 :            :    If THEN_ELSE_REVERSED is true, the fallthrough does not go to the
    2915                 :            :    THEN block of the caller, and we have to reverse the condition.  */
    2916                 :            : 
    2917                 :            : static rtx
    2918                 :    3154790 : noce_get_condition (rtx_insn *jump, rtx_insn **earliest, bool then_else_reversed)
    2919                 :            : {
    2920                 :    3154790 :   rtx cond, set, tmp;
    2921                 :    3154790 :   bool reverse;
    2922                 :            : 
    2923                 :    3154790 :   if (! any_condjump_p (jump))
    2924                 :            :     return NULL_RTX;
    2925                 :            : 
    2926                 :    3154790 :   set = pc_set (jump);
    2927                 :            : 
    2928                 :            :   /* If this branches to JUMP_LABEL when the condition is false,
    2929                 :            :      reverse the condition.  */
    2930                 :    6309580 :   reverse = (GET_CODE (XEXP (SET_SRC (set), 2)) == LABEL_REF
    2931                 :    3154790 :              && label_ref_label (XEXP (SET_SRC (set), 2)) == JUMP_LABEL (jump));
    2932                 :            : 
    2933                 :            :   /* We may have to reverse because the caller's if block is not canonical,
    2934                 :            :      i.e. the THEN block isn't the fallthrough block for the TEST block
    2935                 :            :      (see find_if_header).  */
    2936                 :    3154790 :   if (then_else_reversed)
    2937                 :    1418580 :     reverse = !reverse;
    2938                 :            : 
    2939                 :            :   /* If the condition variable is a register and is MODE_INT, accept it.  */
    2940                 :            : 
    2941                 :    3154790 :   cond = XEXP (SET_SRC (set), 0);
    2942                 :    3154790 :   tmp = XEXP (cond, 0);
    2943                 :    3154050 :   if (REG_P (tmp) && GET_MODE_CLASS (GET_MODE (tmp)) == MODE_INT
    2944                 :    3154790 :       && (GET_MODE (tmp) != BImode
    2945                 :          0 :           || !targetm.small_register_classes_for_mode_p (BImode)))
    2946                 :            :     {
    2947                 :          0 :       *earliest = jump;
    2948                 :            : 
    2949                 :          0 :       if (reverse)
    2950                 :          0 :         cond = gen_rtx_fmt_ee (reverse_condition (GET_CODE (cond)),
    2951                 :            :                                GET_MODE (cond), tmp, XEXP (cond, 1));
    2952                 :          0 :       return cond;
    2953                 :            :     }
    2954                 :            : 
    2955                 :            :   /* Otherwise, fall back on canonicalize_condition to do the dirty
    2956                 :            :      work of manipulating MODE_CC values and COMPARE rtx codes.  */
    2957                 :    3154790 :   tmp = canonicalize_condition (jump, cond, reverse, earliest,
    2958                 :            :                                 NULL_RTX, have_cbranchcc4, true);
    2959                 :            : 
    2960                 :            :   /* We don't handle side-effects in the condition, like handling
    2961                 :            :      REG_INC notes and making sure no duplicate conditions are emitted.  */
    2962                 :    3154790 :   if (tmp != NULL_RTX && side_effects_p (tmp))
    2963                 :          0 :     return NULL_RTX;
    2964                 :            : 
    2965                 :            :   return tmp;
    2966                 :            : }
    2967                 :            : 
    2968                 :            : /* Return true if OP is ok for if-then-else processing.  */
    2969                 :            : 
    2970                 :            : static int
    2971                 :    5330510 : noce_operand_ok (const_rtx op)
    2972                 :            : {
    2973                 :    5330510 :   if (side_effects_p (op))
    2974                 :            :     return FALSE;
    2975                 :            : 
    2976                 :            :   /* We special-case memories, so handle any of them with
    2977                 :            :      no address side effects.  */
    2978                 :    5312450 :   if (MEM_P (op))
    2979                 :    1191810 :     return ! side_effects_p (XEXP (op, 0));
    2980                 :            : 
    2981                 :    4120640 :   return ! may_trap_p (op);
    2982                 :            : }
    2983                 :            : 
    2984                 :            : /* Return true iff basic block TEST_BB is valid for noce if-conversion.
    2985                 :            :    The condition used in this if-conversion is in COND.
    2986                 :            :    In practice, check that TEST_BB ends with a single set
    2987                 :            :    x := a and all previous computations
    2988                 :            :    in TEST_BB don't produce any values that are live after TEST_BB.
    2989                 :            :    In other words, all the insns in TEST_BB are there only
    2990                 :            :    to compute a value for x.  Add the rtx cost of the insns
    2991                 :            :    in TEST_BB to COST.  Record whether TEST_BB is a single simple
    2992                 :            :    set instruction in SIMPLE_P.  */
    2993                 :            : 
    2994                 :            : static bool
    2995                 :    1622880 : bb_valid_for_noce_process_p (basic_block test_bb, rtx cond,
    2996                 :            :                               unsigned int *cost, bool *simple_p)
    2997                 :            : {
    2998                 :    1622880 :   if (!test_bb)
    2999                 :            :     return false;
    3000                 :            : 
    3001                 :    1622880 :   rtx_insn *last_insn = last_active_insn (test_bb, FALSE);
    3002                 :    1622880 :   rtx last_set = NULL_RTX;
    3003                 :            : 
    3004                 :    1622880 :   rtx cc = cc_in_cond (cond);
    3005                 :            : 
    3006                 :    1622880 :   if (!insn_valid_noce_process_p (last_insn, cc))
    3007                 :            :     return false;
    3008                 :    1145260 :   last_set = single_set (last_insn);
    3009                 :            : 
    3010                 :    1145260 :   rtx x = SET_DEST (last_set);
    3011                 :    1145260 :   rtx_insn *first_insn = first_active_insn (test_bb);
    3012                 :    1145260 :   rtx first_set = single_set (first_insn);
    3013                 :            : 
    3014                 :    1145260 :   if (!first_set)
    3015                 :            :     return false;
    3016                 :            : 
    3017                 :            :   /* We have a single simple set, that's okay.  */
    3018                 :    1120180 :   bool speed_p = optimize_bb_for_speed_p (test_bb);
    3019                 :            : 
    3020                 :    1120180 :   if (first_insn == last_insn)
    3021                 :            :     {
    3022                 :     389117 :       *simple_p = noce_operand_ok (SET_DEST (first_set));
    3023                 :     389117 :       *cost += pattern_cost (first_set, speed_p);
    3024                 :     389117 :       return *simple_p;
    3025                 :            :     }
    3026                 :            : 
    3027                 :     731062 :   rtx_insn *prev_last_insn = PREV_INSN (last_insn);
    3028                 :     731062 :   gcc_assert (prev_last_insn);
    3029                 :            : 
    3030                 :            :   /* For now, disallow setting x multiple times in test_bb.  */
    3031                 :     731062 :   if (REG_P (x) && reg_set_between_p (x, first_insn, prev_last_insn))
    3032                 :            :     return false;
    3033                 :            : 
    3034                 :     596347 :   bitmap test_bb_temps = BITMAP_ALLOC (&reg_obstack);
    3035                 :            : 
    3036                 :            :   /* The regs that are live out of test_bb.  */
    3037                 :     596347 :   bitmap test_bb_live_out = df_get_live_out (test_bb);
    3038                 :            : 
    3039                 :     596347 :   int potential_cost = pattern_cost (last_set, speed_p);
    3040                 :     596347 :   rtx_insn *insn;
    3041                 :    5068000 :   FOR_BB_INSNS (test_bb, insn)
    3042                 :            :     {
    3043                 :    2741180 :       if (insn != last_insn)
    3044                 :            :         {
    3045                 :    2650180 :           if (!active_insn_p (insn))
    3046                 :    1596460 :             continue;
    3047                 :            : 
    3048                 :    1053720 :           if (!insn_valid_noce_process_p (insn, cc))
    3049                 :     155858 :             goto free_bitmap_and_fail;
    3050                 :            : 
    3051                 :     897863 :           rtx sset = single_set (insn);
    3052                 :     897863 :           gcc_assert (sset);
    3053                 :            : 
    3054                 :     897863 :           if (contains_mem_rtx_p (SET_SRC (sset))
    3055                 :     671323 :               || !REG_P (SET_DEST (sset))
    3056                 :    1459100 :               || reg_overlap_mentioned_p (SET_DEST (sset), cond))
    3057                 :     349493 :             goto free_bitmap_and_fail;
    3058                 :            : 
    3059                 :     548370 :           potential_cost += pattern_cost (sset, speed_p);
    3060                 :     548370 :           bitmap_set_bit (test_bb_temps, REGNO (SET_DEST (sset)));
    3061                 :            :         }
    3062                 :            :     }
    3063                 :            : 
    3064                 :            :   /* If any of the intermediate results in test_bb are live after test_bb
    3065                 :            :      then fail.  */
    3066                 :      90996 :   if (bitmap_intersect_p (test_bb_live_out, test_bb_temps))
    3067                 :      55279 :     goto free_bitmap_and_fail;
    3068                 :            : 
    3069                 :      35717 :   BITMAP_FREE (test_bb_temps);
    3070                 :      35717 :   *cost += potential_cost;
    3071                 :      35717 :   *simple_p = false;
    3072                 :      35717 :   return true;
    3073                 :            : 
    3074                 :     560630 :  free_bitmap_and_fail:
    3075                 :     560630 :   BITMAP_FREE (test_bb_temps);
    3076                 :     560630 :   return false;
    3077                 :            : }
    3078                 :            : 
    3079                 :            : /* We have something like:
    3080                 :            : 
    3081                 :            :      if (x > y)
    3082                 :            :        { i = a; j = b; k = c; }
    3083                 :            : 
    3084                 :            :    Make it:
    3085                 :            : 
    3086                 :            :      tmp_i = (x > y) ? a : i;
    3087                 :            :      tmp_j = (x > y) ? b : j;
    3088                 :            :      tmp_k = (x > y) ? c : k;
    3089                 :            :      i = tmp_i;
    3090                 :            :      j = tmp_j;
    3091                 :            :      k = tmp_k;
    3092                 :            : 
    3093                 :            :    Subsequent passes are expected to clean up the extra moves.
    3094                 :            : 
    3095                 :            :    Look for special cases such as writes to one register which are
    3096                 :            :    read back in another SET, as might occur in a swap idiom or
    3097                 :            :    similar.
    3098                 :            : 
    3099                 :            :    These look like:
    3100                 :            : 
    3101                 :            :    if (x > y)
    3102                 :            :      i = a;
    3103                 :            :      j = i;
    3104                 :            : 
    3105                 :            :    Which we want to rewrite to:
    3106                 :            : 
    3107                 :            :      tmp_i = (x > y) ? a : i;
    3108                 :            :      tmp_j = (x > y) ? tmp_i : j;
    3109                 :            :      i = tmp_i;
    3110                 :            :      j = tmp_j;
    3111                 :            : 
    3112                 :            :    We can catch these when looking at (SET x y) by keeping a list of the
    3113                 :            :    registers we would have targeted before if-conversion and looking back
    3114                 :            :    through it for an overlap with Y.  If we find one, we rewire the
    3115                 :            :    conditional set to use the temporary we introduced earlier.
    3116                 :            : 
    3117                 :            :    IF_INFO contains the useful information about the block structure and
    3118                 :            :    jump instructions.  */
    3119                 :            : 
    3120                 :            : static int
    3121                 :       7900 : noce_convert_multiple_sets (struct noce_if_info *if_info)
    3122                 :            : {
    3123                 :       7900 :   basic_block test_bb = if_info->test_bb;
    3124                 :       7900 :   basic_block then_bb = if_info->then_bb;
    3125                 :       7900 :   basic_block join_bb = if_info->join_bb;
    3126                 :       7900 :   rtx_insn *jump = if_info->jump;
    3127                 :       7900 :   rtx_insn *cond_earliest;
    3128                 :       7900 :   rtx_insn *insn;
    3129                 :            : 
    3130                 :       7900 :   start_sequence ();
    3131                 :            : 
    3132                 :            :   /* Decompose the condition attached to the jump.  */
    3133                 :       7900 :   rtx cond = noce_get_condition (jump, &cond_earliest, false);
    3134                 :       7900 :   rtx x = XEXP (cond, 0);
    3135                 :       7900 :   rtx y = XEXP (cond, 1);
    3136                 :       7900 :   rtx_code cond_code = GET_CODE (cond);
    3137                 :            : 
    3138                 :            :   /* The true targets for a conditional move.  */
    3139                 :       7900 :   auto_vec<rtx> targets;
    3140                 :            :   /* The temporaries introduced to allow us to not consider register
    3141                 :            :      overlap.  */
    3142                 :       7900 :   auto_vec<rtx> temporaries;
    3143                 :            :   /* The insns we've emitted.  */
    3144                 :       7900 :   auto_vec<rtx_insn *> unmodified_insns;
    3145                 :       7900 :   int count = 0;
    3146                 :            : 
    3147                 :      42869 :   FOR_BB_INSNS (then_bb, insn)
    3148                 :            :     {
    3149                 :            :       /* Skip over non-insns.  */
    3150                 :      35015 :       if (!active_insn_p (insn))
    3151                 :      12947 :         continue;
    3152                 :            : 
    3153                 :      22068 :       rtx set = single_set (insn);
    3154                 :      22068 :       gcc_checking_assert (set);
    3155                 :            : 
    3156                 :      22068 :       rtx target = SET_DEST (set);
    3157                 :      22068 :       rtx temp = gen_reg_rtx (GET_MODE (target));
    3158                 :      22068 :       rtx new_val = SET_SRC (set);
    3159                 :      22068 :       rtx old_val = target;
    3160                 :            : 
    3161                 :            :       /* If we were supposed to read from an earlier write in this block,
    3162                 :            :          we've changed the register allocation.  Rewire the read.  While
    3163                 :            :          we are looking, also try to catch a swap idiom.  */
    3164                 :      49524 :       for (int i = count - 1; i >= 0; --i)
    3165                 :      29912 :         if (reg_overlap_mentioned_p (new_val, targets[i]))
    3166                 :            :           {
    3167                 :            :             /* Catch a "swap" style idiom.  */
    3168                 :       2456 :             if (find_reg_note (insn, REG_DEAD, new_val) != NULL_RTX)
    3169                 :            :               /* The write to targets[i] is only live until the read
    3170                 :            :                  here.  As the condition codes match, we can propagate
    3171                 :            :                  the set to here.  */
    3172                 :       2411 :               new_val = SET_SRC (single_set (unmodified_insns[i]));
    3173                 :            :             else
    3174                 :         45 :               new_val = temporaries[i];
    3175                 :            :             break;
    3176                 :            :           }
    3177                 :            : 
    3178                 :            :       /* If we had a non-canonical conditional jump (i.e. one where
    3179                 :            :          the fallthrough is to the "else" case) we need to reverse
    3180                 :            :          the conditional select.  */
    3181                 :      22068 :       if (if_info->then_else_reversed)
    3182                 :       6913 :         std::swap (old_val, new_val);
    3183                 :            : 
    3184                 :            : 
    3185                 :            :       /* We allow simple lowpart register subreg SET sources in
    3186                 :            :          bb_ok_for_noce_convert_multiple_sets.  Be careful when processing
    3187                 :            :          sequences like:
    3188                 :            :          (set (reg:SI r1) (reg:SI r2))
    3189                 :            :          (set (reg:HI r3) (subreg:HI (r1)))
    3190                 :            :          For the second insn new_val or old_val (r1 in this example) will be
    3191                 :            :          taken from the temporaries and have the wider mode which will not
    3192                 :            :          match with the mode of the other source of the conditional move, so
    3193                 :            :          we'll end up trying to emit r4:HI = cond ? (r1:SI) : (r3:HI).
    3194                 :            :          Wrap the two cmove operands into subregs if appropriate to prevent
    3195                 :            :          that.  */
    3196                 :      22068 :       if (GET_MODE (new_val) != GET_MODE (temp))
    3197                 :            :         {
    3198                 :          0 :           machine_mode src_mode = GET_MODE (new_val);
    3199                 :          0 :           machine_mode dst_mode = GET_MODE (temp);
    3200                 :          0 :           if (!partial_subreg_p (dst_mode, src_mode))
    3201                 :            :             {
    3202                 :          0 :               end_sequence ();
    3203                 :         46 :               return FALSE;
    3204                 :            :             }
    3205                 :          0 :           new_val = lowpart_subreg (dst_mode, new_val, src_mode);
    3206                 :            :         }
    3207                 :      22068 :       if (GET_MODE (old_val) != GET_MODE (temp))
    3208                 :            :         {
    3209                 :          0 :           machine_mode src_mode = GET_MODE (old_val);
    3210                 :          0 :           machine_mode dst_mode = GET_MODE (temp);
    3211                 :          0 :           if (!partial_subreg_p (dst_mode, src_mode))
    3212                 :            :             {
    3213                 :          0 :               end_sequence ();
    3214                 :          0 :               return FALSE;
    3215                 :            :             }
    3216                 :          0 :           old_val = lowpart_subreg (dst_mode, old_val, src_mode);
    3217                 :            :         }
    3218                 :            : 
    3219                 :            :       /* Actually emit the conditional move.  */
    3220                 :      22068 :       rtx temp_dest = noce_emit_cmove (if_info, temp, cond_code,
    3221                 :      22068 :                                        x, y, new_val, old_val);
    3222                 :            : 
    3223                 :            :       /* If we failed to expand the conditional move, drop out and don't
    3224                 :            :          try to continue.  */
    3225                 :      22068 :       if (temp_dest == NULL_RTX)
    3226                 :            :         {
    3227                 :         46 :           end_sequence ();
    3228                 :         46 :           return FALSE;
    3229                 :            :         }
    3230                 :            : 
    3231                 :            :       /* Bookkeeping.  */
    3232                 :      22022 :       count++;
    3233                 :      22022 :       targets.safe_push (target);
    3234                 :      22022 :       temporaries.safe_push (temp_dest);
    3235                 :      22022 :       unmodified_insns.safe_push (insn);
    3236                 :            :     }
    3237                 :            : 
    3238                 :            :   /* We must have seen some sort of insn to insert, otherwise we were
    3239                 :            :      given an empty BB to convert, and we can't handle that.  */
    3240                 :       7854 :   gcc_assert (!unmodified_insns.is_empty ());
    3241                 :            : 
    3242                 :            :   /* Now fixup the assignments.  */
    3243                 :      29870 :   for (int i = 0; i < count; i++)
    3244                 :      22016 :     noce_emit_move_insn (targets[i], temporaries[i]);
    3245                 :            : 
    3246                 :            :   /* Actually emit the sequence if it isn't too expensive.  */
    3247                 :       7854 :   rtx_insn *seq = get_insns ();
    3248                 :            : 
    3249                 :       7854 :   if (!targetm.noce_conversion_profitable_p (seq, if_info))
    3250                 :            :     {
    3251                 :       7579 :       end_sequence ();
    3252                 :       7579 :       return FALSE;
    3253                 :            :     }
    3254                 :            : 
    3255                 :       1652 :   for (insn = seq; insn; insn = NEXT_INSN (insn))
    3256                 :       1377 :     set_used_flags (insn);
    3257                 :            : 
    3258                 :            :   /* Mark all our temporaries and targets as used.  */
    3259                 :        825 :   for (int i = 0; i < count; i++)
    3260                 :            :     {
    3261                 :        550 :       set_used_flags (temporaries[i]);
    3262                 :        550 :       set_used_flags (targets[i]);
    3263                 :            :     }
    3264                 :            : 
    3265                 :        275 :   set_used_flags (cond);
    3266                 :        275 :   set_used_flags (x);
    3267                 :        275 :   set_used_flags (y);
    3268                 :            : 
    3269                 :        275 :   unshare_all_rtl_in_chain (seq);
    3270                 :        275 :   end_sequence ();
    3271                 :            : 
    3272                 :        275 :   if (!seq)
    3273                 :            :     return FALSE;
    3274                 :            : 
    3275                 :       1652 :   for (insn = seq; insn; insn = NEXT_INSN (insn))
    3276                 :       1377 :     if (JUMP_P (insn)
    3277                 :       2204 :         || recog_memoized (insn) == -1)
    3278                 :          0 :       return FALSE;
    3279                 :            : 
    3280                 :        275 :   emit_insn_before_setloc (seq, if_info->jump,
    3281                 :        275 :                            INSN_LOCATION (unmodified_insns.last ()));
    3282                 :            : 
    3283                 :            :   /* Clean up THEN_BB and the edges in and out of it.  */
    3284                 :        275 :   remove_edge (find_edge (test_bb, join_bb));
    3285                 :        275 :   remove_edge (find_edge (then_bb, join_bb));
    3286                 :        275 :   redirect_edge_and_branch_force (single_succ_edge (test_bb), join_bb);
    3287                 :        275 :   delete_basic_block (then_bb);
    3288                 :        275 :   num_true_changes++;
    3289                 :            : 
    3290                 :            :   /* Maybe merge blocks now the jump is simple enough.  */
    3291                 :        275 :   if (can_merge_blocks_p (test_bb, join_bb))
    3292                 :            :     {
    3293                 :         29 :       merge_blocks (test_bb, join_bb);
    3294                 :         29 :       num_true_changes++;
    3295                 :            :     }
    3296                 :            : 
    3297                 :        275 :   num_updated_if_blocks++;
    3298                 :        275 :   if_info->transform_name = "noce_convert_multiple_sets";
    3299                 :        275 :   return TRUE;
    3300                 :            : }
    3301                 :            : 
    3302                 :            : /* Return true iff basic block TEST_BB is comprised of only
    3303                 :            :    (SET (REG) (REG)) insns suitable for conversion to a series
    3304                 :            :    of conditional moves.  Also check that we have more than one set
    3305                 :            :    (other routines can handle a single set better than we would), and
    3306                 :            :    fewer than PARAM_MAX_RTL_IF_CONVERSION_INSNS sets.  */
    3307                 :            : 
    3308                 :            : static bool
    3309                 :     802202 : bb_ok_for_noce_convert_multiple_sets (basic_block test_bb)
    3310                 :            : {
    3311                 :     802202 :   rtx_insn *insn;
    3312                 :     802202 :   unsigned count = 0;
    3313                 :     802202 :   unsigned param = param_max_rtl_if_conversion_insns;
    3314                 :            : 
    3315                 :    8264300 :   FOR_BB_INSNS (test_bb, insn)
    3316                 :            :     {
    3317                 :            :       /* Skip over notes etc.  */
    3318                 :    4512370 :       if (!active_insn_p (insn))
    3319                 :    3547130 :         continue;
    3320                 :            : 
    3321                 :            :       /* We only handle SET insns.  */
    3322                 :     965234 :       rtx set = single_set (insn);
    3323                 :     965234 :       if (set == NULL_RTX)
    3324                 :            :         return false;
    3325                 :            : 
    3326                 :     882811 :       rtx dest = SET_DEST (set);
    3327                 :     882811 :       rtx src = SET_SRC (set);
    3328                 :            : 
    3329                 :            :       /* We can possibly relax this, but for now only handle REG to REG
    3330                 :            :          (including subreg) moves.  This avoids any issues that might come
    3331                 :            :          from introducing loads/stores that might violate data-race-freedom
    3332                 :            :          guarantees.  */
    3333                 :     882811 :       if (!REG_P (dest))
    3334                 :            :         return false;
    3335                 :            : 
    3336                 :     780431 :       if (!(REG_P (src)
    3337                 :       3113 :            || (GET_CODE (src) == SUBREG && REG_P (SUBREG_REG (src))
    3338                 :       3101 :                && subreg_lowpart_p (src))))
    3339                 :     594951 :         return false;
    3340                 :            : 
    3341                 :            :       /* Destination must be appropriate for a conditional write.  */
    3342                 :     185480 :       if (!noce_operand_ok (dest))
    3343                 :            :         return false;
    3344                 :            : 
    3345                 :            :       /* We must be able to conditionally move in this mode.  */
    3346                 :     185480 :       if (!can_conditionally_move_p (GET_MODE (dest)))
    3347                 :            :         return false;
    3348                 :            : 
    3349                 :     183916 :       count++;
    3350                 :            :     }
    3351                 :            : 
    3352                 :            :   /* If we would only put out one conditional move, the other strategies
    3353                 :            :      this pass tries are better optimized and will be more appropriate.
    3354                 :            :      Some targets want to strictly limit the number of conditional moves
    3355                 :            :      that are emitted, they set this through PARAM, we need to respect
    3356                 :            :      that.  */
    3357                 :      20884 :   return count > 1 && count <= param;
    3358                 :            : }
    3359                 :            : 
    3360                 :            : /* Compute average of two given costs weighted by relative probabilities
    3361                 :            :    of respective basic blocks in an IF-THEN-ELSE.  E is the IF-THEN edge.
    3362                 :            :    With P as the probability to take the IF-THEN branch, return
    3363                 :            :    P * THEN_COST + (1 - P) * ELSE_COST.  */
    3364                 :            : static unsigned
    3365                 :     198923 : average_cost (unsigned then_cost, unsigned else_cost, edge e)
    3366                 :            : {
    3367                 :     198923 :   return else_cost + e->probability.apply ((signed) (then_cost - else_cost));
    3368                 :            : }
    3369                 :            : 
    3370                 :            : /* Given a simple IF-THEN-JOIN or IF-THEN-ELSE-JOIN block, attempt to convert
    3371                 :            :    it without using conditional execution.  Return TRUE if we were successful
    3372                 :            :    at converting the block.  */
    3373                 :            : 
    3374                 :            : static int
    3375                 :    1418580 : noce_process_if_block (struct noce_if_info *if_info)
    3376                 :            : {
    3377                 :    1418580 :   basic_block test_bb = if_info->test_bb;    /* test block */
    3378                 :    1418580 :   basic_block then_bb = if_info->then_bb;    /* THEN */
    3379                 :    1418580 :   basic_block else_bb = if_info->else_bb;    /* ELSE or NULL */
    3380                 :    1418580 :   basic_block join_bb = if_info->join_bb;    /* JOIN */
    3381                 :    1418580 :   rtx_insn *jump = if_info->jump;
    3382                 :    1418580 :   rtx cond = if_info->cond;
    3383                 :    1418580 :   rtx_insn *insn_a, *insn_b;
    3384                 :    1418580 :   rtx set_a, set_b;
    3385                 :    1418580 :   rtx orig_x, x, a, b;
    3386                 :            : 
    3387                 :            :   /* We're looking for patterns of the form
    3388                 :            : 
    3389                 :            :      (1) if (...) x = a; else x = b;
    3390                 :            :      (2) x = b; if (...) x = a;
    3391                 :            :      (3) if (...) x = a;   // as if with an initial x = x.
    3392                 :            :      (4) if (...) { x = a; y = b; z = c; }  // Like 3, for multiple SETS.
    3393                 :            :      The later patterns require jumps to be more expensive.
    3394                 :            :      For the if (...) x = a; else x = b; case we allow multiple insns
    3395                 :            :      inside the then and else blocks as long as their only effect is
    3396                 :            :      to calculate a value for x.
    3397                 :            :      ??? For future expansion, further expand the "multiple X" rules.  */
    3398                 :            : 
    3399                 :            :   /* First look for multiple SETS.  */
    3400                 :    1418580 :   if (!else_bb
    3401                 :            :       && HAVE_conditional_move
    3402                 :            :       && !HAVE_cc0
    3403                 :    1418580 :       && bb_ok_for_noce_convert_multiple_sets (then_bb))
    3404                 :            :     {
    3405                 :       7900 :       if (noce_convert_multiple_sets (if_info))
    3406                 :            :         {
    3407                 :        275 :           if (dump_file && if_info->transform_name)
    3408                 :          1 :             fprintf (dump_file, "if-conversion succeeded through %s\n",
    3409                 :            :                      if_info->transform_name);
    3410                 :        275 :           return TRUE;
    3411                 :            :         }
    3412                 :            :     }
    3413                 :            : 
    3414                 :    1418310 :   bool speed_p = optimize_bb_for_speed_p (test_bb);
    3415                 :    1418310 :   unsigned int then_cost = 0, else_cost = 0;
    3416                 :    1418310 :   if (!bb_valid_for_noce_process_p (then_bb, cond, &then_cost,
    3417                 :            :                                     &if_info->then_simple))
    3418                 :            :     return false;
    3419                 :            : 
    3420                 :     368012 :   if (else_bb
    3421                 :     368012 :       && !bb_valid_for_noce_process_p (else_bb, cond, &else_cost,
    3422                 :            :                                        &if_info->else_simple))
    3423                 :            :     return false;
    3424                 :            : 
    3425                 :     220263 :   if (speed_p)
    3426                 :     198923 :     if_info->original_cost += average_cost (then_cost, else_cost,
    3427                 :            :                                             find_edge (test_bb, then_bb));
    3428                 :            :   else
    3429                 :      21340 :     if_info->original_cost += then_cost + else_cost;
    3430                 :            : 
    3431                 :     220263 :   insn_a = last_active_insn (then_bb, FALSE);
    3432                 :     220263 :   set_a = single_set (insn_a);
    3433                 :     220263 :   gcc_assert (set_a);
    3434                 :            : 
    3435                 :     220263 :   x = SET_DEST (set_a);
    3436                 :     220263 :   a = SET_SRC (set_a);
    3437                 :            : 
    3438                 :            :   /* Look for the other potential set.  Make sure we've got equivalent
    3439                 :            :      destinations.  */
    3440                 :            :   /* ??? This is overconservative.  Storing to two different mems is
    3441                 :            :      as easy as conditionally computing the address.  Storing to a
    3442                 :            :      single mem merely requires a scratch memory to use as one of the
    3443                 :            :      destination addresses; often the memory immediately below the
    3444                 :            :      stack pointer is available for this.  */
    3445                 :     220263 :   set_b = NULL_RTX;
    3446                 :     220263 :   if (else_bb)
    3447                 :            :     {
    3448                 :      56822 :       insn_b = last_active_insn (else_bb, FALSE);
    3449                 :      56822 :       set_b = single_set (insn_b);
    3450                 :      56822 :       gcc_assert (set_b);
    3451                 :            : 
    3452                 :      56822 :       if (!rtx_interchangeable_p (x, SET_DEST (set_b)))
    3453                 :            :         return FALSE;
    3454                 :            :     }
    3455                 :            :   else
    3456                 :            :     {
    3457                 :     163441 :       insn_b = if_info->cond_earliest;
    3458                 :     396548 :       do
    3459                 :     396548 :         insn_b = prev_nonnote_nondebug_insn (insn_b);
    3460                 :            :       while (insn_b
    3461                 :     395101 :              && (BLOCK_FOR_INSN (insn_b)
    3462                 :     395101 :                  == BLOCK_FOR_INSN (if_info->cond_earliest))
    3463                 :     722224 :              && !modified_in_p (x, insn_b));
    3464                 :            : 
    3465                 :            :       /* We're going to be moving the evaluation of B down from above
    3466                 :            :          COND_EARLIEST to JUMP.  Make sure the relevant data is still
    3467                 :            :          intact.  */
    3468                 :     163441 :       if (! insn_b
    3469                 :     161994 :           || BLOCK_FOR_INSN (insn_b) != BLOCK_FOR_INSN (if_info->cond_earliest)
    3470                 :      92569 :           || !NONJUMP_INSN_P (insn_b)
    3471                 :      88250 :           || (set_b = single_set (insn_b)) == NULL_RTX
    3472                 :      86998 :           || ! rtx_interchangeable_p (x, SET_DEST (set_b))
    3473                 :      76938 :           || ! noce_operand_ok (SET_SRC (set_b))
    3474                 :      73934 :           || reg_overlap_mentioned_p (x, SET_SRC (set_b))
    3475                 :      72246 :           || modified_between_p (SET_SRC (set_b), insn_b, jump)
    3476                 :            :           /* Avoid extending the lifetime of hard registers on small
    3477                 :            :              register class machines.  */
    3478                 :      71053 :           || (REG_P (SET_SRC (set_b))
    3479                 :      18728 :               && HARD_REGISTER_P (SET_SRC (set_b))
    3480                 :       2370 :               && targetm.small_register_classes_for_mode_p
    3481                 :       2370 :                    (GET_MODE (SET_SRC (set_b))))
    3482                 :            :           /* Likewise with X.  In particular this can happen when
    3483                 :            :              noce_get_condition looks farther back in the instruction
    3484                 :            :              stream than one might expect.  */
    3485                 :      68683 :           || reg_overlap_mentioned_p (x, cond)
    3486                 :      55506 :           || reg_overlap_mentioned_p (x, a)
    3487                 :     214629 :           || modified_between_p (x, insn_b, jump))
    3488                 :            :         {
    3489                 :            :           insn_b = NULL;
    3490                 :            :           set_b = NULL_RTX;
    3491                 :            :         }
    3492                 :            :     }
    3493                 :            : 
    3494                 :            :   /* If x has side effects then only the if-then-else form is safe to
    3495                 :            :      convert.  But even in that case we would need to restore any notes
    3496                 :            :      (such as REG_INC) at then end.  That can be tricky if
    3497                 :            :      noce_emit_move_insn expands to more than one insn, so disable the
    3498                 :            :      optimization entirely for now if there are side effects.  */
    3499                 :     210887 :   if (side_effects_p (x))
    3500                 :            :     return FALSE;
    3501                 :            : 
    3502                 :     210887 :   b = (set_b ? SET_SRC (set_b) : x);
    3503                 :            : 
    3504                 :            :   /* Only operate on register destinations, and even then avoid extending
    3505                 :            :      the lifetime of hard registers on small register class machines.  */
    3506                 :     210887 :   orig_x = x;
    3507                 :     210887 :   if_info->orig_x = orig_x;
    3508                 :     210887 :   if (!REG_P (x)
    3509                 :     210887 :       || (HARD_REGISTER_P (x)
    3510                 :          2 :           && targetm.small_register_classes_for_mode_p (GET_MODE (x))))
    3511                 :            :     {
    3512                 :      49604 :       if (GET_MODE (x) == BLKmode)
    3513                 :            :         return FALSE;
    3514                 :            : 
    3515                 :      49344 :       if (GET_CODE (x) == ZERO_EXTRACT
    3516                 :          1 :           && (!CONST_INT_P (XEXP (x, 1))
    3517                 :          1 :               || !CONST_INT_P (XEXP (x, 2))))
    3518                 :            :         return FALSE;
    3519                 :            : 
    3520                 :      49344 :       x = gen_reg_rtx (GET_MODE (GET_CODE (x) == STRICT_LOW_PART
    3521                 :            :                                  ? XEXP (x, 0) : x));
    3522                 :            :     }
    3523                 :            : 
    3524                 :            :   /* Don't operate on sources that may trap or are volatile.  */
    3525                 :     210627 :   if (! noce_operand_ok (a) || ! noce_operand_ok (b))
    3526                 :          0 :     return FALSE;
    3527                 :            : 
    3528                 :     247967 :  retry:
    3529                 :            :   /* Set up the info block for our subroutines.  */
    3530                 :     247967 :   if_info->insn_a = insn_a;
    3531                 :     247967 :   if_info->insn_b = insn_b;
    3532                 :     247967 :   if_info->x = x;
    3533                 :     247967 :   if_info->a = a;
    3534                 :     247967 :   if_info->b = b;
    3535                 :            : 
    3536                 :            :   /* Try optimizations in some approximation of a useful order.  */
    3537                 :            :   /* ??? Should first look to see if X is live incoming at all.  If it
    3538                 :            :      isn't, we don't need anything but an unconditional set.  */
    3539                 :            : 
    3540                 :            :   /* Look and see if A and B are really the same.  Avoid creating silly
    3541                 :            :      cmove constructs that no one will fix up later.  */
    3542                 :     247967 :   if (noce_simple_bbs (if_info)
    3543                 :     224208 :       && rtx_interchangeable_p (a, b))
    3544                 :            :     {
    3545                 :            :       /* If we have an INSN_B, we don't have to create any new rtl.  Just
    3546                 :            :          move the instruction that we already have.  If we don't have an
    3547                 :            :          INSN_B, that means that A == X, and we've got a noop move.  In
    3548                 :            :          that case don't do anything and let the code below delete INSN_A.  */
    3549                 :        139 :       if (insn_b && else_bb)
    3550                 :            :         {
    3551                 :        131 :           rtx note;
    3552                 :            : 
    3553                 :        131 :           if (else_bb && insn_b == BB_END (else_bb))
    3554                 :        108 :             BB_END (else_bb) = PREV_INSN (insn_b);
    3555                 :        131 :           reorder_insns (insn_b, insn_b, PREV_INSN (jump));
    3556                 :            : 
    3557                 :            :           /* If there was a REG_EQUAL note, delete it since it may have been
    3558                 :            :              true due to this insn being after a jump.  */
    3559                 :        131 :           if ((note = find_reg_note (insn_b, REG_EQUAL, NULL_RTX)) != 0)
    3560                 :          3 :             remove_note (insn_b, note);
    3561                 :            : 
    3562                 :        139 :           insn_b = NULL;
    3563                 :            :         }
    3564                 :            :       /* If we have "x = b; if (...) x = a;", and x has side-effects, then
    3565                 :            :          x must be executed twice.  */
    3566                 :          8 :       else if (insn_b && side_effects_p (orig_x))
    3567                 :            :         return FALSE;
    3568                 :            : 
    3569                 :        139 :       x = orig_x;
    3570                 :        139 :       goto success;
    3571                 :            :     }
    3572                 :            : 
    3573                 :     247828 :   if (!set_b && MEM_P (orig_x))
    3574                 :            :     /* We want to avoid store speculation to avoid cases like
    3575                 :            :          if (pthread_mutex_trylock(mutex))
    3576                 :            :            ++global_variable;
    3577                 :            :        Rather than go to much effort here, we rely on the SSA optimizers,
    3578                 :            :        which do a good enough job these days.  */
    3579                 :            :     return FALSE;
    3580                 :            : 
    3581                 :     201582 :   if (noce_try_move (if_info))
    3582                 :          0 :     goto success;
    3583                 :     201582 :   if (noce_try_ifelse_collapse (if_info))
    3584                 :       1424 :     goto success;
    3585                 :     200158 :   if (noce_try_store_flag (if_info))
    3586                 :      11305 :     goto success;
    3587                 :     188853 :   if (noce_try_bitop (if_info))
    3588                 :          0 :     goto success;
    3589                 :     188853 :   if (noce_try_minmax (if_info))
    3590                 :          1 :     goto success;
    3591                 :     188852 :   if (noce_try_abs (if_info))
    3592                 :        108 :     goto success;
    3593                 :     188744 :   if (noce_try_inverse_constants (if_info))
    3594                 :          0 :     goto success;
    3595                 :     188744 :   if (!targetm.have_conditional_execution ()
    3596                 :     188744 :       && noce_try_store_flag_constants (if_info))
    3597                 :       1656 :     goto success;
    3598                 :     187088 :   if (HAVE_conditional_move
    3599                 :     187088 :       && noce_try_cmove (if_info))
    3600                 :      29693 :     goto success;
    3601                 :     157395 :   if (! targetm.have_conditional_execution ())
    3602                 :            :     {
    3603                 :     157395 :       if (noce_try_addcc (if_info))
    3604                 :       4829 :         goto success;
    3605                 :     152566 :       if (noce_try_store_flag_mask (if_info))
    3606                 :          6 :         goto success;
    3607                 :     152560 :       if (HAVE_conditional_move
    3608                 :     152560 :           && noce_try_cmove_arith (if_info))
    3609                 :      25905 :         goto success;
    3610                 :     126655 :       if (noce_try_sign_mask (if_info))
    3611                 :          0 :         goto success;
    3612                 :            :     }
    3613                 :            : 
    3614                 :     126655 :   if (!else_bb && set_b)
    3615                 :            :     {
    3616                 :      37340 :       insn_b = NULL;
    3617                 :      37340 :       set_b = NULL_RTX;
    3618                 :      37340 :       b = orig_x;
    3619                 :      37340 :       goto retry;
    3620                 :            :     }
    3621                 :            : 
    3622                 :            :   return FALSE;
    3623                 :            : 
    3624                 :      75066 :  success:
    3625                 :      75066 :   if (dump_file && if_info->transform_name)
    3626                 :          6 :     fprintf (dump_file, "if-conversion succeeded through %s\n",
    3627                 :            :              if_info->transform_name);
    3628                 :            : 
    3629                 :            :   /* If we used a temporary, fix it up now.  */
    3630                 :      75066 :   if (orig_x != x)
    3631                 :            :     {
    3632                 :       2725 :       rtx_insn *seq;
    3633                 :            : 
    3634                 :       2725 :       start_sequence ();
    3635                 :       2725 :       noce_emit_move_insn (orig_x, x);
    3636                 :       2725 :       seq = get_insns ();
    3637                 :       2725 :       set_used_flags (orig_x);
    3638                 :       2725 :       unshare_all_rtl_in_chain (seq);
    3639                 :       2725 :       end_sequence ();
    3640                 :            : 
    3641                 :       2725 :       emit_insn_before_setloc (seq, BB_END (test_bb), INSN_LOCATION (insn_a));
    3642                 :            :     }
    3643                 :            : 
    3644                 :            :   /* The original THEN and ELSE blocks may now be removed.  The test block
    3645                 :            :      must now jump to the join block.  If the test block and the join block
    3646                 :            :      can be merged, do so.  */
    3647                 :      75066 :   if (else_bb)
    3648                 :            :     {
    3649                 :      25281 :       delete_basic_block (else_bb);
    3650                 :      25281 :       num_true_changes++;
    3651                 :            :     }
    3652                 :            :   else
    3653                 :      49785 :     remove_edge (find_edge (test_bb, join_bb));
    3654                 :            : 
    3655                 :      75066 :   remove_edge (find_edge (then_bb, join_bb));
    3656                 :      75066 :   redirect_edge_and_branch_force (single_succ_edge (test_bb), join_bb);
    3657                 :      75066 :   delete_basic_block (then_bb);
    3658                 :      75066 :   num_true_changes++;
    3659                 :            : 
    3660                 :      75066 :   if (can_merge_blocks_p (test_bb, join_bb))
    3661                 :            :     {
    3662                 :      55227 :       merge_blocks (test_bb, join_bb);
    3663                 :      55227 :       num_true_changes++;
    3664                 :            :     }
    3665                 :            : 
    3666                 :      75066 :   num_updated_if_blocks++;
    3667                 :      75066 :   return TRUE;
    3668                 :            : }
    3669                 :            : 
    3670                 :            : /* Check whether a block is suitable for conditional move conversion.
    3671                 :            :    Every insn must be a simple set of a register to a constant or a
    3672                 :            :    register.  For each assignment, store the value in the pointer map
    3673                 :            :    VALS, keyed indexed by register pointer, then store the register
    3674                 :            :    pointer in REGS.  COND is the condition we will test.  */
    3675                 :            : 
    3676                 :            : static int
    3677                 :    1366270 : check_cond_move_block (basic_block bb,
    3678                 :            :                        hash_map<rtx, rtx> *vals,
    3679                 :            :                        vec<rtx> *regs,
    3680                 :            :                        rtx cond)
    3681                 :            : {
    3682                 :    1366270 :   rtx_insn *insn;
    3683                 :    1366270 :   rtx cc = cc_in_cond (cond);
    3684                 :            : 
    3685                 :            :    /* We can only handle simple jumps at the end of the basic block.
    3686                 :            :       It is almost impossible to update the CFG otherwise.  */
    3687                 :    1366270 :   insn = BB_END (bb);
    3688                 :    1366270 :   if (JUMP_P (insn) && !onlyjump_p (insn))
    3689                 :            :     return FALSE;
    3690                 :            : 
    3691                 :   10890400 :   FOR_BB_INSNS (bb, insn)
    3692                 :            :     {
    3693                 :    6086110 :       rtx set, dest, src;
    3694                 :            : 
    3695                 :    6086110 :       if (!NONDEBUG_INSN_P (insn) || JUMP_P (insn))
    3696                 :    4683160 :         continue;
    3697                 :    1402950 :       set = single_set (insn);
    3698                 :    1402950 :       if (!set)
    3699                 :    1324020 :         return FALSE;
    3700                 :            : 
    3701                 :    1331370 :       dest = SET_DEST (set);
    3702                 :    1331370 :       src = SET_SRC (set);
    3703                 :    1331370 :       if (!REG_P (dest)
    3704                 :    1331370 :           || (HARD_REGISTER_P (dest)
    3705                 :     252419 :               && targetm.small_register_classes_for_mode_p (GET_MODE (dest))))
    3706                 :     578600 :         return FALSE;
    3707                 :            : 
    3708                 :     752769 :       if (!CONSTANT_P (src) && !register_operand (src, VOIDmode))
    3709                 :            :         return FALSE;
    3710                 :            : 
    3711                 :      98921 :       if (side_effects_p (src) || side_effects_p (dest))
    3712                 :          0 :         return FALSE;
    3713                 :            : 
    3714                 :      98921 :       if (may_trap_p (src) || may_trap_p (dest))
    3715                 :          0 :         return FALSE;
    3716                 :            : 
    3717                 :            :       /* Don't try to handle this if the source register was
    3718                 :            :          modified earlier in the block.  */
    3719                 :      98921 :       if ((REG_P (src)
    3720                 :      98931 :            && vals->get (src))
    3721                 :     132591 :           || (GET_CODE (src) == SUBREG && REG_P (SUBREG_REG (src))
    3722                 :       5776 :               && vals->get (SUBREG_REG (src))))
    3723                 :        606 :         return FALSE;
    3724                 :            : 
    3725                 :            :       /* Don't try to handle this if the destination register was
    3726                 :            :          modified earlier in the block.  */
    3727                 :    1422340 :       if (vals->get (dest))
    3728                 :            :         return FALSE;
    3729                 :            : 
    3730                 :            :       /* Don't try to handle this if the condition uses the
    3731                 :            :          destination register.  */
    3732                 :      98315 :       if (reg_overlap_mentioned_p (dest, cond))
    3733                 :            :         return FALSE;
    3734                 :            : 
    3735                 :            :       /* Don't try to handle this if the source register is modified
    3736                 :            :          later in the block.  */
    3737                 :      82211 :       if (!CONSTANT_P (src)
    3738                 :      82211 :           && modified_between_p (src, insn, NEXT_INSN (BB_END (bb))))
    3739                 :            :         return FALSE;
    3740                 :            : 
    3741                 :            :       /* Skip it if the instruction to be moved might clobber CC.  */
    3742                 :      78925 :       if (cc && set_of (cc, insn))
    3743                 :            :         return FALSE;
    3744                 :            : 
    3745                 :      78925 :       vals->put (dest, src);
    3746                 :            : 
    3747                 :      78925 :       regs->safe_push (dest);
    3748                 :            :     }
    3749                 :            : 
    3750                 :            :   return TRUE;
    3751                 :            : }
    3752                 :            : 
    3753                 :            : /* Given a basic block BB suitable for conditional move conversion,
    3754                 :            :    a condition COND, and pointer maps THEN_VALS and ELSE_VALS containing
    3755                 :            :    the register values depending on COND, emit the insns in the block as
    3756                 :            :    conditional moves.  If ELSE_BLOCK is true, THEN_BB was already
    3757                 :            :    processed.  The caller has started a sequence for the conversion.
    3758                 :            :    Return true if successful, false if something goes wrong.  */
    3759                 :            : 
    3760                 :            : static bool
    3761                 :      21873 : cond_move_convert_if_block (struct noce_if_info *if_infop,
    3762                 :            :                             basic_block bb, rtx cond,
    3763                 :            :                             hash_map<rtx, rtx> *then_vals,
    3764                 :            :                             hash_map<rtx, rtx> *else_vals,
    3765                 :            :                             bool else_block_p)
    3766                 :            : {
    3767                 :      21873 :   enum rtx_code code;
    3768                 :      21873 :   rtx_insn *insn;
    3769                 :      21873 :   rtx cond_arg0, cond_arg1;
    3770                 :            : 
    3771                 :      21873 :   code = GET_CODE (cond);
    3772                 :      21873 :   cond_arg0 = XEXP (cond, 0);
    3773                 :      21873 :   cond_arg1 = XEXP (cond, 1);
    3774                 :            : 
    3775                 :     154449 :   FOR_BB_INSNS (bb, insn)
    3776                 :            :     {
    3777                 :      72531 :       rtx set, target, dest, t, e;
    3778                 :            : 
    3779                 :            :       /* ??? Maybe emit conditional debug insn?  */
    3780                 :      72531 :       if (!NONDEBUG_INSN_P (insn) || JUMP_P (insn))
    3781                 :      49702 :         continue;
    3782                 :      27578 :       set = single_set (insn);
    3783                 :      27578 :       gcc_assert (set && REG_P (SET_DEST (set)));
    3784                 :            : 
    3785                 :      27578 :       dest = SET_DEST (set);
    3786                 :            : 
    3787                 :      27578 :       rtx *then_slot = then_vals->get (dest);
    3788                 :      27578 :       rtx *else_slot = else_vals->get (dest);
    3789                 :      27578 :       t = then_slot ? *then_slot : NULL_RTX;
    3790                 :      27578 :       e = else_slot ? *else_slot : NULL_RTX;
    3791                 :            : 
    3792                 :      27578 :       if (else_block_p)
    3793                 :            :         {
    3794                 :            :           /* If this register was set in the then block, we already
    3795                 :            :              handled this case there.  */
    3796                 :       5537 :           if (t)
    3797                 :       4749 :             continue;
    3798                 :        788 :           t = dest;
    3799                 :        788 :           gcc_assert (e);
    3800                 :            :         }
    3801                 :            :       else
    3802                 :            :         {
    3803                 :      22041 :           gcc_assert (t);
    3804                 :      22041 :           if (!e)
    3805                 :      17032 :             e = dest;
    3806                 :            :         }
    3807                 :            : 
    3808                 :      22829 :       target = noce_emit_cmove (if_infop, dest, code, cond_arg0, cond_arg1,
    3809                 :            :                                 t, e);
    3810                 :      22829 :       if (!target)
    3811                 :       6243 :         return false;
    3812                 :            : 
    3813                 :      16586 :       if (target != dest)
    3814                 :          0 :         noce_emit_move_insn (dest, target);
    3815                 :            :     }
    3816                 :            : 
    3817                 :            :   return true;
    3818                 :            : }
    3819                 :            : 
    3820                 :            : /* Given a simple IF-THEN-JOIN or IF-THEN-ELSE-JOIN block, attempt to convert
    3821                 :            :    it using only conditional moves.  Return TRUE if we were successful at
    3822                 :            :    converting the block.  */
    3823                 :            : 
    3824                 :            : static int
    3825                 :    1343240 : cond_move_process_if_block (struct noce_if_info *if_info)
    3826                 :            : {
    3827                 :    1343240 :   basic_block test_bb = if_info->test_bb;
    3828                 :    1343240 :   basic_block then_bb = if_info->then_bb;
    3829                 :    1343240 :   basic_block else_bb = if_info->else_bb;
    3830                 :    1343240 :   basic_block join_bb = if_info->join_bb;
    3831                 :    1343240 :   rtx_insn *jump = if_info->jump;
    3832                 :    1343240 :   rtx cond = if_info->cond;
    3833                 :    1343240 :   rtx_insn *seq, *loc_insn;
    3834                 :    1343240 :   rtx reg;
    3835                 :    1343240 :   int c;
    3836                 :    1343240 :   vec<rtx> then_regs = vNULL;
    3837                 :    1343240 :   vec<rtx> else_regs = vNULL;
    3838                 :    1343240 :   unsigned int i;
    3839                 :    1343240 :   int success_p = FALSE;
    3840                 :    1343240 :   int limit = param_max_rtl_if_conversion_insns;
    3841                 :            : 
    3842                 :            :   /* Build a mapping for each block to the value used for each
    3843                 :            :      register.  */
    3844                 :    1343240 :   hash_map<rtx, rtx> then_vals;
    3845                 :    2686490 :   hash_map<rtx, rtx> else_vals;
    3846                 :            : 
    3847                 :            :   /* Make sure the blocks are suitable.  */
    3848                 :    1343240 :   if (!check_cond_move_block (then_bb, &then_vals, &then_regs, cond)
    3849                 :    1343240 :       || (else_bb
    3850                 :      23024 :           && !check_cond_move_block (else_bb, &else_vals, &else_regs, cond)))
    3851                 :    1324050 :     goto done;
    3852                 :            : 
    3853                 :            :   /* Make sure the blocks can be used together.  If the same register
    3854                 :            :      is set in both blocks, and is not set to a constant in both
    3855                 :            :      cases, then both blocks must set it to the same register.  We
    3856                 :            :      have already verified that if it is set to a register, that the
    3857                 :            :      source register does not change after the assignment.  Also count
    3858                 :            :      the number of registers set in only one of the blocks.  */
    3859                 :            :   c = 0;
    3860                 :      59946 :   FOR_EACH_VEC_ELT (then_regs, i, reg)
    3861                 :            :     {
    3862                 :      24472 :       rtx *then_slot = then_vals.get (reg);
    3863                 :      24472 :       rtx *else_slot = else_vals.get (reg);
    3864                 :            : 
    3865                 :      24472 :       gcc_checking_assert (then_slot);
    3866                 :      24472 :       if (!else_slot)
    3867                 :      17583 :         ++c;
    3868                 :            :       else
    3869                 :            :         {
    3870                 :       6889 :           rtx then_val = *then_slot;
    3871                 :       6889 :           rtx else_val = *else_slot;
    3872                 :       2536 :           if (!CONSTANT_P (then_val) && !CONSTANT_P (else_val)
    3873                 :       8340 :               && !rtx_equal_p (then_val, else_val))
    3874                 :       1378 :             goto done;
    3875                 :            :         }
    3876                 :            :     }
    3877                 :            : 
    3878                 :            :   /* Finish off c for MAX_CONDITIONAL_EXECUTE.  */
    3879                 :      28027 :   FOR_EACH_VEC_ELT (else_regs, i, reg)
    3880                 :            :     {
    3881                 :       5899 :       gcc_checking_assert (else_vals.get (reg));
    3882                 :      11798 :       if (!then_vals.get (reg))
    3883                 :        860 :         ++c;
    3884                 :            :     }
    3885                 :            : 
    3886                 :            :   /* Make sure it is reasonable to convert this block.  What matters
    3887                 :            :      is the number of assignments currently made in only one of the
    3888                 :            :      branches, since if we convert we are going to always execute
    3889                 :            :      them.  */
    3890                 :      17814 :   if (c > MAX_CONDITIONAL_EXECUTE
    3891                 :      17814 :       || c > limit)
    3892                 :         34 :     goto done;
    3893                 :            : 
    3894                 :            :   /* Try to emit the conditional moves.  First do the then block,
    3895                 :            :      then do anything left in the else blocks.  */
    3896                 :      17780 :   start_sequence ();
    3897                 :      17780 :   if (!cond_move_convert_if_block (if_info, then_bb, cond,
    3898                 :            :                                    &then_vals, &else_vals, false)
    3899                 :      17780 :       || (else_bb
    3900                 :       4093 :           && !cond_move_convert_if_block (if_info, else_bb, cond,
    3901                 :            :                                           &then_vals, &else_vals, true)))
    3902                 :            :     {
    3903                 :       6243 :       end_sequence ();
    3904                 :       6243 :       goto done;
    3905                 :            :     }
    3906                 :      11537 :   seq = end_ifcvt_sequence (if_info);
    3907                 :      11537 :   if (!seq)
    3908                 :        162 :     goto done;
    3909                 :            : 
    3910                 :      11375 :   loc_insn = first_active_insn (then_bb);
    3911                 :      11375 :   if (!loc_insn)
    3912                 :            :     {
    3913                 :          1 :       loc_insn = first_active_insn (else_bb);
    3914                 :          1 :       gcc_assert (loc_insn);
    3915                 :            :     }
    3916                 :      11375 :   emit_insn_before_setloc (seq, jump, INSN_LOCATION (loc_insn));
    3917                 :            : 
    3918                 :      11375 :   if (else_bb)
    3919                 :            :     {
    3920                 :       4048 :       delete_basic_block (else_bb);
    3921                 :       4048 :       num_true_changes++;
    3922                 :            :     }
    3923                 :            :   else
    3924                 :       7327 :     remove_edge (find_edge (test_bb, join_bb));
    3925                 :            : 
    3926                 :      11375 :   remove_edge (find_edge (then_bb, join_bb));
    3927                 :      11375 :   redirect_edge_and_branch_force (single_succ_edge (test_bb), join_bb);
    3928                 :      11375 :   delete_basic_block (then_bb);
    3929                 :      11375 :   num_true_changes++;
    3930                 :            : 
    3931                 :      11375 :   if (can_merge_blocks_p (test_bb, join_bb))
    3932                 :            :     {
    3933                 :       4521 :       merge_blocks (test_bb, join_bb);
    3934                 :       4521 :       num_true_changes++;
    3935                 :            :     }
    3936                 :            : 
    3937                 :      11375 :   num_updated_if_blocks++;
    3938                 :      11375 :   success_p = TRUE;
    3939                 :            : 
    3940                 :    1343240 : done:
    3941                 :    1343240 :   then_regs.release ();
    3942                 :    1343240 :   else_regs.release ();
    3943                 :    1343240 :   return success_p;
    3944                 :            : }
    3945                 :            : 
    3946                 :            : 
    3947                 :            : /* Determine if a given basic block heads a simple IF-THEN-JOIN or an
    3948                 :            :    IF-THEN-ELSE-JOIN block.
    3949                 :            : 
    3950                 :            :    If so, we'll try to convert the insns to not require the branch,
    3951                 :            :    using only transformations that do not require conditional execution.
    3952                 :            : 
    3953                 :            :    Return TRUE if we were successful at converting the block.  */
    3954                 :            : 
    3955                 :            : static int
    3956                 :    6279960 : noce_find_if_block (basic_block test_bb, edge then_edge, edge else_edge,
    3957                 :            :                     int pass)
    3958                 :            : {
    3959                 :    6279960 :   basic_block then_bb, else_bb, join_bb;
    3960                 :    6279960 :   bool then_else_reversed = false;
    3961                 :    6279960 :   rtx_insn *jump;
    3962                 :    6279960 :   rtx cond;
    3963                 :    6279960 :   rtx_insn *cond_earliest;
    3964                 :    6279960 :   struct noce_if_info if_info;
    3965                 :    6279960 :   bool speed_p = optimize_bb_for_speed_p (test_bb);
    3966                 :            : 
    3967                 :            :   /* We only ever should get here before reload.  */
    3968                 :    6279960 :   gcc_assert (!reload_completed);
    3969                 :            : 
    3970                 :            :   /* Recognize an IF-THEN-ELSE-JOIN block.  */
    3971                 :    6279960 :   if (single_pred_p (then_edge->dest)
    3972                 :    5190570 :       && single_succ_p (then_edge->dest)
    3973                 :    2188100 :       && single_pred_p (else_edge->dest)
    3974                 :    1153820 :       && single_succ_p (else_edge->dest)
    3975                 :    7097580 :       && single_succ (then_edge->dest) == single_succ (else_edge->dest))
    3976                 :            :     {
    3977                 :            :       then_bb = then_edge->dest;
    3978                 :            :       else_bb = else_edge->dest;
    3979                 :    1447860 :       join_bb = single_succ (then_bb);
    3980                 :            :     }
    3981                 :            :   /* Recognize an IF-THEN-JOIN block.  */
    3982                 :    5634310 :   else if (single_pred_p (then_edge->dest)
    3983                 :    4544930 :            && single_succ_p (then_edge->dest)
    3984                 :    7176780 :            && single_succ (then_edge->dest) == else_edge->dest)
    3985                 :            :     {
    3986                 :            :       then_bb = then_edge->dest;
    3987                 :            :       else_bb = NULL_BLOCK;
    3988                 :            :       join_bb = else_edge->dest;
    3989                 :            :     }
    3990                 :            :   /* Recognize an IF-ELSE-JOIN block.  We can have those because the order
    3991                 :            :      of basic blocks in cfglayout mode does not matter, so the fallthrough
    3992                 :            :      edge can go to any basic block (and not just to bb->next_bb, like in
    3993                 :            :      cfgrtl mode).  */
    3994                 :    4927980 :   else if (single_pred_p (else_edge->dest)
    3995                 :    2277200 :            && single_succ_p (else_edge->dest)
    3996                 :    5923410 :            && single_succ (else_edge->dest) == then_edge->dest)
    3997                 :            :     {
    3998                 :            :       /* The noce transformations do not apply to IF-ELSE-JOIN blocks.
    3999                 :            :          To make this work, we have to invert the THEN and ELSE blocks
    4000                 :            :          and reverse the jump condition.  */
    4001                 :            :       then_bb = else_edge->dest;
    4002                 :            :       else_bb = NULL_BLOCK;
    4003                 :    1447860 :       join_bb = single_succ (then_bb);
    4004                 :            :       then_else_reversed = true;
    4005                 :            :     }
    4006                 :            :   else
    4007                 :            :     /* Not a form we can handle.  */
    4008                 :            :     return FALSE;
    4009                 :            : 
    4010                 :            :   /* The edges of the THEN and ELSE blocks cannot have complex edges.  */
    4011                 :    1447860 :   if (single_succ_edge (then_bb)->flags & EDGE_COMPLEX)
    4012                 :            :     return FALSE;
    4013                 :    1419450 :   if (else_bb
    4014                 :    1419450 :       && single_succ_edge (else_bb)->flags & EDGE_COMPLEX)
    4015                 :            :     return FALSE;
    4016                 :            : 
    4017                 :    1418650 :   num_possible_if_blocks++;
    4018                 :            : 
    4019                 :    1418650 :   if (dump_file)
    4020                 :            :     {
    4021                 :         85 :       fprintf (dump_file,
    4022                 :            :                "\nIF-THEN%s-JOIN block found, pass %d, test %d, then %d",
    4023                 :            :                (else_bb) ? "-ELSE" : "",
    4024                 :            :                pass, test_bb->index, then_bb->index);
    4025                 :            : 
    4026                 :         50 :       if (else_bb)
    4027                 :         15 :         fprintf (dump_file, ", else %d", else_bb->index);
    4028                 :            : 
    4029                 :         50 :       fprintf (dump_file, ", join %d\n", join_bb->index);
    4030                 :            :     }
    4031                 :            : 
    4032                 :            :   /* If the conditional jump is more than just a conditional
    4033                 :            :      jump, then we cannot do if-conversion on this block.  */
    4034                 :    1418650 :   jump = BB_END (test_bb);
    4035                 :    1418650 :   if (! onlyjump_p (jump))
    4036                 :            :     return FALSE;
    4037                 :            : 
    4038                 :            :   /* If this is not a standard conditional jump, we can't parse it.  */
    4039                 :    1418580 :   cond = noce_get_condition (jump, &cond_earliest, then_else_reversed);
    4040                 :    1418580 :   if (!cond)
    4041                 :            :     return FALSE;
    4042                 :            : 
    4043                 :            :   /* We must be comparing objects whose modes imply the size.  */
    4044                 :    1418580 :   if (GET_MODE (XEXP (cond, 0)) == BLKmode)
    4045                 :            :     return FALSE;
    4046                 :            : 
    4047                 :            :   /* Initialize an IF_INFO struct to pass around.  */
    4048                 :    1418580 :   memset (&if_info, 0, sizeof if_info);
    4049                 :    1418580 :   if_info.test_bb = test_bb;
    4050                 :    1418580 :   if_info.then_bb = then_bb;
    4051                 :    1418580 :   if_info.else_bb = else_bb;
    4052                 :    1418580 :   if_info.join_bb = join_bb;
    4053                 :    1418580 :   if_info.cond = cond;
    4054                 :    1418580 :   rtx_insn *rev_cond_earliest;
    4055                 :    2837170 :   if_info.rev_cond = noce_get_condition (jump, &rev_cond_earliest,
    4056                 :    1418580 :                                          !then_else_reversed);
    4057                 :    1418580 :   gcc_assert (if_info.rev_cond == NULL_RTX
    4058                 :            :               || rev_cond_earliest == cond_earliest);
    4059                 :    1418580 :   if_info.cond_earliest = cond_earliest;
    4060                 :    1418580 :   if_info.jump = jump;
    4061                 :    1418580 :   if_info.then_else_reversed = then_else_reversed;
    4062                 :    1418580 :   if_info.speed_p = speed_p;
    4063                 :    1418580 :   if_info.max_seq_cost
    4064                 :    1418580 :     = targetm.max_noce_ifcvt_seq_cost (then_edge);
    4065                 :            :   /* We'll add in the cost of THEN_BB and ELSE_BB later, when we check
    4066                 :            :      that they are valid to transform.  We can't easily get back to the insn
    4067                 :            :      for COND (and it may not exist if we had to canonicalize to get COND),
    4068                 :            :      and jump_insns are always given a cost of 1 by seq_cost, so treat
    4069                 :            :      both instructions as having cost COSTS_N_INSNS (1).  */
    4070                 :    1418580 :   if_info.original_cost = COSTS_N_INSNS (2);
    4071                 :            : 
    4072                 :            : 
    4073                 :            :   /* Do the real work.  */
    4074                 :            : 
    4075                 :    1418580 :   if (noce_process_if_block (&if_info))
    4076                 :            :     return TRUE;
    4077                 :            : 
    4078                 :    1343240 :   if (HAVE_conditional_move
    4079                 :    1343240 :       && cond_move_process_if_block (&if_info))
    4080                 :      11375 :     return TRUE;
    4081                 :            : 
    4082                 :            :   return FALSE;
    4083                 :            : }
    4084                 :            : 
    4085                 :            : 
    4086                 :            : /* Merge the blocks and mark for local life update.  */
    4087                 :            : 
    4088                 :            : static void
    4089                 :          0 : merge_if_block (struct ce_if_block * ce_info)
    4090                 :            : {
    4091                 :          0 :   basic_block test_bb = ce_info->test_bb;    /* last test block */
    4092                 :          0 :   basic_block then_bb = ce_info->then_bb;    /* THEN */
    4093                 :          0 :   basic_block else_bb = ce_info->else_bb;    /* ELSE or NULL */
    4094                 :          0 :   basic_block join_bb = ce_info->join_bb;    /* join block */
    4095                 :          0 :   basic_block combo_bb;
    4096                 :            : 
    4097                 :            :   /* All block merging is done into the lower block numbers.  */
    4098                 :            : 
    4099                 :          0 :   combo_bb = test_bb;
    4100                 :          0 :   df_set_bb_dirty (test_bb);
    4101                 :            : 
    4102                 :            :   /* Merge any basic blocks to handle && and || subtests.  Each of
    4103                 :            :      the blocks are on the fallthru path from the predecessor block.  */
    4104                 :          0 :   if (ce_info->num_multiple_test_blocks > 0)
    4105                 :            :     {
    4106                 :          0 :       basic_block bb = test_bb;
    4107                 :          0 :       basic_block last_test_bb = ce_info->last_test_bb;
    4108                 :          0 :       basic_block fallthru = block_fallthru (bb);
    4109                 :            : 
    4110                 :          0 :       do
    4111                 :            :         {
    4112                 :          0 :           bb = fallthru;
    4113                 :          0 :           fallthru = block_fallthru (bb);
    4114                 :          0 :           merge_blocks (combo_bb, bb);
    4115                 :          0 :           num_true_changes++;
    4116                 :            :         }
    4117                 :          0 :       while (bb != last_test_bb);
    4118                 :            :     }
    4119                 :            : 
    4120                 :            :   /* Merge TEST block into THEN block.  Normally the THEN block won't have a
    4121                 :            :      label, but it might if there were || tests.  That label's count should be
    4122                 :            :      zero, and it normally should be removed.  */
    4123                 :            : 
    4124                 :          0 :   if (then_bb)
    4125                 :            :     {
    4126                 :            :       /* If THEN_BB has no successors, then there's a BARRIER after it.
    4127                 :            :          If COMBO_BB has more than one successor (THEN_BB), then that BARRIER
    4128                 :            :          is no longer needed, and in fact it is incorrect to leave it in
    4129                 :            :          the insn stream.  */
    4130                 :          0 :       if (EDGE_COUNT (then_bb->succs) == 0
    4131                 :          0 :           && EDGE_COUNT (combo_bb->succs) > 1)
    4132                 :            :         {
    4133                 :          0 :           rtx_insn *end = NEXT_INSN (BB_END (then_bb));
    4134                 :          0 :           while (end && NOTE_P (end) && !NOTE_INSN_BASIC_BLOCK_P (end))
    4135                 :          0 :             end = NEXT_INSN (end);
    4136                 :            : 
    4137                 :          0 :           if (end && BARRIER_P (end))
    4138                 :          0 :             delete_insn (end);
    4139                 :            :         }
    4140                 :          0 :       merge_blocks (combo_bb, then_bb);
    4141                 :          0 :       num_true_changes++;
    4142                 :            :     }
    4143                 :            : 
    4144                 :            :   /* The ELSE block, if it existed, had a label.  That label count
    4145                 :            :      will almost always be zero, but odd things can happen when labels
    4146                 :            :      get their addresses taken.  */
    4147                 :          0 :   if (else_bb)
    4148                 :            :     {
    4149                 :            :       /* If ELSE_BB has no successors, then there's a BARRIER after it.
    4150                 :            :          If COMBO_BB has more than one successor (ELSE_BB), then that BARRIER
    4151                 :            :          is no longer needed, and in fact it is incorrect to leave it in
    4152                 :            :          the insn stream.  */
    4153                 :          0 :       if (EDGE_COUNT (else_bb->succs) == 0
    4154                 :          0 :           && EDGE_COUNT (combo_bb->succs) > 1)
    4155                 :            :         {
    4156                 :          0 :           rtx_insn *end = NEXT_INSN (BB_END (else_bb));
    4157                 :          0 :           while (end && NOTE_P (end) && !NOTE_INSN_BASIC_BLOCK_P (end))
    4158                 :          0 :             end = NEXT_INSN (end);
    4159                 :            : 
    4160                 :          0 :           if (end && BARRIER_P (end))
    4161                 :          0 :             delete_insn (end);
    4162                 :            :         }
    4163                 :          0 :       merge_blocks (combo_bb, else_bb);
    4164                 :          0 :       num_true_changes++;
    4165                 :            :     }
    4166                 :            : 
    4167                 :            :   /* If there was no join block reported, that means it was not adjacent
    4168                 :            :      to the others, and so we cannot merge them.  */
    4169                 :            : 
    4170                 :          0 :   if (! join_bb)
    4171                 :            :     {
    4172                 :          0 :       rtx_insn *last = BB_END (combo_bb);
    4173                 :            : 
    4174                 :            :       /* The outgoing edge for the current COMBO block should already
    4175                 :            :          be correct.  Verify this.  */
    4176                 :          0 :       if (EDGE_COUNT (combo_bb->succs) == 0)
    4177                 :          0 :         gcc_assert (find_reg_note (last, REG_NORETURN, NULL)
    4178                 :            :                     || (NONJUMP_INSN_P (last)
    4179                 :            :                         && GET_CODE (PATTERN (last)) == TRAP_IF
    4180                 :            :                         && (TRAP_CONDITION (PATTERN (last))
    4181                 :            :                             == const_true_rtx)));
    4182                 :            : 
    4183                 :            :       else
    4184                 :            :       /* There should still be something at the end of the THEN or ELSE
    4185                 :            :          blocks taking us to our final destination.  */
    4186                 :          0 :         gcc_assert (JUMP_P (last)
    4187                 :            :                     || (EDGE_SUCC (combo_bb, 0)->dest
    4188                 :            :                         == EXIT_BLOCK_PTR_FOR_FN (cfun)
    4189                 :            :                         && CALL_P (last)
    4190                 :            :                         && SIBLING_CALL_P (last))
    4191                 :            :                     || ((EDGE_SUCC (combo_bb, 0)->flags & EDGE_EH)
    4192                 :            :                         && can_throw_internal (last)));
    4193                 :            :     }
    4194                 :            : 
    4195                 :            :   /* The JOIN block may have had quite a number of other predecessors too.
    4196                 :            :      Since we've already merged the TEST, THEN and ELSE blocks, we should
    4197                 :            :      have only one remaining edge from our if-then-else diamond.  If there
    4198                 :            :      is more than one remaining edge, it must come from elsewhere.  There
    4199                 :            :      may be zero incoming edges if the THEN block didn't actually join
    4200                 :            :      back up (as with a call to a non-return function).  */
    4201                 :          0 :   else if (EDGE_COUNT (join_bb->preds) < 2
    4202                 :          0 :            && join_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
    4203                 :            :     {
    4204                 :            :       /* We can merge the JOIN cleanly and update the dataflow try
    4205                 :            :          again on this pass.*/
    4206                 :          0 :       merge_blocks (combo_bb, join_bb);
    4207                 :          0 :       num_true_changes++;
    4208                 :            :     }
    4209                 :            :   else
    4210                 :            :     {
    4211                 :            :       /* We cannot merge the JOIN.  */
    4212                 :            : 
    4213                 :            :       /* The outgoing edge for the current COMBO block should already
    4214                 :            :          be correct.  Verify this.  */
    4215                 :          0 :       gcc_assert (single_succ_p (combo_bb)
    4216                 :            :                   && single_succ (combo_bb) == join_bb);
    4217                 :            : 
    4218                 :            :       /* Remove the jump and cruft from the end of the COMBO block.  */
    4219                 :          0 :       if (join_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
    4220                 :          0 :         tidy_fallthru_edge (single_succ_edge (combo_bb));
    4221                 :            :     }
    4222                 :            : 
    4223                 :          0 :   num_updated_if_blocks++;
    4224                 :          0 : }
    4225                 :            : 
    4226                 :            : /* Find a block ending in a simple IF condition and try to transform it
    4227                 :            :    in some way.  When converting a multi-block condition, put the new code
    4228                 :            :    in the first such block and delete the rest.  Return a pointer to this
    4229                 :            :    first block if some transformation was done.  Return NULL otherwise.  */
    4230                 :            : 
    4231                 :            : static basic_block
    4232                 :   24738700 : find_if_header (basic_block test_bb, int pass)
    4233                 :            : {
    4234                 :   24738700 :   ce_if_block ce_info;
    4235                 :   24738700 :   edge then_edge;
    4236                 :   24738700 :   edge else_edge;
    4237                 :            : 
    4238                 :            :   /* The kind of block we're looking for has exactly two successors.  */
    4239                 :   24738700 :   if (EDGE_COUNT (test_bb->succs) != 2)
    4240                 :            :     return NULL;
    4241                 :            : 
    4242                 :   12796100 :   then_edge = EDGE_SUCC (test_bb, 0);
    4243                 :   12796100 :   else_edge = EDGE_SUCC (test_bb, 1);
    4244                 :            : 
    4245                 :   12796100 :   if (df_get_bb_dirty (then_edge->dest))
    4246                 :            :     return NULL;
    4247                 :   12777600 :   if (df_get_bb_dirty (else_edge->dest))
    4248                 :            :     return NULL;
    4249                 :            : 
    4250                 :            :   /* Neither edge should be abnormal.  */
    4251                 :   12749200 :   if ((then_edge->flags & EDGE_COMPLEX)
    4252                 :   11491500 :       || (else_edge->flags & EDGE_COMPLEX))
    4253                 :            :     return NULL;
    4254                 :            : 
    4255                 :            :   /* Nor exit the loop.  */
    4256                 :   11203900 :   if ((then_edge->flags & EDGE_LOOP_EXIT)
    4257                 :   10087600 :       || (else_edge->flags & EDGE_LOOP_EXIT))
    4258                 :            :     return NULL;
    4259                 :            : 
    4260                 :            :   /* The THEN edge is canonically the one that falls through.  */
    4261                 :    9137510 :   if (then_edge->flags & EDGE_FALLTHRU)
    4262                 :            :     ;
    4263                 :    4591880 :   else if (else_edge->flags & EDGE_FALLTHRU)
    4264                 :    9137080 :     std::swap (then_edge, else_edge);
    4265                 :            :   else
    4266                 :            :     /* Otherwise this must be a multiway branch of some sort.  */
    4267                 :            :     return NULL;
    4268                 :            : 
    4269                 :    9137080 :   memset (&ce_info, 0, sizeof (ce_info));
    4270                 :    9137080 :   ce_info.test_bb = test_bb;
    4271                 :    9137080 :   ce_info.then_bb = then_edge->dest;
    4272                 :    9137080 :   ce_info.else_bb = else_edge->dest;
    4273                 :    9137080 :   ce_info.pass = pass;
    4274                 :            : 
    4275                 :            : #ifdef IFCVT_MACHDEP_INIT
    4276                 :            :   IFCVT_MACHDEP_INIT (&ce_info);
    4277                 :            : #endif
    4278                 :            : 
    4279                 :    9137080 :   if (!reload_completed
    4280                 :    9137080 :       && noce_find_if_block (test_bb, then_edge, else_edge, pass))
    4281                 :      86716 :     goto success;
    4282                 :            : 
    4283                 :    9050360 :   if (reload_completed
    4284                 :    2857120 :       && targetm.have_conditional_execution ()
    4285                 :    9050360 :       && cond_exec_find_if_block (&ce_info))
    4286                 :          0 :     goto success;
    4287                 :            : 
    4288                 :    9050360 :   if (targetm.have_trap ()
    4289                 :    9050360 :       && optab_handler (ctrap_optab, word_mode) != CODE_FOR_nothing
    4290                 :    9050360 :       && find_cond_trap (test_bb, then_edge, else_edge))
    4291                 :          0 :     goto success;
    4292                 :            : 
    4293                 :    9050360 :   if (dom_info_state (CDI_POST_DOMINATORS) >= DOM_NO_FAST_QUERY
    4294                 :    9050360 :       && (reload_completed || !targetm.have_conditional_execution ()))
    4295                 :            :     {
    4296                 :    9050360 :       if (find_if_case_1 (test_bb, then_edge, else_edge))
    4297                 :       8120 :         goto success;
    4298                 :    9042240 :       if (find_if_case_2 (test_bb, then_edge, else_edge))
    4299                 :     125940 :         goto success;
    4300                 :            :     }
    4301                 :            : 
    4302                 :            :   return NULL;
    4303                 :            : 
    4304                 :     220776 :  success:
    4305                 :     220776 :   if (dump_file)
    4306                 :         18 :     fprintf (dump_file, "Conversion succeeded on pass %d.\n", pass);
    4307                 :            :   /* Set this so we continue looking.  */
    4308                 :     220776 :   cond_exec_changed_p = TRUE;
    4309                 :     220776 :   return ce_info.test_bb;
    4310                 :            : }
    4311                 :            : 
    4312                 :            : /* Return true if a block has two edges, one of which falls through to the next
    4313                 :            :    block, and the other jumps to a specific block, so that we can tell if the
    4314                 :            :    block is part of an && test or an || test.  Returns either -1 or the number
    4315                 :            :    of non-note, non-jump, non-USE/CLOBBER insns in the block.  */
    4316                 :            : 
    4317                 :            : static int
    4318                 :          0 : block_jumps_and_fallthru_p (basic_block cur_bb, basic_block target_bb)
    4319                 :            : {
    4320                 :          0 :   edge cur_edge;
    4321                 :          0 :   int fallthru_p = FALSE;
    4322                 :          0 :   int jump_p = FALSE;
    4323                 :          0 :   rtx_insn *insn;
    4324                 :          0 :   rtx_insn *end;
    4325                 :          0 :   int n_insns = 0;
    4326                 :          0 :   edge_iterator ei;
    4327                 :            : 
    4328                 :          0 :   if (!cur_bb || !target_bb)
    4329                 :            :     return -1;
    4330                 :            : 
    4331                 :            :   /* If no edges, obviously it doesn't jump or fallthru.  */
    4332                 :          0 :   if (EDGE_COUNT (cur_bb->succs) == 0)
    4333                 :            :     return FALSE;
    4334                 :            : 
    4335                 :          0 :   FOR_EACH_EDGE (cur_edge, ei, cur_bb->succs)
    4336                 :            :     {
    4337                 :          0 :       if (cur_edge->flags & EDGE_COMPLEX)
    4338                 :            :         /* Anything complex isn't what we want.  */
    4339                 :            :         return -1;
    4340                 :            : 
    4341                 :          0 :       else if (cur_edge->flags & EDGE_FALLTHRU)
    4342                 :            :         fallthru_p = TRUE;
    4343                 :            : 
    4344                 :          0 :       else if (cur_edge->dest == target_bb)
    4345                 :            :         jump_p = TRUE;
    4346                 :            : 
    4347                 :            :       else
    4348                 :            :         return -1;
    4349                 :            :     }
    4350                 :            : 
    4351                 :          0 :   if ((jump_p & fallthru_p) == 0)
    4352                 :            :     return -1;
    4353                 :            : 
    4354                 :            :   /* Don't allow calls in the block, since this is used to group && and ||
    4355                 :            :      together for conditional execution support.  ??? we should support
    4356                 :            :      conditional execution support across calls for IA-64 some day, but
    4357                 :            :      for now it makes the code simpler.  */
    4358                 :          0 :   end = BB_END (cur_bb);
    4359                 :          0 :   insn = BB_HEAD (cur_bb);
    4360                 :            : 
    4361                 :          0 :   while (insn != NULL_RTX)
    4362                 :            :     {
    4363                 :          0 :       if (CALL_P (insn))
    4364                 :            :         return -1;
    4365                 :            : 
    4366                 :          0 :       if (INSN_P (insn)
    4367                 :          0 :           && !JUMP_P (insn)
    4368                 :          0 :           && !DEBUG_INSN_P (insn)
    4369                 :          0 :           && GET_CODE (PATTERN (insn)) != USE
    4370                 :          0 :           && GET_CODE (PATTERN (insn)) != CLOBBER)
    4371                 :          0 :         n_insns++;
    4372                 :            : 
    4373                 :          0 :       if (insn == end)
    4374                 :            :         break;
    4375                 :            : 
    4376                 :          0 :       insn = NEXT_INSN (insn);
    4377                 :            :     }
    4378                 :            : 
    4379                 :            :   return n_insns;
    4380                 :            : }
    4381                 :            : 
    4382                 :            : /* Determine if a given basic block heads a simple IF-THEN or IF-THEN-ELSE
    4383                 :            :    block.  If so, we'll try to convert the insns to not require the branch.
    4384                 :            :    Return TRUE if we were successful at converting the block.  */
    4385                 :            : 
    4386                 :            : static int
    4387                 :          0 : cond_exec_find_if_block (struct ce_if_block * ce_info)
    4388                 :            : {
    4389                 :          0 :   basic_block test_bb = ce_info->test_bb;
    4390                 :          0 :   basic_block then_bb = ce_info->then_bb;
    4391                 :          0 :   basic_block else_bb = ce_info->else_bb;
    4392                 :          0 :   basic_block join_bb = NULL_BLOCK;
    4393                 :          0 :   edge cur_edge;
    4394                 :          0 :   basic_block next;
    4395                 :          0 :   edge_iterator ei;
    4396                 :            : 
    4397                 :          0 :   ce_info->last_test_bb = test_bb;
    4398                 :            : 
    4399                 :            :   /* We only ever should get here after reload,
    4400                 :            :      and if we have conditional execution.  */
    4401                 :          0 :   gcc_assert (reload_completed && targetm.have_conditional_execution ());
    4402                 :            : 
    4403                 :            :   /* Discover if any fall through predecessors of the current test basic block
    4404                 :            :      were && tests (which jump to the else block) or || tests (which jump to
    4405                 :            :      the then block).  */
    4406                 :          0 :   if (single_pred_p (test_bb)
    4407                 :          0 :       && single_pred_edge (test_bb)->flags == EDGE_FALLTHRU)
    4408                 :            :     {
    4409                 :          0 :       basic_block bb = single_pred (test_bb);
    4410                 :          0 :       basic_block target_bb;
    4411                 :          0 :       int max_insns = MAX_CONDITIONAL_EXECUTE;
    4412                 :          0 :       int n_insns;
    4413                 :            : 
    4414                 :            :       /* Determine if the preceding block is an && or || block.  */
    4415                 :          0 :       if ((n_insns = block_jumps_and_fallthru_p (bb, else_bb)) >= 0)
    4416                 :            :         {
    4417                 :          0 :           ce_info->and_and_p = TRUE;
    4418                 :          0 :           target_bb = else_bb;
    4419                 :            :         }
    4420                 :          0 :       else if ((n_insns = block_jumps_and_fallthru_p (bb, then_bb)) >= 0)
    4421                 :            :         {
    4422                 :          0 :           ce_info->and_and_p = FALSE;
    4423                 :          0 :           target_bb = then_bb;
    4424                 :            :         }
    4425                 :            :       else
    4426                 :            :         target_bb = NULL_BLOCK;
    4427                 :            : 
    4428                 :          0 :       if (target_bb && n_insns <= max_insns)
    4429                 :            :         {
    4430                 :          0 :           int total_insns = 0;
    4431                 :          0 :           int blocks = 0;
    4432                 :            : 
    4433                 :          0 :           ce_info->last_test_bb = test_bb;
    4434                 :            : 
    4435                 :            :           /* Found at least one && or || block, look for more.  */
    4436                 :          0 :           do
    4437                 :            :             {
    4438                 :          0 :               ce_info->test_bb = test_bb = bb;
    4439                 :          0 :               total_insns += n_insns;
    4440                 :          0 :               blocks++;
    4441                 :            : 
    4442                 :          0 :               if (!single_pred_p (bb))
    4443                 :            :                 break;
    4444                 :            : 
    4445                 :          0 :               bb = single_pred (bb);
    4446                 :          0 :               n_insns = block_jumps_and_fallthru_p (bb, target_bb);
    4447                 :            :             }
    4448                 :          0 :           while (n_insns >= 0 && (total_insns + n_insns) <= max_insns);
    4449                 :            : 
    4450                 :          0 :           ce_info->num_multiple_test_blocks = blocks;
    4451                 :          0 :           ce_info->num_multiple_test_insns = total_insns;
    4452                 :            : 
    4453                 :          0 :           if (ce_info->and_and_p)
    4454                 :          0 :             ce_info->num_and_and_blocks = blocks;
    4455                 :            :           else
    4456                 :          0 :             ce_info->num_or_or_blocks = blocks;
    4457                 :            :         }
    4458                 :            :     }
    4459                 :            : 
    4460                 :            :   /* The THEN block of an IF-THEN combo must have exactly one predecessor,
    4461                 :            :      other than any || blocks which jump to the THEN block.  */
    4462                 :          0 :   if ((EDGE_COUNT (then_bb->preds) - ce_info->num_or_or_blocks) != 1)
    4463                 :            :     return FALSE;
    4464                 :            : 
    4465                 :            :   /* The edges of the THEN and ELSE blocks cannot have complex edges.  */
    4466                 :          0 :   FOR_EACH_EDGE (cur_edge, ei, then_bb->preds)
    4467                 :            :     {
    4468                 :          0 :       if (cur_edge->flags & EDGE_COMPLEX)
    4469                 :            :         return FALSE;
    4470                 :            :     }
    4471                 :            : 
    4472                 :          0 :   FOR_EACH_EDGE (cur_edge, ei, else_bb->preds)
    4473                 :            :     {
    4474                 :          0 :       if (cur_edge->flags & EDGE_COMPLEX)
    4475                 :            :         return FALSE;
    4476                 :            :     }
    4477                 :            : 
    4478                 :            :   /* The THEN block of an IF-THEN combo must have zero or one successors.  */
    4479                 :          0 :   if (EDGE_COUNT (then_bb->succs) > 0
    4480                 :          0 :       && (!single_succ_p (then_bb)
    4481                 :          0 :           || (single_succ_edge (then_bb)->flags & EDGE_COMPLEX)
    4482                 :          0 :           || (epilogue_completed
    4483                 :          0 :               && tablejump_p (BB_END (then_bb), NULL, NULL))))
    4484                 :          0 :     return FALSE;
    4485                 :            : 
    4486                 :            :   /* If the THEN block has no successors, conditional execution can still
    4487                 :            :      make a conditional call.  Don't do this unless the ELSE block has
    4488                 :            :      only one incoming edge -- the CFG manipulation is too ugly otherwise.
    4489                 :            :      Check for the last insn of the THEN block being an indirect jump, which
    4490                 :            :      is listed as not having any successors, but confuses the rest of the CE
    4491                 :            :      code processing.  ??? we should fix this in the future.  */
    4492                 :          0 :   if (EDGE_COUNT (then_bb->succs) == 0)
    4493                 :            :     {
    4494                 :          0 :       if (single_pred_p (else_bb) && else_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
    4495                 :            :         {
    4496                 :          0 :           rtx_insn *last_insn = BB_END (then_bb);
    4497                 :            : 
    4498                 :          0 :           while (last_insn
    4499                 :          0 :                  && NOTE_P (last_insn)
    4500                 :          0 :                  && last_insn != BB_HEAD (then_bb))
    4501                 :          0 :             last_insn = PREV_INSN (last_insn);
    4502                 :            : 
    4503                 :          0 :           if (last_insn
    4504                 :          0 :               && JUMP_P (last_insn)
    4505                 :          0 :               && ! simplejump_p (last_insn))
    4506                 :            :             return FALSE;
    4507                 :            : 
    4508                 :            :           join_bb = else_bb;
    4509                 :            :           else_bb = NULL_BLOCK;
    4510                 :            :         }
    4511                 :            :       else
    4512                 :            :         return FALSE;
    4513                 :            :     }
    4514                 :            : 
    4515                 :            :   /* If the THEN block's successor is the other edge out of the TEST block,
    4516                 :            :      then we have an IF-THEN combo without an ELSE.  */
    4517                 :          0 :   else if (single_succ (then_bb) == else_bb)
    4518                 :            :     {
    4519                 :            :       join_bb = else_bb;
    4520                 :            :       else_bb = NULL_BLOCK;
    4521                 :            :     }
    4522                 :            : 
    4523                 :            :   /* If the THEN and ELSE block meet in a subsequent block, and the ELSE
    4524                 :            :      has exactly one predecessor and one successor, and the outgoing edge
    4525                 :            :      is not complex, then we have an IF-THEN-ELSE combo.  */
    4526                 :          0 :   else if (single_succ_p (else_bb)
    4527                 :          0 :            && single_succ (then_bb) == single_succ (else_bb)
    4528                 :          0 :            && single_pred_p (else_bb)
    4529                 :          0 :            && !(single_succ_edge (else_bb)->flags & EDGE_COMPLEX)
    4530                 :          0 :            && !(epilogue_completed
    4531                 :          0 :                 && tablejump_p (BB_END (else_bb), NULL, NULL)))
    4532                 :          0 :     join_bb = single_succ (else_bb);
    4533                 :            : 
    4534                 :            :   /* Otherwise it is not an IF-THEN or IF-THEN-ELSE combination.  */
    4535                 :            :   else
    4536                 :          0 :     return FALSE;
    4537                 :            : 
    4538                 :          0 :   num_possible_if_blocks++;
    4539                 :            : 
    4540                 :          0 :   if (dump_file)
    4541                 :            :     {
    4542                 :          0 :       fprintf (dump_file,
    4543                 :            :                "\nIF-THEN%s block found, pass %d, start block %d "
    4544                 :            :                "[insn %d], then %d [%d]",
    4545                 :            :                (else_bb) ? "-ELSE" : "",
    4546                 :            :                ce_info->pass,
    4547                 :            :                test_bb->index,
    4548                 :          0 :                BB_HEAD (test_bb) ? (int)INSN_UID (BB_HEAD (test_bb)) : -1,
    4549                 :            :                then_bb->index,
    4550                 :          0 :                BB_HEAD (then_bb) ? (int)INSN_UID (BB_HEAD (then_bb)) : -1);
    4551                 :            : 
    4552                 :          0 :       if (else_bb)
    4553                 :          0 :         fprintf (dump_file, ", else %d [%d]",
    4554                 :            :                  else_bb->index,
    4555                 :          0 :                  BB_HEAD (else_bb) ? (int)INSN_UID (BB_HEAD (else_bb)) : -1);
    4556                 :            : 
    4557                 :          0 :       fprintf (dump_file, ", join %d [%d]",
    4558                 :            :                join_bb->index,
    4559                 :          0 :                BB_HEAD (join_bb) ? (int)INSN_UID (BB_HEAD (join_bb)) : -1);
    4560                 :            : 
    4561                 :          0 :       if (ce_info->num_multiple_test_blocks > 0)
    4562                 :          0 :         fprintf (dump_file, ", %d %s block%s last test %d [%d]",
    4563                 :            :                  ce_info->num_multiple_test_blocks,
    4564                 :          0 :                  (ce_info->and_and_p) ? "&&" : "||",
    4565                 :            :                  (ce_info->num_multiple_test_blocks == 1) ? "" : "s",
    4566                 :            :                  ce_info->last_test_bb->index,
    4567                 :          0 :                  ((BB_HEAD (ce_info->last_test_bb))
    4568                 :          0 :                   ? (int)INSN_UID (BB_HEAD (ce_info->last_test_bb))
    4569                 :            :                   : -1));
    4570                 :            : 
    4571                 :          0 :       fputc ('\n', dump_file);
    4572                 :            :     }
    4573                 :            : 
    4574                 :            :   /* Make sure IF, THEN, and ELSE, blocks are adjacent.  Actually, we get the
    4575                 :            :      first condition for free, since we've already asserted that there's a
    4576                 :            :      fallthru edge from IF to THEN.  Likewise for the && and || blocks, since
    4577                 :            :      we checked the FALLTHRU flag, those are already adjacent to the last IF
    4578                 :            :      block.  */
    4579                 :            :   /* ??? As an enhancement, move the ELSE block.  Have to deal with
    4580                 :            :      BLOCK notes, if by no other means than backing out the merge if they
    4581                 :            :      exist.  Sticky enough I don't want to think about it now.  */
    4582                 :          0 :   next = then_bb;
    4583                 :          0 :   if (else_bb && (next = next->next_bb) != else_bb)
    4584                 :            :     return FALSE;
    4585                 :          0 :   if ((next = next->next_bb) != join_bb
    4586                 :          0 :       && join_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
    4587                 :            :     {
    4588                 :          0 :       if (else_bb)
    4589                 :            :         join_bb = NULL;
    4590                 :            :       else
    4591                 :            :         return FALSE;
    4592                 :            :     }
    4593                 :            : 
    4594                 :            :   /* Do the real work.  */
    4595                 :            : 
    4596                 :          0 :   ce_info->else_bb = else_bb;
    4597                 :          0 :   ce_info->join_bb = join_bb;
    4598                 :            : 
    4599                 :            :   /* If we have && and || tests, try to first handle combining the && and ||
    4600                 :            :      tests into the conditional code, and if that fails, go back and handle
    4601                 :            :      it without the && and ||, which at present handles the && case if there
    4602                 :            :      was no ELSE block.  */
    4603                 :          0 :   if (cond_exec_process_if_block (ce_info, TRUE))
    4604                 :            :     return TRUE;
    4605                 :            : 
    4606                 :          0 :   if (ce_info->num_multiple_test_blocks)
    4607                 :            :     {
    4608                 :          0 :       cancel_changes (0);
    4609                 :            : 
    4610                 :          0 :       if (cond_exec_process_if_block (ce_info, FALSE))
    4611                 :          0 :         return TRUE;
    4612                 :            :     }
    4613                 :            : 
    4614                 :            :   return FALSE;
    4615                 :            : }
    4616                 :            : 
    4617                 :            : /* Convert a branch over a trap, or a branch
    4618                 :            :    to a trap, into a conditional trap.  */
    4619                 :            : 
    4620                 :            : static int
    4621                 :          0 : find_cond_trap (basic_block test_bb, edge then_edge, edge else_edge)
    4622                 :            : {
    4623                 :          0 :   basic_block then_bb = then_edge->dest;
    4624                 :          0 :   basic_block else_bb = else_edge->dest;
    4625                 :          0 :   basic_block other_bb, trap_bb;
    4626                 :          0 :   rtx_insn *trap, *jump;
    4627                 :          0 :   rtx cond;
    4628                 :          0 :   rtx_insn *cond_earliest;
    4629                 :            : 
    4630                 :            :   /* Locate the block with the trap instruction.  */
    4631                 :            :   /* ??? While we look for no successors, we really ought to allow
    4632                 :            :      EH successors.  Need to fix merge_if_block for that to work.  */
    4633                 :          0 :   if ((trap = block_has_only_trap (then_bb)) != NULL)
    4634                 :            :     trap_bb = then_bb, other_bb = else_bb;
    4635                 :          0 :   else if ((trap = block_has_only_trap (else_bb)) != NULL)
    4636                 :            :     trap_bb = else_bb, other_bb = then_bb;
    4637                 :            :   else
    4638                 :            :     return FALSE;
    4639                 :            : 
    4640                 :          0 :   if (dump_file)
    4641                 :            :     {
    4642                 :          0 :       fprintf (dump_file, "\nTRAP-IF block found, start %d, trap %d\n",
    4643                 :            :                test_bb->index, trap_bb->index);
    4644                 :            :     }
    4645                 :            : 
    4646                 :            :   /* If this is not a standard conditional jump, we can't parse it.  */
    4647                 :          0 :   jump = BB_END (test_bb);
    4648                 :          0 :   cond = noce_get_condition (jump, &cond_earliest, then_bb == trap_bb);
    4649                 :          0 :   if (! cond)
    4650                 :            :     return FALSE;
    4651                 :            : 
    4652                 :            :   /* If the conditional jump is more than just a conditional jump, then
    4653                 :            :      we cannot do if-conversion on this block.  Give up for returnjump_p,
    4654                 :            :      changing a conditional return followed by unconditional trap for
    4655                 :            :      conditional trap followed by unconditional return is likely not
    4656                 :            :      beneficial and harder to handle.  */
    4657                 :          0 :   if (! onlyjump_p (jump) || returnjump_p (jump))
    4658                 :          0 :     return FALSE;
    4659                 :            : 
    4660                 :            :   /* We must be comparing objects whose modes imply the size.  */
    4661                 :          0 :   if (GET_MODE (XEXP (cond, 0)) == BLKmode)
    4662                 :            :     return FALSE;
    4663                 :            : 
    4664                 :            :   /* Attempt to generate the conditional trap.  */
    4665                 :          0 :   rtx_insn *seq = gen_cond_trap (GET_CODE (cond), copy_rtx (XEXP (cond, 0)),
    4666                 :            :                                  copy_rtx (XEXP (cond, 1)),
    4667                 :          0 :                                  TRAP_CODE (PATTERN (trap)));
    4668                 :          0 :   if (seq == NULL)
    4669                 :            :     return FALSE;
    4670                 :            : 
    4671                 :            :   /* If that results in an invalid insn, back out.  */
    4672                 :          0 :   for (rtx_insn *x = seq; x; x = NEXT_INSN (x))
    4673                 :          0 :     if (recog_memoized (x) < 0)
    4674                 :            :       return FALSE;
    4675                 :            : 
    4676                 :            :   /* Emit the new insns before cond_earliest.  */
    4677                 :          0 :   emit_insn_before_setloc (seq, cond_earliest, INSN_LOCATION (trap));
    4678                 :            : 
    4679                 :            :   /* Delete the trap block if possible.  */
    4680                 :          0 :   remove_edge (trap_bb == then_bb ? then_edge : else_edge);
    4681                 :          0 :   df_set_bb_dirty (test_bb);
    4682                 :          0 :   df_set_bb_dirty (then_bb);
    4683                 :          0 :   df_set_bb_dirty (else_bb);
    4684                 :            : 
    4685                 :          0 :   if (EDGE_COUNT (trap_bb->preds) == 0)
    4686                 :            :     {
    4687                 :          0 :       delete_basic_block (trap_bb);
    4688                 :          0 :       num_true_changes++;
    4689                 :            :     }
    4690                 :            : 
    4691                 :            :   /* Wire together the blocks again.  */
    4692                 :          0 :   if (current_ir_type () == IR_RTL_CFGLAYOUT)
    4693                 :          0 :     single_succ_edge (test_bb)->flags |= EDGE_FALLTHRU;
    4694                 :          0 :   else if (trap_bb == then_bb)
    4695                 :            :     {
    4696                 :          0 :       rtx lab = JUMP_LABEL (jump);
    4697                 :          0 :       rtx_insn *seq = targetm.gen_jump (lab);
    4698                 :          0 :       rtx_jump_insn *newjump = emit_jump_insn_after (seq, jump);
    4699                 :          0 :       LABEL_NUSES (lab) += 1;
    4700                 :          0 :       JUMP_LABEL (newjump) = lab;
    4701                 :          0 :       emit_barrier_after (newjump);
    4702                 :            :     }
    4703                 :          0 :   delete_insn (jump);
    4704                 :            : 
    4705                 :          0 :   if (can_merge_blocks_p (test_bb, other_bb))
    4706                 :            :     {
    4707                 :          0 :       merge_blocks (test_bb, other_bb);
    4708                 :          0 :       num_true_changes++;
    4709                 :            :     }
    4710                 :            : 
    4711                 :          0 :   num_updated_if_blocks++;
    4712                 :          0 :   return TRUE;
    4713                 :            : }
    4714                 :            : 
    4715                 :            : /* Subroutine of find_cond_trap: if BB contains only a trap insn,
    4716                 :            :    return it.  */
    4717                 :            : 
    4718                 :            : static rtx_insn *
    4719                 :          0 : block_has_only_trap (basic_block bb)
    4720                 :            : {
    4721                 :          0 :   rtx_insn *trap;
    4722                 :            : 
    4723                 :            :   /* We're not the exit block.  */
    4724                 :          0 :   if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
    4725                 :            :     return NULL;
    4726                 :            : 
    4727                 :            :   /* The block must have no successors.  */
    4728                 :          0 :   if (EDGE_COUNT (bb->succs) > 0)
    4729                 :            :     return NULL;
    4730                 :            : 
    4731                 :            :   /* The only instruction in the THEN block must be the trap.  */
    4732                 :          0 :   trap = first_active_insn (bb);
    4733                 :          0 :   if (! (trap == BB_END (bb)
    4734                 :          0 :          && GET_CODE (PATTERN (trap)) == TRAP_IF
    4735                 :          0 :          && TRAP_CONDITION (PATTERN (trap)) == const_true_rtx))
    4736                 :          0 :     return NULL;
    4737                 :            : 
    4738                 :            :   return trap;
    4739                 :            : }
    4740                 :            : 
    4741                 :            : /* Look for IF-THEN-ELSE cases in which one of THEN or ELSE is
    4742                 :            :    transformable, but not necessarily the other.  There need be no
    4743                 :            :    JOIN block.
    4744                 :            : 
    4745                 :            :    Return TRUE if we were successful at converting the block.
    4746                 :            : 
    4747                 :            :    Cases we'd like to look at:
    4748                 :            : 
    4749                 :            :    (1)
    4750                 :            :         if (test) goto over; // x not live
    4751                 :            :         x = a;
    4752                 :            :         goto label;
    4753                 :            :         over:
    4754                 :            : 
    4755                 :            :    becomes
    4756                 :            : 
    4757                 :            :         x = a;
    4758                 :            :         if (! test) goto label;
    4759                 :            : 
    4760                 :            :    (2)
    4761                 :            :         if (test) goto E; // x not live
    4762                 :            :         x = big();
    4763                 :            :         goto L;
    4764                 :            :         E:
    4765                 :            :         x = b;
    4766                 :            :         goto M;
    4767                 :            : 
    4768                 :            :    becomes
    4769                 :            : 
    4770                 :            :         x = b;
    4771                 :            :         if (test) goto M;
    4772                 :            :         x = big();
    4773                 :            :         goto L;
    4774                 :            : 
    4775                 :            :    (3) // This one's really only interesting for targets that can do
    4776                 :            :        // multiway branching, e.g. IA-64 BBB bundles.  For other targets
    4777                 :            :        // it results in multiple branches on a cache line, which often
    4778                 :            :        // does not sit well with predictors.
    4779                 :            : 
    4780                 :            :         if (test1) goto E; // predicted not taken
    4781                 :            :         x = a;
    4782                 :            :         if (test2) goto F;
    4783                 :            :         ...
    4784                 :            :         E:
    4785                 :            :         x = b;
    4786                 :            :         J:
    4787                 :            : 
    4788                 :            :    becomes
    4789                 :            : 
    4790                 :            :         x = a;
    4791                 :            :         if (test1) goto E;
    4792                 :            :         if (test2) goto F;
    4793                 :            : 
    4794                 :            :    Notes:
    4795                 :            : 
    4796                 :            :    (A) Don't do (2) if the branch is predicted against the block we're
    4797                 :            :    eliminating.  Do it anyway if we can eliminate a branch; this requires
    4798                 :            :    that the sole successor of the eliminated block postdominate the other
    4799                 :            :    side of the if.
    4800                 :            : 
    4801                 :            :    (B) With CE, on (3) we can steal from both sides of the if, creating
    4802                 :            : 
    4803                 :            :         if (test1) x = a;
    4804                 :            :         if (!test1) x = b;
    4805                 :            :         if (test1) goto J;
    4806                 :            :         if (test2) goto F;
    4807                 :            :         ...
    4808                 :            :         J:
    4809                 :            : 
    4810                 :            :    Again, this is most useful if J postdominates.
    4811                 :            : 
    4812                 :            :    (C) CE substitutes for helpful life information.
    4813                 :            : 
    4814                 :            :    (D) These heuristics need a lot of work.  */
    4815                 :            : 
    4816                 :            : /* Tests for case 1 above.  */
    4817                 :            : 
    4818                 :            : static int
    4819                 :    9050360 : find_if_case_1 (basic_block test_bb, edge then_edge, edge else_edge)
    4820                 :            : {
    4821                 :    9050360 :   basic_block then_bb = then_edge->dest;
    4822                 :    9050360 :   basic_block else_bb = else_edge->dest;
    4823                 :    9050360 :   basic_block new_bb;
    4824                 :    9050360 :   int then_bb_index;
    4825                 :    9050360 :   profile_probability then_prob;
    4826                 :    9050360 :   rtx else_target = NULL_RTX;
    4827                 :            : 
    4828                 :            :   /* If we are partitioning hot/cold basic blocks, we don't want to
    4829                 :            :      mess up unconditional or indirect jumps that cross between hot
    4830                 :            :      and cold sections.
    4831                 :            : 
    4832                 :            :      Basic block partitioning may result in some jumps that appear to
    4833                 :            :      be optimizable (or blocks that appear to be mergeable), but which really
    4834                 :            :      must be left untouched (they are required to make it safely across
    4835                 :            :      partition boundaries).  See  the comments at the top of
    4836                 :            :      bb-reorder.c:partition_hot_cold_basic_blocks for complete details.  */
    4837                 :            : 
    4838                 :    9050360 :   if ((BB_END (then_bb)
    4839                 :    9050360 :        && JUMP_P (BB_END (then_bb))
    4840                 :    4881190 :        && CROSSING_JUMP_P (BB_END (then_bb)))
    4841                 :    8848410 :       || (BB_END (test_bb)
    4842                 :    8848410 :           && JUMP_P (BB_END (test_bb))
    4843                 :    8848410 :           && CROSSING_JUMP_P (BB_END (test_bb)))
    4844                 :   17827300 :       || (BB_END (else_bb)
    4845                 :    8776900 :           && JUMP_P (BB_END (else_bb))
    4846                 :    4078790 :           && CROSSING_JUMP_P (BB_END (else_bb))))
    4847                 :            :     return FALSE;
    4848                 :            : 
    4849                 :            :   /* THEN has one successor.  */
    4850                 :    8763320 :   if (!single_succ_p (then_bb))
    4851                 :            :     return FALSE;
    4852                 :            : 
    4853                 :            :   /* THEN does not fall through, but is not strange either.  */
    4854                 :    3878870 :   if (single_succ_edge (then_bb)->flags & (EDGE_COMPLEX | EDGE_FALLTHRU))
    4855                 :            :     return FALSE;
    4856                 :            : 
    4857                 :            :   /* THEN has one predecessor.  */
    4858                 :     739560 :   if (!single_pred_p (then_bb))
    4859                 :            :     return FALSE;
    4860                 :            : 
    4861                 :            :   /* THEN must do something.  */
    4862                 :     676351 :   if (forwarder_block_p (then_bb))
    4863                 :            :     return FALSE;
    4864                 :            : 
    4865                 :     426744 :   num_possible_if_blocks++;
    4866                 :     426744 :   if (dump_file)
    4867                 :          4 :     fprintf (dump_file,
    4868                 :            :              "\nIF-CASE-1 found, start %d, then %d\n",
    4869                 :            :              test_bb->index, then_bb->index);
    4870                 :            : 
    4871                 :     426744 :   then_prob = then_edge->probability.invert ();
    4872                 :            : 
    4873                 :            :   /* We're speculating from the THEN path, we want to make sure the cost
    4874                 :            :      of speculation is within reason.  */
    4875                 :     822346 :   if (! cheap_bb_rtx_cost_p (then_bb, then_prob,
    4876                 :     822346 :         COSTS_N_INSNS (BRANCH_COST (optimize_bb_for_speed_p (then_edge->src),
    4877                 :            :                                     predictable_edge_p (then_edge)))))
    4878                 :            :     return FALSE;
    4879                 :            : 
    4880                 :      88543 :   if (else_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
    4881                 :            :     {
    4882                 :          0 :       rtx_insn *jump = BB_END (else_edge->src);
    4883                 :          0 :       gcc_assert (JUMP_P (jump));
    4884                 :          0 :       else_target = JUMP_LABEL (jump);
    4885                 :            :     }
    4886                 :            : 
    4887                 :            :   /* Registers set are dead, or are predicable.  */
    4888                 :      88543 :   if (! dead_or_predicable (test_bb, then_bb, else_bb,
    4889                 :            :                             single_succ_edge (then_bb), 1))
    4890                 :            :     return FALSE;
    4891                 :            : 
    4892                 :            :   /* Conversion went ok, including moving the insns and fixing up the
    4893                 :            :      jump.  Adjust the CFG to match.  */
    4894                 :            : 
    4895                 :            :   /* We can avoid creating a new basic block if then_bb is immediately
    4896                 :            :      followed by else_bb, i.e. deleting then_bb allows test_bb to fall
    4897                 :            :      through to else_bb.  */
    4898                 :            : 
    4899                 :       8120 :   if (then_bb->next_bb == else_bb
    4900                 :       4226 :       && then_bb->prev_bb == test_bb
    4901                 :       4226 :       && else_bb != EXIT_BLOCK_PTR_FOR_FN (cfun))
    4902                 :            :     {
    4903                 :       4226 :       redirect_edge_succ (FALLTHRU_EDGE (test_bb), else_bb);
    4904                 :       4226 :       new_bb = 0;
    4905                 :            :     }
    4906                 :       3894 :   else if (else_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
    4907                 :          0 :     new_bb = force_nonfallthru_and_redirect (FALLTHRU_EDGE (test_bb),
    4908                 :            :                                              else_bb, else_target);
    4909                 :            :   else
    4910                 :       3894 :     new_bb = redirect_edge_and_branch_force (FALLTHRU_EDGE (test_bb),
    4911                 :            :                                              else_bb);
    4912                 :            : 
    4913                 :       8120 :   df_set_bb_dirty (test_bb);
    4914                 :       8120 :   df_set_bb_dirty (else_bb);
    4915                 :            : 
    4916                 :       8120 :   then_bb_index = then_bb->index;
    4917                 :       8120 :   delete_basic_block (then_bb);
    4918                 :            : 
    4919                 :            :   /* Make rest of code believe that the newly created block is the THEN_BB
    4920                 :            :      block we removed.  */
    4921                 :       8120 :   if (new_bb)
    4922                 :            :     {
    4923                 :       3892 :       df_bb_replace (then_bb_index, new_bb);
    4924                 :            :       /* This should have been done above via force_nonfallthru_and_redirect
    4925                 :            :          (possibly called from redirect_edge_and_branch_force).  */
    4926                 :       3892 :       gcc_checking_assert (BB_PARTITION (new_bb) == BB_PARTITION (test_bb));
    4927                 :            :     }
    4928                 :            : 
    4929                 :       8120 :   num_true_changes++;
    4930                 :       8120 :   num_updated_if_blocks++;
    4931                 :       8120 :   return TRUE;
    4932                 :            : }
    4933                 :            : 
    4934                 :            : /* Test for case 2 above.  */
    4935                 :            : 
    4936                 :            : static int
    4937                 :    9042240 : find_if_case_2 (basic_block test_bb, edge then_edge, edge else_edge)
    4938                 :            : {
    4939                 :    9042240 :   basic_block then_bb = then_edge->dest;
    4940                 :    9042240 :   basic_block else_bb = else_edge->dest;
    4941                 :    9042240 :   edge else_succ;
    4942                 :    9042240 :   profile_probability then_prob, else_prob;
    4943                 :            : 
    4944                 :            :   /* We do not want to speculate (empty) loop latches.  */
    4945                 :    9042240 :   if (current_loops
    4946                 :    3546510 :       && else_bb->loop_father->latch == else_bb)
    4947                 :            :     return FALSE;
    4948                 :            : 
    4949                 :            :   /* If we are partitioning hot/cold basic blocks, we don't want to
    4950                 :            :      mess up unconditional or indirect jumps that cross between hot
    4951                 :            :      and cold sections.
    4952                 :            : 
    4953                 :            :      Basic block partitioning may result in some jumps that appear to
    4954                 :            :      be optimizable (or blocks that appear to be mergeable), but which really
    4955                 :            :      must be left untouched (they are required to make it safely across
    4956                 :            :      partition boundaries).  See  the comments at the top of
    4957                 :            :      bb-reorder.c:partition_hot_cold_basic_blocks for complete details.  */
    4958                 :            : 
    4959                 :    8939440 :   if ((BB_END (then_bb)
    4960                 :    8939440 :        && JUMP_P (BB_END (then_bb))
    4961                 :    4820060 :        && CROSSING_JUMP_P (BB_END (then_bb)))
    4962                 :    8737490 :       || (BB_END (test_bb)
    4963                 :    8737490 :           && JUMP_P (BB_END (test_bb))
    4964                 :    8737490 :           && CROSSING_JUMP_P (BB_END (test_bb)))
    4965                 :   17605400 :       || (BB_END (else_bb)
    4966                 :    8665970 :           && JUMP_P (BB_END (else_bb))
    4967                 :    3984260 :           && CROSSING_JUMP_P (BB_END (else_bb))))
    4968                 :            :     return FALSE;
    4969                 :            : 
    4970                 :            :   /* ELSE has one successor.  */
    4971                 :    8652400 :   if (!single_succ_p (else_bb))
    4972                 :            :     return FALSE;
    4973                 :            :   else
    4974                 :    3695660 :     else_succ = single_succ_edge (else_bb);
    4975                 :            : 
    4976                 :            :   /* ELSE outgoing edge is not complex.  */
    4977                 :    3695660 :   if (else_succ->flags & EDGE_COMPLEX)
    4978                 :            :     return FALSE;
    4979                 :            : 
    4980                 :            :   /* ELSE has one predecessor.  */
    4981                 :    3590000 :   if (!single_pred_p (else_bb))
    4982                 :            :     return FALSE;
    4983                 :            : 
    4984                 :            :   /* THEN is not EXIT.  */
    4985                 :    2104120 :   if (then_bb->index < NUM_FIXED_BLOCKS)
    4986                 :            :     return FALSE;
    4987                 :            : 
    4988                 :    2104120 :   else_prob = else_edge->probability;
    4989                 :    2104120 :   then_prob = else_prob.invert ();
    4990                 :            : 
    4991                 :            :   /* ELSE is predicted or SUCC(ELSE) postdominates THEN.  */
    4992                 :    2104120 :   if (else_prob > then_prob)
    4993                 :            :     ;
    4994                 :    1401800 :   else if (else_succ->dest->index < NUM_FIXED_BLOCKS
    4995                 :    1401800 :            || dominated_by_p (CDI_POST_DOMINATORS, then_bb,
    4996                 :            :                               else_succ->dest))
    4997                 :            :     ;
    4998                 :            :   else
    4999                 :            :     return FALSE;
    5000                 :            : 
    5001                 :    1830920 :   num_possible_if_blocks++;
    5002                 :    1830920 :   if (dump_file)
    5003                 :         35 :     fprintf (dump_file,
    5004                 :            :              "\nIF-CASE-2 found, start %d, else %d\n",
    5005                 :            :              test_bb->index, else_bb->index);
    5006                 :            : 
    5007                 :            :   /* We're speculating from the ELSE path, we want to make sure the cost
    5008                 :            :      of speculation is within reason.  */
    5009                 :    3385640 :   if (! cheap_bb_rtx_cost_p (else_bb, else_prob,
    5010                 :    3385640 :         COSTS_N_INSNS (BRANCH_COST (optimize_bb_for_speed_p (else_edge->src),
    5011                 :            :                                     predictable_edge_p (else_edge)))))
    5012                 :            :     return FALSE;
    5013                 :            : 
    5014                 :            :   /* Registers set are dead, or are predicable.  */
    5015                 :     338245 :   if (! dead_or_predicable (test_bb, else_bb, then_bb, else_succ, 0))
    5016                 :            :     return FALSE;
    5017                 :            : 
    5018                 :            :   /* Conversion went ok, including moving the insns and fixing up the
    5019                 :            :      jump.  Adjust the CFG to match.  */
    5020                 :            : 
    5021                 :     125940 :   df_set_bb_dirty (test_bb);
    5022                 :     125940 :   df_set_bb_dirty (then_bb);
    5023                 :     125940 :   delete_basic_block (else_bb);
    5024                 :            : 
    5025                 :     125940 :   num_true_changes++;
    5026                 :     125940 :   num_updated_if_blocks++;
    5027                 :            : 
    5028                 :            :   /* ??? We may now fallthru from one of THEN's successors into a join
    5029                 :            :      block.  Rerun cleanup_cfg?  Examine things manually?  Wait?  */
    5030                 :            : 
    5031                 :     125940 :   return TRUE;
    5032                 :            : }
    5033                 :            : 
    5034                 :            : /* Used by the code above to perform the actual rtl transformations.
    5035                 :            :    Return TRUE if successful.
    5036                 :            : 
    5037                 :            :    TEST_BB is the block containing the conditional branch.  MERGE_BB
    5038                 :            :    is the block containing the code to manipulate.  DEST_EDGE is an
    5039                 :            :    edge representing a jump to the join block; after the conversion,
    5040                 :            :    TEST_BB should be branching to its destination.
    5041                 :            :    REVERSEP is true if the sense of the branch should be reversed.  */
    5042                 :            : 
    5043                 :            : static int
    5044                 :     426788 : dead_or_predicable (basic_block test_bb, basic_block merge_bb,
    5045                 :            :                     basic_block other_bb, edge dest_edge, int reversep)
    5046                 :            : {
    5047                 :     426788 :   basic_block new_dest = dest_edge->dest;
    5048                 :     426788 :   rtx_insn *head, *end, *jump;
    5049                 :     426788 :   rtx_insn *earliest = NULL;
    5050                 :     426788 :   rtx old_dest;
    5051                 :     426788 :   bitmap merge_set = NULL;
    5052                 :            :   /* Number of pending changes.  */
    5053                 :     426788 :   int n_validated_changes = 0;
    5054                 :     426788 :   rtx new_dest_label = NULL_RTX;
    5055                 :            : 
    5056                 :     426788 :   jump = BB_END (test_bb);
    5057                 :            : 
    5058                 :            :   /* Find the extent of the real code in the merge block.  */
    5059                 :     426788 :   head = BB_HEAD (merge_bb);
    5060                 :     426788 :   end = BB_END (merge_bb);
    5061                 :            : 
    5062                 :     491459 :   while (DEBUG_INSN_P (end) && end != head)
    5063                 :      64671 :     end = PREV_INSN (end);
    5064                 :            : 
    5065                 :            :   /* If merge_bb ends with a tablejump, predicating/moving insn's
    5066                 :            :      into test_bb and then deleting merge_bb will result in the jumptable
    5067                 :            :      that follows merge_bb being removed along with merge_bb and then we
    5068                 :            :      get an unresolved reference to the jumptable.  */
    5069                 :     426788 :   if (tablejump_p (end, NULL, NULL))
    5070                 :            :     return FALSE;
    5071                 :            : 
    5072                 :     426788 :   if (LABEL_P (head))
    5073                 :     338289 :     head = NEXT_INSN (head);
    5074                 :     426788 :   while (DEBUG_INSN_P (head) && head != end)
    5075                 :          0 :     head = NEXT_INSN (head);
    5076                 :     426788 :   if (NOTE_P (head))
    5077                 :            :     {
    5078                 :     426788 :       if (head == end)
    5079                 :            :         {
    5080                 :      84051 :           head = end = NULL;
    5081                 :      84051 :           goto no_body;
    5082                 :            :         }
    5083                 :     342737 :       head = NEXT_INSN (head);
    5084                 :     645834 :       while (DEBUG_INSN_P (head) && head != end)
    5085                 :     303097 :         head = NEXT_INSN (head);
    5086                 :            :     }
    5087                 :            : 
    5088                 :     342737 :   if (JUMP_P (end))
    5089                 :            :     {
    5090                 :     132447 :       if (!onlyjump_p (end))
    5091                 :            :         return FALSE;
    5092                 :      99691 :       if (head == end)
    5093                 :            :         {
    5094                 :          5 :           head = end = NULL;
    5095                 :          5 :           goto no_body;
    5096                 :            :         }
    5097                 :      99686 :       end = PREV_INSN (end);
    5098                 :     118636 :       while (DEBUG_INSN_P (end) && end != head)
    5099                 :      18950 :         end = PREV_INSN (end);
    5100                 :            :     }
    5101                 :            : 
    5102                 :            :   /* Don't move frame-related insn across the conditional branch.  This
    5103                 :            :      can lead to one of the paths of the branch having wrong unwind info.  */
    5104                 :     309976 :   if (epilogue_completed)
    5105                 :            :     {
    5106                 :            :       rtx_insn *insn = head;
    5107                 :      29968 :       while (1)
    5108                 :            :         {
    5109                 :     157018 :           if (INSN_P (insn) && RTX_FRAME_RELATED_P (insn))
    5110                 :            :             return FALSE;
    5111                 :     156819 :           if (insn == end)
    5112                 :            :             break;
    5113                 :      29968 :           insn = NEXT_INSN (insn);
    5114                 :      29968 :         }
    5115                 :            :     }
    5116                 :            : 
    5117                 :            :   /* Disable handling dead code by conditional execution if the machine needs
    5118                 :            :      to do anything funny with the tests, etc.  */
    5119                 :            : #ifndef IFCVT_MODIFY_TESTS
    5120                 :     309777 :   if (targetm.have_conditional_execution ())
    5121                 :            :     {
    5122                 :            :       /* In the conditional execution case, we have things easy.  We know
    5123                 :            :          the condition is reversible.  We don't have to check life info
    5124                 :            :          because we're going to conditionally execute the code anyway.
    5125                 :            :          All that's left is making sure the insns involved can actually
    5126                 :            :          be predicated.  */
    5127                 :            : 
    5128                 :          0 :       rtx cond;
    5129                 :            : 
    5130                 :          0 :       cond = cond_exec_get_condition (jump);
    5131                 :          0 :       if (! cond)
    5132                 :          0 :         return FALSE;
    5133                 :            : 
    5134                 :          0 :       rtx note = find_reg_note (jump, REG_BR_PROB, NULL_RTX);
    5135                 :          0 :       profile_probability prob_val
    5136                 :          0 :           = (note ? profile_probability::from_reg_br_prob_note (XINT (note, 0))
    5137                 :          0 :              : profile_probability::uninitialized ());
    5138                 :            : 
    5139                 :          0 :       if (reversep)
    5140                 :            :         {
    5141                 :          0 :           enum rtx_code rev = reversed_comparison_code (cond, jump);
    5142                 :          0 :           if (rev == UNKNOWN)
    5143                 :            :             return FALSE;
    5144                 :          0 :           cond = gen_rtx_fmt_ee (rev, GET_MODE (cond), XEXP (cond, 0),
    5145                 :            :                                  XEXP (cond, 1));
    5146                 :          0 :           prob_val = prob_val.invert ();
    5147                 :            :         }
    5148                 :            : 
    5149                 :          0 :       if (cond_exec_process_insns (NULL, head, end, cond, prob_val, 0)
    5150                 :          0 :           && verify_changes (0))
    5151                 :          0 :         n_validated_changes = num_validated_changes ();
    5152                 :            :       else
    5153                 :          0 :         cancel_changes (0);
    5154                 :            : 
    5155                 :          0 :       earliest = jump;
    5156                 :            :     }
    5157                 :            : #endif
    5158                 :            : 
    5159                 :            :   /* If we allocated new pseudos (e.g. in the conditional move
    5160                 :            :      expander called from noce_emit_cmove), we must resize the
    5161                 :            :      array first.  */
    5162                 :     309777 :   if (max_regno < max_reg_num ())
    5163                 :      61344 :     max_regno = max_reg_num ();
    5164                 :            : 
    5165                 :            :   /* Try the NCE path if the CE path did not result in any changes.  */
    5166                 :     309777 :   if (n_validated_changes == 0)
    5167                 :            :     {
    5168                 :     309777 :       rtx cond;
    5169                 :     309777 :       rtx_insn *insn;
    5170                 :     309777 :       regset live;
    5171                 :     309777 :       bool success;
    5172                 :            : 
    5173                 :            :       /* In the non-conditional execution case, we have to verify that there
    5174                 :            :          are no trapping operations, no calls, no references to memory, and
    5175                 :            :          that any registers modified are dead at the branch site.  */
    5176                 :            : 
    5177                 :     309777 :       if (!any_condjump_p (jump))
    5178                 :            :         return FALSE;
    5179                 :            : 
    5180                 :            :       /* Find the extent of the conditional.  */
    5181                 :     309721 :       cond = noce_get_condition (jump, &earliest, false);
    5182                 :     309721 :       if (!cond)
    5183                 :            :         return FALSE;
    5184                 :            : 
    5185                 :     309721 :       live = BITMAP_ALLOC (&reg_obstack);
    5186                 :     309721 :       simulate_backwards_to_point (merge_bb, live, end);
    5187                 :     309721 :       success = can_move_insns_across (head, end, earliest, jump,
    5188                 :            :                                        merge_bb, live,
    5189                 :            :                                        df_get_live_in (other_bb), NULL);
    5190                 :     309721 :       BITMAP_FREE (live);
    5191                 :     309721 :       if (!success)
    5192                 :            :         return FALSE;
    5193                 :            : 
    5194                 :            :       /* Collect the set of registers set in MERGE_BB.  */
    5195                 :     117195 :       merge_set = BITMAP_ALLOC (&reg_obstack);
    5196                 :            : 
    5197                 :    1018880 :       FOR_BB_INSNS (merge_bb, insn)
    5198                 :     450843 :         if (NONDEBUG_INSN_P (insn))
    5199                 :     144000 :           df_simulate_find_defs (insn, merge_set);
    5200                 :            : 
    5201                 :            :       /* If shrink-wrapping, disable this optimization when test_bb is
    5202                 :            :          the first basic block and merge_bb exits.  The idea is to not
    5203                 :            :          move code setting up a return register as that may clobber a
    5204                 :            :          register used to pass function parameters, which then must be
    5205                 :            :          saved in caller-saved regs.  A caller-saved reg requires the
    5206                 :            :          prologue, killing a shrink-wrap opportunity.  */
    5207                 :     117195 :       if ((SHRINK_WRAPPING_ENABLED && !epilogue_completed)
    5208                 :     100987 :           && ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb == test_bb
    5209                 :      19559 :           && single_succ_p (new_dest)
    5210                 :      13650 :           && single_succ (new_dest) == EXIT_BLOCK_PTR_FOR_FN (cfun)
    5211                 :     130352 :           && bitmap_intersect_p (df_get_live_in (new_dest), merge_set))
    5212                 :            :         {
    5213                 :      13156 :           regset return_regs;
    5214                 :      13156 :           unsigned int i;
    5215                 :            : 
    5216                 :      13156 :           return_regs = BITMAP_ALLOC (&reg_obstack);
    5217                 :            : 
    5218                 :            :           /* Start off with the intersection of regs used to pass
    5219                 :            :              params and regs used to return values.  */
    5220                 :    1013010 :           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
    5221                 :     999856 :             if (FUNCTION_ARG_REGNO_P (i)
    5222                 :     999856 :                 && targetm.calls.function_value_regno_p (i))
    5223                 :      68623 :               bitmap_set_bit (return_regs, INCOMING_REGNO (i));
    5224                 :            : 
    5225                 :      13156 :           bitmap_and_into (return_regs,
    5226                 :      13156 :                            df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
    5227                 :      13156 :           bitmap_and_into (return_regs,
    5228                 :      13156 :                            df_get_live_in (EXIT_BLOCK_PTR_FOR_FN (cfun)));
    5229                 :      13156 :           if (!bitmap_empty_p (return_regs))
    5230                 :            :             {
    5231                 :       7215 :               FOR_BB_INSNS_REVERSE (new_dest, insn)
    5232                 :       3351 :                 if (NONDEBUG_INSN_P (insn))
    5233                 :            :                   {
    5234                 :       1730 :                     df_ref def;
    5235                 :            : 
    5236                 :            :                     /* If this insn sets any reg in return_regs, add all
    5237                 :            :                        reg uses to the set of regs we're interested in.  */
    5238                 :       2340 :                     FOR_EACH_INSN_DEF (def, insn)
    5239                 :       1229 :                       if (bitmap_bit_p (return_regs, DF_REF_REGNO (def)))
    5240                 :            :                         {
    5241                 :        619 :                           df_simulate_uses (insn, return_regs);
    5242                 :        619 :                           break;
    5243                 :            :                         }
    5244                 :            :                   }
    5245                 :        513 :               if (bitmap_intersect_p (merge_set, return_regs))
    5246                 :            :                 {
    5247                 :        512 :                   BITMAP_FREE (return_regs);
    5248                 :        512 :                   BITMAP_FREE (merge_set);
    5249                 :        512 :                   return FALSE;
    5250                 :            :                 }
    5251                 :            :             }
    5252                 :      12644 :           BITMAP_FREE (return_regs);
    5253                 :            :         }
    5254                 :            :     }
    5255                 :            : 
    5256                 :     200739 :  no_body:
    5257                 :            :   /* We don't want to use normal invert_jump or redirect_jump because
    5258                 :            :      we don't want to delete_insn called.  Also, we want to do our own
    5259                 :            :      change group management.  */
    5260                 :            : 
    5261                 :     200739 :   old_dest = JUMP_LABEL (jump);
    5262                 :     200739 :   if (other_bb != new_dest)
    5263                 :            :     {
    5264                 :     200729 :       if (!any_condjump_p (jump))
    5265                 :         16 :         goto cancel;
    5266                 :            : 
    5267                 :     200713 :       if (JUMP_P (BB_END (dest_edge->src)))
    5268                 :       8585 :         new_dest_label = JUMP_LABEL (BB_END (dest_edge->src));
    5269                 :     192128 :       else if (new_dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
    5270                 :      66663 :         new_dest_label = ret_rtx;
    5271                 :            :       else
    5272                 :     125465 :         new_dest_label = block_label (new_dest);
    5273                 :            : 
    5274                 :     200713 :       rtx_jump_insn *jump_insn = as_a <rtx_jump_insn *> (jump);
    5275                 :     200713 :       if (reversep
    5276                 :     393308 :           ? ! invert_jump_1 (jump_insn, new_dest_label)
    5277                 :     192595 :           : ! redirect_jump_1 (jump_insn, new_dest_label))
    5278                 :          0 :         goto cancel;
    5279                 :            :     }
    5280                 :            : 
    5281                 :     200723 :   if (verify_changes (n_validated_changes))
    5282                 :     134060 :     confirm_change_group ();
    5283                 :            :   else
    5284                 :      66663 :     goto cancel;
    5285                 :            : 
    5286                 :     134060 :   if (other_bb != new_dest)
    5287                 :            :     {
    5288                 :     134050 :       redirect_jump_2 (as_a <rtx_jump_insn *> (jump), old_dest, new_dest_label,
    5289                 :            :                        0, reversep);
    5290                 :            : 
    5291                 :     134050 :       redirect_edge_succ (BRANCH_EDGE (test_bb), new_dest);
    5292                 :     134050 :       if (reversep)
    5293                 :            :         {
    5294                 :       8118 :           std::swap (BRANCH_EDGE (test_bb)->probability,
    5295                 :       8118 :                      FALLTHRU_EDGE (test_bb)->probability);
    5296                 :       8118 :           update_br_prob_note (test_bb);
    5297                 :            :         }
    5298                 :            :     }
    5299                 :            : 
    5300                 :            :   /* Move the insns out of MERGE_BB to before the branch.  */
    5301                 :     134060 :   if (head != NULL)
    5302                 :            :     {
    5303                 :     116683 :       rtx_insn *insn;
    5304                 :            : 
    5305                 :     116683 :       if (end == BB_END (merge_bb))
    5306                 :      96998 :         BB_END (merge_bb) = PREV_INSN (head);
    5307                 :            : 
    5308                 :            :       /* PR 21767: when moving insns above a conditional branch, the REG_EQUAL
    5309                 :            :          notes being moved might become invalid.  */
    5310                 :            :       insn = head;
    5311                 :     137575 :       do
    5312                 :            :         {
    5313                 :     137575 :           rtx note;
    5314                 :            : 
    5315                 :     137575 :           if (! INSN_P (insn))
    5316                 :       1838 :             continue;
    5317                 :     135737 :           note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
    5318                 :     135737 :           if (! note)
    5319                 :     128737 :             continue;
    5320                 :       7000 :           remove_note (insn, note);
    5321                 :     137575 :         } while (insn != end && (insn = NEXT_INSN (insn)));
    5322                 :            : 
    5323                 :            :       /* PR46315: when moving insns above a conditional branch, the REG_EQUAL
    5324                 :            :          notes referring to the registers being set might become invalid.  */
    5325                 :     116683 :       if (merge_set)
    5326                 :            :         {
    5327                 :     116683 :           unsigned i;
    5328                 :     116683 :           bitmap_iterator bi;
    5329                 :            : 
    5330                 :     263170 :           EXECUTE_IF_SET_IN_BITMAP (merge_set, 0, i, bi)
    5331                 :     146487 :             remove_reg_equal_equiv_notes_for_regno (i);
    5332                 :            : 
    5333                 :     116683 :           BITMAP_FREE (merge_set);
    5334                 :            :         }
    5335                 :            : 
    5336                 :     116683 :       reorder_insns (head, end, PREV_INSN (earliest));
    5337                 :            :     }
    5338                 :            : 
    5339                 :            :   /* Remove the jump and edge if we can.  */
    5340                 :     134060 :   if (other_bb == new_dest)
    5341                 :            :     {
    5342                 :         10 :       delete_insn (jump);
    5343                 :         10 :       remove_edge (BRANCH_EDGE (test_bb));
    5344                 :            :       /* ??? Can't merge blocks here, as then_bb is still in use.
    5345                 :            :          At minimum, the merge will get done just before bb-reorder.  */
    5346                 :            :     }
    5347                 :            : 
    5348                 :            :   return TRUE;
    5349                 :            : 
    5350                 :      66679 :  cancel:
    5351                 :      66679 :   cancel_changes (0);
    5352                 :            : 
    5353                 :      66679 :   if (merge_set)
    5354                 :          0 :     BITMAP_FREE (merge_set);
    5355                 :            : 
    5356                 :            :   return FALSE;
    5357                 :            : }
    5358                 :            : 
    5359                 :            : /* Main entry point for all if-conversion.  AFTER_COMBINE is true if
    5360                 :            :    we are after combine pass.  */
    5361                 :            : 
    5362                 :            : static void
    5363                 :    2059770 : if_convert (bool after_combine)
    5364                 :            : {
    5365                 :    2059770 :   basic_block bb;
    5366                 :    2059770 :   int pass;
    5367                 :            : 
    5368                 :    2059770 :   if (optimize == 1)
    5369                 :            :     {
    5370                 :     123699 :       df_live_add_problem ();
    5371                 :     123699 :       df_live_set_all_dirty ();
    5372                 :            :     }
    5373                 :            : 
    5374                 :            :   /* Record whether we are after combine pass.  */
    5375                 :    2059770 :   ifcvt_after_combine = after_combine;
    5376                 :    2059770 :   have_cbranchcc4 = (direct_optab_handler (cbranch_optab, CCmode)
    5377                 :    2059770 :                      != CODE_FOR_nothing);
    5378                 :    2059770 :   num_possible_if_blocks = 0;
    5379                 :    2059770 :   num_updated_if_blocks = 0;
    5380                 :    2059770 :   num_true_changes = 0;
    5381                 :            : 
    5382                 :    2059770 :   loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
    5383                 :    2059770 :   mark_loop_exit_edges ();
    5384                 :    2059770 :   loop_optimizer_finalize ();
    5385                 :    2059770 :   free_dominance_info (CDI_DOMINATORS);
    5386                 :            : 
    5387                 :            :   /* Compute postdominators.  */
    5388                 :    2059770 :   calculate_dominance_info (CDI_POST_DOMINATORS);
    5389                 :            : 
    5390                 :    2059770 :   df_set_flags (DF_LR_RUN_DCE);
    5391                 :            : 
    5392                 :            :   /* Go through each of the basic blocks looking for things to convert.  If we
    5393                 :            :      have conditional execution, we make multiple passes to allow us to handle
    5394                 :            :      IF-THEN{-ELSE} blocks within other IF-THEN{-ELSE} blocks.  */
    5395                 :    2059770 :   pass = 0;
    5396                 :    2193850 :   do
    5397                 :            :     {
    5398                 :    2193850 :       df_analyze ();
    5399                 :            :       /* Only need to do dce on the first pass.  */
    5400                 :    2193850 :       df_clear_flags (DF_LR_RUN_DCE);
    5401                 :    2193850 :       cond_exec_changed_p = FALSE;
    5402                 :    2193850 :       pass++;
    5403                 :            : 
    5404                 :            : #ifdef IFCVT_MULTIPLE_DUMPS
    5405                 :    2193850 :       if (dump_file && pass > 1)
    5406                 :         18 :         fprintf (dump_file, "\n\n========== Pass %d ==========\n", pass);
    5407                 :            : #endif
    5408                 :            : 
    5409                 :   27078300 :       FOR_EACH_BB_FN (bb, cfun)
    5410                 :            :         {
    5411                 :   25105200 :           basic_block new_bb;
    5412                 :   25105200 :           while (!df_get_bb_dirty (bb)
    5413                 :   25105200 :                  && (new_bb = find_if_header (bb, pass)) != NULL)
    5414                 :            :             bb = new_bb;
    5415                 :            :         }
    5416                 :            : 
    5417                 :            : #ifdef IFCVT_MULTIPLE_DUMPS
    5418                 :    2193850 :       if (dump_file && cond_exec_changed_p)
    5419                 :         18 :         print_rtl_with_bb (dump_file, get_insns (), dump_flags);
    5420                 :            : #endif
    5421                 :            :     }
    5422                 :    2193850 :   while (cond_exec_changed_p);
    5423                 :            : 
    5424                 :            : #ifdef IFCVT_MULTIPLE_DUMPS
    5425                 :    2059770 :   if (dump_file)
    5426                 :         86 :     fprintf (dump_file, "\n\n========== no more changes\n");
    5427                 :            : #endif
    5428                 :            : 
    5429                 :    2059770 :   free_dominance_info (CDI_POST_DOMINATORS);
    5430                 :            : 
    5431                 :    2059770 :   if (dump_file)
    5432                 :         86 :     fflush (dump_file);
    5433                 :            : 
    5434                 :    2059770 :   clear_aux_for_blocks ();
    5435                 :            : 
    5436                 :            :   /* If we allocated new pseudos, we must resize the array for sched1.  */
    5437                 :    2059770 :   if (max_regno < max_reg_num ())
    5438                 :     466421 :     max_regno = max_reg_num ();
    5439                 :            : 
    5440                 :            :   /* Write the final stats.  */
    5441                 :    2059770 :   if (dump_file && num_possible_if_blocks > 0)
    5442                 :            :     {
    5443                 :         58 :       fprintf (dump_file,
    5444                 :            :                "\n%d possible IF blocks searched.\n",
    5445                 :            :                num_possible_if_blocks);
    5446                 :         58 :       fprintf (dump_file,
    5447                 :            :                "%d IF blocks converted.\n",
    5448                 :            :                num_updated_if_blocks);
    5449                 :         58 :       fprintf (dump_file,
    5450                 :            :                "%d true changes made.\n\n\n",
    5451                 :            :                num_true_changes);
    5452                 :            :     }
    5453                 :            : 
    5454                 :    2059770 :   if (optimize == 1)
    5455                 :     123699 :     df_remove_problem (df_live);
    5456                 :            : 
    5457                 :            :   /* Some non-cold blocks may now be only reachable from cold blocks.
    5458                 :            :      Fix that up.  */
    5459                 :    2059770 :   fixup_partitions ();
    5460                 :            : 
    5461                 :    2059770 :   checking_verify_flow_info ();
    5462                 :    2059770 : }
    5463                 :            : 
    5464                 :            : /* If-conversion and CFG cleanup.  */
    5465                 :            : static unsigned int
    5466                 :     688548 : rest_of_handle_if_conversion (void)
    5467                 :            : {
    5468                 :     688548 :   int flags = 0;
    5469                 :            : 
    5470                 :     688548 :   if (flag_if_conversion)
    5471                 :            :     {
    5472                 :     686585 :       if (dump_file)
    5473                 :            :         {
    5474                 :         34 :           dump_reg_info (dump_file);
    5475                 :         34 :           dump_flow_info (dump_file, dump_flags);
    5476                 :            :         }
    5477                 :     686585 :       cleanup_cfg (CLEANUP_EXPENSIVE);
    5478                 :     686585 :       if_convert (false);
    5479                 :     686585 :       if (num_updated_if_blocks)
    5480                 :            :         /* Get rid of any dead CC-related instructions.  */
    5481                 :      85102 :         flags |= CLEANUP_FORCE_FAST_DCE;
    5482                 :            :     }
    5483                 :            : 
    5484                 :     688548 :   cleanup_cfg (flags);
    5485                 :     688548 :   return 0;
    5486                 :            : }
    5487                 :            : 
    5488                 :            : namespace {
    5489                 :            : 
    5490                 :            : const pass_data pass_data_rtl_ifcvt =
    5491                 :            : {
    5492                 :            :   RTL_PASS, /* type */
    5493                 :            :   "ce1", /* name */
    5494                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    5495                 :            :   TV_IFCVT, /* tv_id */
    5496                 :            :   0, /* properties_required */
    5497                 :            :   0, /* properties_provided */
    5498                 :            :   0, /* properties_destroyed */
    5499                 :            :   0, /* todo_flags_start */
    5500                 :            :   TODO_df_finish, /* todo_flags_finish */
    5501                 :            : };
    5502                 :            : 
    5503                 :            : class pass_rtl_ifcvt : public rtl_opt_pass
    5504                 :            : {
    5505                 :            : public:
    5506                 :     200773 :   pass_rtl_ifcvt (gcc::context *ctxt)
    5507                 :     401546 :     : rtl_opt_pass (pass_data_rtl_ifcvt, ctxt)
    5508                 :            :   {}
    5509                 :            : 
    5510                 :            :   /* opt_pass methods: */
    5511                 :     944101 :   virtual bool gate (function *)
    5512                 :            :     {
    5513                 :     944101 :       return (optimize > 0) && dbg_cnt (if_conversion);
    5514                 :            :     }
    5515                 :            : 
    5516                 :     688548 :   virtual unsigned int execute (function *)
    5517                 :            :     {
    5518                 :     688548 :       return rest_of_handle_if_conversion ();
    5519                 :            :     }
    5520                 :            : 
    5521                 :            : }; // class pass_rtl_ifcvt
    5522                 :            : 
    5523                 :            : } // anon namespace
    5524                 :            : 
    5525                 :            : rtl_opt_pass *
    5526                 :     200773 : make_pass_rtl_ifcvt (gcc::context *ctxt)
    5527                 :            : {
    5528                 :     200773 :   return new pass_rtl_ifcvt (ctxt);
    5529                 :            : }
    5530                 :            : 
    5531                 :            : 
    5532                 :            : /* Rerun if-conversion, as combine may have simplified things enough
    5533                 :            :    to now meet sequence length restrictions.  */
    5534                 :            : 
    5535                 :            : namespace {
    5536                 :            : 
    5537                 :            : const pass_data pass_data_if_after_combine =
    5538                 :            : {
    5539                 :            :   RTL_PASS, /* type */
    5540                 :            :   "ce2", /* name */
    5541                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    5542                 :            :   TV_IFCVT, /* tv_id */
    5543                 :            :   0, /* properties_required */
    5544                 :            :   0, /* properties_provided */
    5545                 :            :   0, /* properties_destroyed */
    5546                 :            :   0, /* todo_flags_start */
    5547                 :            :   TODO_df_finish, /* todo_flags_finish */
    5548                 :            : };
    5549                 :            : 
    5550                 :            : class pass_if_after_combine : public rtl_opt_pass
    5551                 :            : {
    5552                 :            : public:
    5553                 :     200773 :   pass_if_after_combine (gcc::context *ctxt)
    5554                 :     401546 :     : rtl_opt_pass (pass_data_if_after_combine, ctxt)
    5555                 :            :   {}
    5556                 :            : 
    5557                 :            :   /* opt_pass methods: */
    5558                 :     944101 :   virtual bool gate (function *)
    5559                 :            :     {
    5560                 :     688549 :       return optimize > 0 && flag_if_conversion
    5561                 :    1630690 :         && dbg_cnt (if_after_combine);
    5562                 :            :     }
    5563                 :            : 
    5564                 :     686585 :   virtual unsigned int execute (function *)
    5565                 :            :     {
    5566                 :     686585 :       if_convert (true);
    5567                 :     686585 :       return 0;
    5568                 :            :     }
    5569                 :            : 
    5570                 :            : }; // class pass_if_after_combine
    5571                 :            : 
    5572                 :            : } // anon namespace
    5573                 :            : 
    5574                 :            : rtl_opt_pass *
    5575                 :     200773 : make_pass_if_after_combine (gcc::context *ctxt)
    5576                 :            : {
    5577                 :     200773 :   return new pass_if_after_combine (ctxt);
    5578                 :            : }
    5579                 :            : 
    5580                 :            : 
    5581                 :            : namespace {
    5582                 :            : 
    5583                 :            : const pass_data pass_data_if_after_reload =
    5584                 :            : {
    5585                 :            :   RTL_PASS, /* type */
    5586                 :            :   "ce3", /* name */
    5587                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    5588                 :            :   TV_IFCVT2, /* tv_id */
    5589                 :            :   0, /* properties_required */
    5590                 :            :   0, /* properties_provided */
    5591                 :            :   0, /* properties_destroyed */
    5592                 :            :   0, /* todo_flags_start */
    5593                 :            :   TODO_df_finish, /* todo_flags_finish */
    5594                 :            : };
    5595                 :            : 
    5596                 :            : class pass_if_after_reload : public rtl_opt_pass
    5597                 :            : {
    5598                 :            : public:
    5599                 :     200773 :   pass_if_after_reload (gcc::context *ctxt)
    5600                 :     401546 :     : rtl_opt_pass (pass_data_if_after_reload, ctxt)
    5601                 :            :   {}
    5602                 :            : 
    5603                 :            :   /* opt_pass methods: */
    5604                 :     944101 :   virtual bool gate (function *)
    5605                 :            :     {
    5606                 :     688549 :       return optimize > 0 && flag_if_conversion2
    5607                 :    1630700 :         && dbg_cnt (if_after_reload);
    5608                 :            :     }
    5609                 :            : 
    5610                 :     686599 :   virtual unsigned int execute (function *)
    5611                 :            :     {
    5612                 :     686599 :       if_convert (true);
    5613                 :     686599 :       return 0;
    5614                 :            :     }
    5615                 :            : 
    5616                 :            : }; // class pass_if_after_reload
    5617                 :            : 
    5618                 :            : } // anon namespace
    5619                 :            : 
    5620                 :            : rtl_opt_pass *
    5621                 :     200773 : make_pass_if_after_reload (gcc::context *ctxt)
    5622                 :            : {
    5623                 :     200773 :   return new pass_if_after_reload (ctxt);
    5624                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.