LCOV - code coverage report
Current view: top level - gcc - rtlanal.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2238 2645 84.6 %
Date: 2020-04-04 11:58:09 Functions: 133 156 85.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Analyze RTL for GNU compiler.
       2                 :            :    Copyright (C) 1987-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 under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "backend.h"
      25                 :            : #include "target.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "predict.h"
      29                 :            : #include "df.h"
      30                 :            : #include "memmodel.h"
      31                 :            : #include "tm_p.h"
      32                 :            : #include "insn-config.h"
      33                 :            : #include "regs.h"
      34                 :            : #include "emit-rtl.h"  /* FIXME: Can go away once crtl is moved to rtl.h.  */
      35                 :            : #include "recog.h"
      36                 :            : #include "addresses.h"
      37                 :            : #include "rtl-iter.h"
      38                 :            : #include "hard-reg-set.h"
      39                 :            : #include "function-abi.h"
      40                 :            : 
      41                 :            : /* Forward declarations */
      42                 :            : static void set_of_1 (rtx, const_rtx, void *);
      43                 :            : static bool covers_regno_p (const_rtx, unsigned int);
      44                 :            : static bool covers_regno_no_parallel_p (const_rtx, unsigned int);
      45                 :            : static int computed_jump_p_1 (const_rtx);
      46                 :            : static void parms_set (rtx, const_rtx, void *);
      47                 :            : 
      48                 :            : static unsigned HOST_WIDE_INT cached_nonzero_bits (const_rtx, scalar_int_mode,
      49                 :            :                                                    const_rtx, machine_mode,
      50                 :            :                                                    unsigned HOST_WIDE_INT);
      51                 :            : static unsigned HOST_WIDE_INT nonzero_bits1 (const_rtx, scalar_int_mode,
      52                 :            :                                              const_rtx, machine_mode,
      53                 :            :                                              unsigned HOST_WIDE_INT);
      54                 :            : static unsigned int cached_num_sign_bit_copies (const_rtx, scalar_int_mode,
      55                 :            :                                                 const_rtx, machine_mode,
      56                 :            :                                                 unsigned int);
      57                 :            : static unsigned int num_sign_bit_copies1 (const_rtx, scalar_int_mode,
      58                 :            :                                           const_rtx, machine_mode,
      59                 :            :                                           unsigned int);
      60                 :            : 
      61                 :            : rtx_subrtx_bound_info rtx_all_subrtx_bounds[NUM_RTX_CODE];
      62                 :            : rtx_subrtx_bound_info rtx_nonconst_subrtx_bounds[NUM_RTX_CODE];
      63                 :            : 
      64                 :            : /* Truncation narrows the mode from SOURCE mode to DESTINATION mode.
      65                 :            :    If TARGET_MODE_REP_EXTENDED (DESTINATION, DESTINATION_REP) is
      66                 :            :    SIGN_EXTEND then while narrowing we also have to enforce the
      67                 :            :    representation and sign-extend the value to mode DESTINATION_REP.
      68                 :            : 
      69                 :            :    If the value is already sign-extended to DESTINATION_REP mode we
      70                 :            :    can just switch to DESTINATION mode on it.  For each pair of
      71                 :            :    integral modes SOURCE and DESTINATION, when truncating from SOURCE
      72                 :            :    to DESTINATION, NUM_SIGN_BIT_COPIES_IN_REP[SOURCE][DESTINATION]
      73                 :            :    contains the number of high-order bits in SOURCE that have to be
      74                 :            :    copies of the sign-bit so that we can do this mode-switch to
      75                 :            :    DESTINATION.  */
      76                 :            : 
      77                 :            : static unsigned int
      78                 :            : num_sign_bit_copies_in_rep[MAX_MODE_INT + 1][MAX_MODE_INT + 1];
      79                 :            : 
      80                 :            : /* Store X into index I of ARRAY.  ARRAY is known to have at least I
      81                 :            :    elements.  Return the new base of ARRAY.  */
      82                 :            : 
      83                 :            : template <typename T>
      84                 :            : typename T::value_type *
      85                 :    4662146 : generic_subrtx_iterator <T>::add_single_to_queue (array_type &array,
      86                 :            :                                                   value_type *base,
      87                 :            :                                                   size_t i, value_type x)
      88                 :            : {
      89                 :    4662146 :   if (base == array.stack)
      90                 :            :     {
      91                 :    2565759 :       if (i < LOCAL_ELEMS)
      92                 :            :         {
      93                 :    2399136 :           base[i] = x;
      94                 :    2399136 :           return base;
      95                 :            :         }
      96                 :     166624 :       gcc_checking_assert (i == LOCAL_ELEMS);
      97                 :            :       /* A previous iteration might also have moved from the stack to the
      98                 :            :          heap, in which case the heap array will already be big enough.  */
      99                 :     166624 :       if (vec_safe_length (array.heap) <= i)
     100                 :     166624 :         vec_safe_grow (array.heap, i + 1);
     101                 :     166624 :       base = array.heap->address ();
     102                 :     166624 :       memcpy (base, array.stack, sizeof (array.stack));
     103                 :     166624 :       base[LOCAL_ELEMS] = x;
     104                 :     166624 :       return base;
     105                 :            :     }
     106                 :    2096378 :   unsigned int length = array.heap->length ();
     107                 :    2096378 :   if (length > i)
     108                 :            :     {
     109                 :     822238 :       gcc_checking_assert (base == array.heap->address ());
     110                 :     822238 :       base[i] = x;
     111                 :     822238 :       return base;
     112                 :            :     }
     113                 :            :   else
     114                 :            :     {
     115                 :    1274142 :       gcc_checking_assert (i == length);
     116                 :    1274142 :       vec_safe_push (array.heap, x);
     117                 :    1274142 :       return array.heap->address ();
     118                 :            :     }
     119                 :            : }
     120                 :            : 
     121                 :            : /* Add the subrtxes of X to worklist ARRAY, starting at END.  Return the
     122                 :            :    number of elements added to the worklist.  */
     123                 :            : 
     124                 :            : template <typename T>
     125                 :            : size_t
     126                 :  161249720 : generic_subrtx_iterator <T>::add_subrtxes_to_queue (array_type &array,
     127                 :            :                                                     value_type *base,
     128                 :            :                                                     size_t end, rtx_type x)
     129                 :            : {
     130                 :  161249720 :   enum rtx_code code = GET_CODE (x);
     131                 :  161249720 :   const char *format = GET_RTX_FORMAT (code);
     132                 :  161249720 :   size_t orig_end = end;
     133                 :  161249720 :   if (__builtin_expect (INSN_P (x), false))
     134                 :            :     {
     135                 :            :       /* Put the pattern at the top of the queue, since that's what
     136                 :            :          we're likely to want most.  It also allows for the SEQUENCE
     137                 :            :          code below.  */
     138                 :      21332 :       for (int i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; --i)
     139                 :      18793 :         if (format[i] == 'e')
     140                 :            :           {
     141                 :       5176 :             value_type subx = T::get_value (x->u.fld[i].rt_rtx);
     142                 :       5176 :             if (__builtin_expect (end < LOCAL_ELEMS, true))
     143                 :       5176 :               base[end++] = subx;
     144                 :            :             else
     145                 :          0 :               base = add_single_to_queue (array, base, end++, subx);
     146                 :            :           }
     147                 :            :     }
     148                 :            :   else
     149                 :  358954400 :     for (int i = 0; format[i]; ++i)
     150                 :  197708160 :       if (format[i] == 'e')
     151                 :            :         {
     152                 :     500760 :           value_type subx = T::get_value (x->u.fld[i].rt_rtx);
     153                 :     500760 :           if (__builtin_expect (end < LOCAL_ELEMS, true))
     154                 :         14 :             base[end++] = subx;
     155                 :            :           else
     156                 :     500746 :             base = add_single_to_queue (array, base, end++, subx);
     157                 :            :         }
     158                 :  197206620 :       else if (format[i] == 'E')
     159                 :            :         {
     160                 :  165590100 :           unsigned int length = GET_NUM_ELEM (x->u.fld[i].rt_rtvec);
     161                 :  165590100 :           rtx *vec = x->u.fld[i].rt_rtvec->elem;
     162                 :  165590100 :           if (__builtin_expect (end + length <= LOCAL_ELEMS, true))
     163                 :  497336700 :             for (unsigned int j = 0; j < length; j++)
     164                 :  331966410 :               base[end++] = T::get_value (vec[j]);
     165                 :            :           else
     166                 :    4381374 :             for (unsigned int j = 0; j < length; j++)
     167                 :    4161397 :               base = add_single_to_queue (array, base, end++,
     168                 :    4161397 :                                           T::get_value (vec[j]));
     169                 :  165590100 :           if (code == SEQUENCE && end == length)
     170                 :            :             /* If the subrtxes of the sequence fill the entire array then
     171                 :            :                we know that no other parts of a containing insn are queued.
     172                 :            :                The caller is therefore iterating over the sequence as a
     173                 :            :                PATTERN (...), so we also want the patterns of the
     174                 :            :                subinstructions.  */
     175                 :          0 :             for (unsigned int j = 0; j < length; j++)
     176                 :            :               {
     177                 :          0 :                 typename T::rtx_type x = T::get_rtx (base[j]);
     178                 :          0 :                 if (INSN_P (x))
     179                 :          0 :                   base[j] = T::get_value (PATTERN (x));
     180                 :            :               }
     181                 :            :         }
     182                 :  161249720 :   return end - orig_end;
     183                 :            : }
     184                 :            : 
     185                 :            : template <typename T>
     186                 :            : void
     187                 :     166624 : generic_subrtx_iterator <T>::free_array (array_type &array)
     188                 :            : {
     189                 :     166624 :   vec_free (array.heap);
     190                 :     166624 : }
     191                 :            : 
     192                 :            : template <typename T>
     193                 :            : const size_t generic_subrtx_iterator <T>::LOCAL_ELEMS;
     194                 :            : 
     195                 :            : template class generic_subrtx_iterator <const_rtx_accessor>;
     196                 :            : template class generic_subrtx_iterator <rtx_var_accessor>;
     197                 :            : template class generic_subrtx_iterator <rtx_ptr_accessor>;
     198                 :            : 
     199                 :            : /* Return 1 if the value of X is unstable
     200                 :            :    (would be different at a different point in the program).
     201                 :            :    The frame pointer, arg pointer, etc. are considered stable
     202                 :            :    (within one function) and so is anything marked `unchanging'.  */
     203                 :            : 
     204                 :            : int
     205                 :          0 : rtx_unstable_p (const_rtx x)
     206                 :            : {
     207                 :          0 :   const RTX_CODE code = GET_CODE (x);
     208                 :          0 :   int i;
     209                 :          0 :   const char *fmt;
     210                 :            : 
     211                 :          0 :   switch (code)
     212                 :            :     {
     213                 :          0 :     case MEM:
     214                 :          0 :       return !MEM_READONLY_P (x) || rtx_unstable_p (XEXP (x, 0));
     215                 :            : 
     216                 :            :     case CONST:
     217                 :            :     CASE_CONST_ANY:
     218                 :            :     case SYMBOL_REF:
     219                 :            :     case LABEL_REF:
     220                 :            :       return 0;
     221                 :            : 
     222                 :          0 :     case REG:
     223                 :            :       /* As in rtx_varies_p, we have to use the actual rtx, not reg number.  */
     224                 :          0 :       if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
     225                 :            :           /* The arg pointer varies if it is not a fixed register.  */
     226                 :          0 :           || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
     227                 :            :         return 0;
     228                 :            :       /* ??? When call-clobbered, the value is stable modulo the restore
     229                 :            :          that must happen after a call.  This currently screws up local-alloc
     230                 :            :          into believing that the restore is not needed.  */
     231                 :          0 :       if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED && x == pic_offset_table_rtx)
     232                 :          0 :         return 0;
     233                 :            :       return 1;
     234                 :            : 
     235                 :          0 :     case ASM_OPERANDS:
     236                 :          0 :       if (MEM_VOLATILE_P (x))
     237                 :            :         return 1;
     238                 :            : 
     239                 :            :       /* Fall through.  */
     240                 :            : 
     241                 :          0 :     default:
     242                 :          0 :       break;
     243                 :            :     }
     244                 :            : 
     245                 :          0 :   fmt = GET_RTX_FORMAT (code);
     246                 :          0 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     247                 :          0 :     if (fmt[i] == 'e')
     248                 :            :       {
     249                 :          0 :         if (rtx_unstable_p (XEXP (x, i)))
     250                 :            :           return 1;
     251                 :            :       }
     252                 :          0 :     else if (fmt[i] == 'E')
     253                 :            :       {
     254                 :            :         int j;
     255                 :          0 :         for (j = 0; j < XVECLEN (x, i); j++)
     256                 :          0 :           if (rtx_unstable_p (XVECEXP (x, i, j)))
     257                 :            :             return 1;
     258                 :            :       }
     259                 :            : 
     260                 :            :   return 0;
     261                 :            : }
     262                 :            : 
     263                 :            : /* Return 1 if X has a value that can vary even between two
     264                 :            :    executions of the program.  0 means X can be compared reliably
     265                 :            :    against certain constants or near-constants.
     266                 :            :    FOR_ALIAS is nonzero if we are called from alias analysis; if it is
     267                 :            :    zero, we are slightly more conservative.
     268                 :            :    The frame pointer and the arg pointer are considered constant.  */
     269                 :            : 
     270                 :            : bool
     271                 :  303169000 : rtx_varies_p (const_rtx x, bool for_alias)
     272                 :            : {
     273                 :  303169000 :   RTX_CODE code;
     274                 :  303169000 :   int i;
     275                 :  303169000 :   const char *fmt;
     276                 :            : 
     277                 :  303169000 :   if (!x)
     278                 :            :     return 0;
     279                 :            : 
     280                 :  303169000 :   code = GET_CODE (x);
     281                 :  303169000 :   switch (code)
     282                 :            :     {
     283                 :   56652000 :     case MEM:
     284                 :   56652000 :       return !MEM_READONLY_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
     285                 :            : 
     286                 :            :     case CONST:
     287                 :            :     CASE_CONST_ANY:
     288                 :            :     case SYMBOL_REF:
     289                 :            :     case LABEL_REF:
     290                 :            :       return 0;
     291                 :            : 
     292                 :  101209000 :     case REG:
     293                 :            :       /* Note that we have to test for the actual rtx used for the frame
     294                 :            :          and arg pointers and not just the register number in case we have
     295                 :            :          eliminated the frame and/or arg pointer and are using it
     296                 :            :          for pseudos.  */
     297                 :  101209000 :       if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
     298                 :            :           /* The arg pointer varies if it is not a fixed register.  */
     299                 :   88545100 :           || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
     300                 :            :         return 0;
     301                 :   88377500 :       if (x == pic_offset_table_rtx
     302                 :            :           /* ??? When call-clobbered, the value is stable modulo the restore
     303                 :            :              that must happen after a call.  This currently screws up
     304                 :            :              local-alloc into believing that the restore is not needed, so we
     305                 :            :              must return 0 only if we are called from alias analysis.  */
     306                 :            :           && (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED || for_alias))
     307                 :     784530 :         return 0;
     308                 :            :       return 1;
     309                 :            : 
     310                 :          0 :     case LO_SUM:
     311                 :            :       /* The operand 0 of a LO_SUM is considered constant
     312                 :            :          (in fact it is related specifically to operand 1)
     313                 :            :          during alias analysis.  */
     314                 :          0 :       return (! for_alias && rtx_varies_p (XEXP (x, 0), for_alias))
     315                 :          0 :              || rtx_varies_p (XEXP (x, 1), for_alias);
     316                 :            : 
     317                 :     225880 :     case ASM_OPERANDS:
     318                 :     225880 :       if (MEM_VOLATILE_P (x))
     319                 :            :         return 1;
     320                 :            : 
     321                 :            :       /* Fall through.  */
     322                 :            : 
     323                 :   82837900 :     default:
     324                 :   82837900 :       break;
     325                 :            :     }
     326                 :            : 
     327                 :   82837900 :   fmt = GET_RTX_FORMAT (code);
     328                 :  147817000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     329                 :  132577000 :     if (fmt[i] == 'e')
     330                 :            :       {
     331                 :  121651000 :         if (rtx_varies_p (XEXP (x, i), for_alias))
     332                 :            :           return 1;
     333                 :            :       }
     334                 :   10925700 :     else if (fmt[i] == 'E')
     335                 :            :       {
     336                 :            :         int j;
     337                 :   12069800 :         for (j = 0; j < XVECLEN (x, i); j++)
     338                 :    9532010 :           if (rtx_varies_p (XVECEXP (x, i, j), for_alias))
     339                 :            :             return 1;
     340                 :            :       }
     341                 :            : 
     342                 :            :   return 0;
     343                 :            : }
     344                 :            : 
     345                 :            : /* Compute an approximation for the offset between the register
     346                 :            :    FROM and TO for the current function, as it was at the start
     347                 :            :    of the routine.  */
     348                 :            : 
     349                 :            : static poly_int64
     350                 :  199299000 : get_initial_register_offset (int from, int to)
     351                 :            : {
     352                 :  199299000 :   static const struct elim_table_t
     353                 :            :   {
     354                 :            :     const int from;
     355                 :            :     const int to;
     356                 :            :   } table[] = ELIMINABLE_REGS;
     357                 :  199299000 :   poly_int64 offset1, offset2;
     358                 :  199299000 :   unsigned int i, j;
     359                 :            : 
     360                 :  199299000 :   if (to == from)
     361                 :          0 :     return 0;
     362                 :            : 
     363                 :            :   /* It is not safe to call INITIAL_ELIMINATION_OFFSET before the epilogue
     364                 :            :      is completed, but we need to give at least an estimate for the stack
     365                 :            :      pointer based on the frame size.  */
     366                 :  199299000 :   if (!epilogue_completed)
     367                 :            :     {
     368                 :  110290000 :       offset1 = crtl->outgoing_args_size + get_frame_size ();
     369                 :            : #if !STACK_GROWS_DOWNWARD
     370                 :            :       offset1 = - offset1;
     371                 :            : #endif
     372                 :  110290000 :       if (to == STACK_POINTER_REGNUM)
     373                 :  109957000 :         return offset1;
     374                 :     333716 :       else if (from == STACK_POINTER_REGNUM)
     375                 :  199299000 :         return - offset1;
     376                 :            :       else
     377                 :     166858 :         return 0;
     378                 :            :      }
     379                 :            : 
     380                 :   89865500 :   for (i = 0; i < ARRAY_SIZE (table); i++)
     381                 :   89865500 :       if (table[i].from == from)
     382                 :            :         {
     383                 :   89009200 :           if (table[i].to == to)
     384                 :            :             {
     385                 :   88153000 :               INITIAL_ELIMINATION_OFFSET (table[i].from, table[i].to,
     386                 :            :                                           offset1);
     387                 :   88153000 :               return offset1;
     388                 :            :             }
     389                 :    4281120 :           for (j = 0; j < ARRAY_SIZE (table); j++)
     390                 :            :             {
     391                 :    3424900 :               if (table[j].to == to
     392                 :    1712450 :                   && table[j].from == table[i].to)
     393                 :            :                 {
     394                 :          0 :                   INITIAL_ELIMINATION_OFFSET (table[i].from, table[i].to,
     395                 :            :                                               offset1);
     396                 :          0 :                   INITIAL_ELIMINATION_OFFSET (table[j].from, table[j].to,
     397                 :            :                                               offset2);
     398                 :          0 :                   return offset1 + offset2;
     399                 :            :                 }
     400                 :    3424900 :               if (table[j].from == to
     401                 :          0 :                   && table[j].to == table[i].to)
     402                 :            :                 {
     403                 :          0 :                   INITIAL_ELIMINATION_OFFSET (table[i].from, table[i].to,
     404                 :            :                                               offset1);
     405                 :          0 :                   INITIAL_ELIMINATION_OFFSET (table[j].from, table[j].to,
     406                 :            :                                               offset2);
     407                 :          0 :                   return offset1 - offset2;
     408                 :            :                 }
     409                 :            :             }
     410                 :            :         }
     411                 :     856225 :       else if (table[i].to == from)
     412                 :            :         {
     413                 :     856225 :           if (table[i].from == to)
     414                 :            :             {
     415                 :          0 :               INITIAL_ELIMINATION_OFFSET (table[i].from, table[i].to,
     416                 :            :                                           offset1);
     417                 :          0 :               return - offset1;
     418                 :            :             }
     419                 :    1712450 :           for (j = 0; j < ARRAY_SIZE (table); j++)
     420                 :            :             {
     421                 :    1712450 :               if (table[j].to == to
     422                 :     856225 :                   && table[j].from == table[i].from)
     423                 :            :                 {
     424                 :     856225 :                   INITIAL_ELIMINATION_OFFSET (table[i].from, table[i].to,
     425                 :            :                                               offset1);
     426                 :     856225 :                   INITIAL_ELIMINATION_OFFSET (table[j].from, table[j].to,
     427                 :            :                                               offset2);
     428                 :     856225 :                   return - offset1 + offset2;
     429                 :            :                 }
     430                 :     856225 :               if (table[j].from == to
     431                 :          0 :                   && table[j].to == table[i].from)
     432                 :            :                 {
     433                 :          0 :                   INITIAL_ELIMINATION_OFFSET (table[i].from, table[i].to,
     434                 :            :                                               offset1);
     435                 :          0 :                   INITIAL_ELIMINATION_OFFSET (table[j].from, table[j].to,
     436                 :            :                                               offset2);
     437                 :          0 :                   return - offset1 - offset2;
     438                 :            :                 }
     439                 :            :             }
     440                 :            :         }
     441                 :            : 
     442                 :            :   /* If the requested register combination was not found,
     443                 :            :      try a different more simple combination.  */
     444                 :          0 :   if (from == ARG_POINTER_REGNUM)
     445                 :            :     return get_initial_register_offset (HARD_FRAME_POINTER_REGNUM, to);
     446                 :          0 :   else if (to == ARG_POINTER_REGNUM)
     447                 :            :     return get_initial_register_offset (from, HARD_FRAME_POINTER_REGNUM);
     448                 :          0 :   else if (from == HARD_FRAME_POINTER_REGNUM)
     449                 :            :     return get_initial_register_offset (FRAME_POINTER_REGNUM, to);
     450                 :          0 :   else if (to == HARD_FRAME_POINTER_REGNUM)
     451                 :            :     return get_initial_register_offset (from, FRAME_POINTER_REGNUM);
     452                 :            :   else
     453                 :          0 :     return 0;
     454                 :            : }
     455                 :            : 
     456                 :            : /* Return nonzero if the use of X+OFFSET as an address in a MEM with SIZE
     457                 :            :    bytes can cause a trap.  MODE is the mode of the MEM (not that of X) and
     458                 :            :    UNALIGNED_MEMS controls whether nonzero is returned for unaligned memory
     459                 :            :    references on strict alignment machines.  */
     460                 :            : 
     461                 :            : static int
     462                 :  613287000 : rtx_addr_can_trap_p_1 (const_rtx x, poly_int64 offset, poly_int64 size,
     463                 :            :                        machine_mode mode, bool unaligned_mems)
     464                 :            : {
     465                 :  613287000 :   enum rtx_code code = GET_CODE (x);
     466                 :  613287000 :   gcc_checking_assert (mode == BLKmode || known_size_p (size));
     467                 :  613287000 :   poly_int64 const_x1;
     468                 :            : 
     469                 :            :   /* The offset must be a multiple of the mode size if we are considering
     470                 :            :      unaligned memory references on strict alignment machines.  */
     471                 :  613287000 :   if (STRICT_ALIGNMENT && unaligned_mems && mode != BLKmode)
     472                 :            :     {
     473                 :            :       poly_int64 actual_offset = offset;
     474                 :            : 
     475                 :            : #ifdef SPARC_STACK_BOUNDARY_HACK
     476                 :            :       /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
     477                 :            :              the real alignment of %sp.  However, when it does this, the
     478                 :            :              alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY.  */
     479                 :            :       if (SPARC_STACK_BOUNDARY_HACK
     480                 :            :           && (x == stack_pointer_rtx || x == hard_frame_pointer_rtx))
     481                 :            :         actual_offset -= STACK_POINTER_OFFSET;
     482                 :            : #endif
     483                 :            : 
     484                 :            :       if (!multiple_p (actual_offset, GET_MODE_SIZE (mode)))
     485                 :            :         return 1;
     486                 :            :     }
     487                 :            : 
     488                 :  613287000 :   switch (code)
     489                 :            :     {
     490                 :    5810760 :     case SYMBOL_REF:
     491                 :    5810760 :       if (SYMBOL_REF_WEAK (x))
     492                 :            :         return 1;
     493                 :    5578560 :       if (!CONSTANT_POOL_ADDRESS_P (x) && !SYMBOL_REF_FUNCTION_P (x))
     494                 :            :         {
     495                 :     503206 :           tree decl;
     496                 :     503206 :           poly_int64 decl_size;
     497                 :            : 
     498                 :     503206 :           if (maybe_lt (offset, 0))
     499                 :            :             return 1;
     500                 :     502625 :           if (!known_size_p (size))
     501                 :        406 :             return maybe_ne (offset, 0);
     502                 :            : 
     503                 :            :           /* If the size of the access or of the symbol is unknown,
     504                 :            :              assume the worst.  */
     505                 :     502219 :           decl = SYMBOL_REF_DECL (x);
     506                 :            : 
     507                 :            :           /* Else check that the access is in bounds.  TODO: restructure
     508                 :            :              expr_size/tree_expr_size/int_expr_size and just use the latter.  */
     509                 :     502219 :           if (!decl)
     510                 :     166055 :             decl_size = -1;
     511                 :     672328 :           else if (DECL_P (decl) && DECL_SIZE_UNIT (decl))
     512                 :            :             {
     513                 :     331267 :               if (!poly_int_tree_p (DECL_SIZE_UNIT (decl), &decl_size))
     514                 :          0 :                 decl_size = -1;
     515                 :            :             }
     516                 :       4897 :           else if (TREE_CODE (decl) == STRING_CST)
     517                 :          0 :             decl_size = TREE_STRING_LENGTH (decl);
     518                 :       4897 :           else if (TYPE_SIZE_UNIT (TREE_TYPE (decl)))
     519                 :          0 :             decl_size = int_size_in_bytes (TREE_TYPE (decl));
     520                 :            :           else
     521                 :       4897 :             decl_size = -1;
     522                 :            : 
     523                 :     502219 :           return (!known_size_p (decl_size) || known_eq (decl_size, 0)
     524                 :     502498 :                   ? maybe_ne (offset, 0)
     525                 :     661976 :                   : !known_subrange_p (offset, size, 0, decl_size));
     526                 :            :         }
     527                 :            : 
     528                 :            :       return 0;
     529                 :            : 
     530                 :            :     case LABEL_REF:
     531                 :            :       return 0;
     532                 :            : 
     533                 :  302266000 :     case REG:
     534                 :            :       /* Stack references are assumed not to trap, but we need to deal with
     535                 :            :          nonsensical offsets.  */
     536                 :  302266000 :       if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
     537                 :  295592000 :          || x == stack_pointer_rtx
     538                 :            :          /* The arg pointer varies if it is not a fixed register.  */
     539                 :   98336300 :          || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
     540                 :            :         {
     541                 :            : #ifdef RED_ZONE_SIZE
     542                 :  204014000 :           poly_int64 red_zone_size = RED_ZONE_SIZE;
     543                 :            : #else
     544                 :            :           poly_int64 red_zone_size = 0;
     545                 :            : #endif
     546                 :  204014000 :           poly_int64 stack_boundary = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
     547                 :  204014000 :           poly_int64 low_bound, high_bound;
     548                 :            : 
     549                 :  204014000 :           if (!known_size_p (size))
     550                 :            :             return 1;
     551                 :            : 
     552                 :  204011000 :           if (x == frame_pointer_rtx)
     553                 :            :             {
     554                 :    5650420 :               if (FRAME_GROWS_DOWNWARD)
     555                 :            :                 {
     556                 :    5650420 :                   high_bound = targetm.starting_frame_offset ();
     557                 :    5650420 :                   low_bound  = high_bound - get_frame_size ();
     558                 :            :                 }
     559                 :            :               else
     560                 :            :                 {
     561                 :            :                   low_bound  = targetm.starting_frame_offset ();
     562                 :            :                   high_bound = low_bound + get_frame_size ();
     563                 :            :                 }
     564                 :            :             }
     565                 :  198360000 :           else if (x == hard_frame_pointer_rtx)
     566                 :            :             {
     567                 :    1023080 :               poly_int64 sp_offset
     568                 :            :                 = get_initial_register_offset (STACK_POINTER_REGNUM,
     569                 :    1023080 :                                                HARD_FRAME_POINTER_REGNUM);
     570                 :    1023080 :               poly_int64 ap_offset
     571                 :            :                 = get_initial_register_offset (ARG_POINTER_REGNUM,
     572                 :    1023080 :                                                HARD_FRAME_POINTER_REGNUM);
     573                 :            : 
     574                 :            : #if STACK_GROWS_DOWNWARD
     575                 :    1023080 :               low_bound  = sp_offset - red_zone_size - stack_boundary;
     576                 :    1023080 :               high_bound = ap_offset
     577                 :    1023080 :                            + FIRST_PARM_OFFSET (current_function_decl)
     578                 :            : #if !ARGS_GROW_DOWNWARD
     579                 :    1023080 :                            + crtl->args.size
     580                 :            : #endif
     581                 :    1023080 :                            + stack_boundary;
     582                 :            : #else
     583                 :            :               high_bound = sp_offset + red_zone_size + stack_boundary;
     584                 :            :               low_bound  = ap_offset
     585                 :            :                            + FIRST_PARM_OFFSET (current_function_decl)
     586                 :            : #if ARGS_GROW_DOWNWARD
     587                 :            :                            - crtl->args.size
     588                 :            : #endif
     589                 :            :                            - stack_boundary;
     590                 :            : #endif
     591                 :            :             }
     592                 :  197337000 :           else if (x == stack_pointer_rtx)
     593                 :            :             {
     594                 :  197253000 :               poly_int64 ap_offset
     595                 :            :                 = get_initial_register_offset (ARG_POINTER_REGNUM,
     596                 :  197253000 :                                                STACK_POINTER_REGNUM);
     597                 :            : 
     598                 :            : #if STACK_GROWS_DOWNWARD
     599                 :  197253000 :               low_bound  = - red_zone_size - stack_boundary;
     600                 :  197253000 :               high_bound = ap_offset
     601                 :  197253000 :                            + FIRST_PARM_OFFSET (current_function_decl)
     602                 :            : #if !ARGS_GROW_DOWNWARD
     603                 :  197253000 :                            + crtl->args.size
     604                 :            : #endif
     605                 :  197253000 :                            + stack_boundary;
     606                 :            : #else
     607                 :            :               high_bound = red_zone_size + stack_boundary;
     608                 :            :               low_bound  = ap_offset
     609                 :            :                            + FIRST_PARM_OFFSET (current_function_decl)
     610                 :            : #if ARGS_GROW_DOWNWARD
     611                 :            :                            - crtl->args.size
     612                 :            : #endif
     613                 :            :                            - stack_boundary;
     614                 :            : #endif
     615                 :            :             }
     616                 :            :           else
     617                 :            :             {
     618                 :            :               /* We assume that accesses are safe to at least the
     619                 :            :                  next stack boundary.
     620                 :            :                  Examples are varargs and __builtin_return_address.  */
     621                 :            : #if ARGS_GROW_DOWNWARD
     622                 :            :               high_bound = FIRST_PARM_OFFSET (current_function_decl)
     623                 :            :                            + stack_boundary;
     624                 :            :               low_bound  = FIRST_PARM_OFFSET (current_function_decl)
     625                 :            :                            - crtl->args.size - stack_boundary;
     626                 :            : #else
     627                 :      83844 :               low_bound  = FIRST_PARM_OFFSET (current_function_decl)
     628                 :      83844 :                            - stack_boundary;
     629                 :      83844 :               high_bound = FIRST_PARM_OFFSET (current_function_decl)
     630                 :      83844 :                            + crtl->args.size + stack_boundary;
     631                 :            : #endif
     632                 :            :             }
     633                 :            : 
     634                 :  204011000 :           if (known_ge (offset, low_bound)
     635                 :  204011000 :               && known_le (offset, high_bound - size))
     636                 :  203813000 :             return 0;
     637                 :            :           return 1;
     638                 :            :         }
     639                 :            :       /* All of the virtual frame registers are stack references.  */
     640                 :   98252400 :       if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
     641                 :   98252400 :           && REGNO (x) <= LAST_VIRTUAL_REGISTER)
     642                 :     254765 :         return 0;
     643                 :            :       return 1;
     644                 :            : 
     645                 :     195916 :     case CONST:
     646                 :     195916 :       return rtx_addr_can_trap_p_1 (XEXP (x, 0), offset, size,
     647                 :     195916 :                                     mode, unaligned_mems);
     648                 :            : 
     649                 :   96185400 :     case PLUS:
     650                 :            :       /* An address is assumed not to trap if:
     651                 :            :          - it is the pic register plus a const unspec without offset.  */
     652                 :   96185400 :       if (XEXP (x, 0) == pic_offset_table_rtx
     653                 :      36976 :           && GET_CODE (XEXP (x, 1)) == CONST
     654                 :      36926 :           && GET_CODE (XEXP (XEXP (x, 1), 0)) == UNSPEC
     655                 :   96218800 :           && known_eq (offset, 0))
     656                 :            :         return 0;
     657                 :            : 
     658                 :            :       /* - or it is an address that can't trap plus a constant integer.  */
     659                 :   96151900 :       if (poly_int_rtx_p (XEXP (x, 1), &const_x1)
     660                 :   84707100 :           && !rtx_addr_can_trap_p_1 (XEXP (x, 0), offset + const_x1,
     661                 :            :                                      size, mode, unaligned_mems))
     662                 :   11782900 :         return 0;
     663                 :            : 
     664                 :            :       return 1;
     665                 :            : 
     666                 :    1754460 :     case LO_SUM:
     667                 :    1754460 :     case PRE_MODIFY:
     668                 :    1754460 :       return rtx_addr_can_trap_p_1 (XEXP (x, 1), offset, size,
     669                 :    1754460 :                                     mode, unaligned_mems);
     670                 :            : 
     671                 :  191011000 :     case PRE_DEC:
     672                 :  191011000 :     case PRE_INC:
     673                 :  191011000 :     case POST_DEC:
     674                 :  191011000 :     case POST_INC:
     675                 :  191011000 :     case POST_MODIFY:
     676                 :  191011000 :       return rtx_addr_can_trap_p_1 (XEXP (x, 0), offset, size,
     677                 :  191011000 :                                     mode, unaligned_mems);
     678                 :            : 
     679                 :   16063200 :     default:
     680                 :   16063200 :       break;
     681                 :            :     }
     682                 :            : 
     683                 :            :   /* If it isn't one of the case above, it can cause a trap.  */
     684                 :   16063200 :   return 1;
     685                 :            : }
     686                 :            : 
     687                 :            : /* Return nonzero if the use of X as an address in a MEM can cause a trap.  */
     688                 :            : 
     689                 :            : int
     690                 :    9584100 : rtx_addr_can_trap_p (const_rtx x)
     691                 :            : {
     692                 :    9584100 :   return rtx_addr_can_trap_p_1 (x, 0, -1, BLKmode, false);
     693                 :            : }
     694                 :            : 
     695                 :            : /* Return true if X contains a MEM subrtx.  */
     696                 :            : 
     697                 :            : bool
     698                 :    1036540 : contains_mem_rtx_p (rtx x)
     699                 :            : {
     700                 :    1036540 :   subrtx_iterator::array_type array;
     701                 :    2544290 :   FOR_EACH_SUBRTX (iter, array, x, ALL)
     702                 :    1762260 :     if (MEM_P (*iter))
     703                 :     254509 :       return true;
     704                 :            : 
     705                 :     782035 :   return false;
     706                 :            : }
     707                 :            : 
     708                 :            : /* Return true if X is an address that is known to not be zero.  */
     709                 :            : 
     710                 :            : bool
     711                 :   29952700 : nonzero_address_p (const_rtx x)
     712                 :            : {
     713                 :   29955000 :   const enum rtx_code code = GET_CODE (x);
     714                 :            : 
     715                 :   29955000 :   switch (code)
     716                 :            :     {
     717                 :     144044 :     case SYMBOL_REF:
     718                 :     144044 :       return flag_delete_null_pointer_checks && !SYMBOL_REF_WEAK (x);
     719                 :            : 
     720                 :            :     case LABEL_REF:
     721                 :            :       return true;
     722                 :            : 
     723                 :   14547800 :     case REG:
     724                 :            :       /* As in rtx_varies_p, we have to use the actual rtx, not reg number.  */
     725                 :   14547800 :       if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
     726                 :   14547800 :           || x == stack_pointer_rtx
     727                 :   14547800 :           || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
     728                 :            :         return true;
     729                 :            :       /* All of the virtual frame registers are stack references.  */
     730                 :   14547800 :       if (REGNO (x) >= FIRST_VIRTUAL_REGISTER
     731                 :   14547800 :           && REGNO (x) <= LAST_VIRTUAL_REGISTER)
     732                 :          0 :         return true;
     733                 :            :       return false;
     734                 :            : 
     735                 :       2247 :     case CONST:
     736                 :       2247 :       return nonzero_address_p (XEXP (x, 0));
     737                 :            : 
     738                 :    5590840 :     case PLUS:
     739                 :            :       /* Handle PIC references.  */
     740                 :    5590840 :       if (XEXP (x, 0) == pic_offset_table_rtx
     741                 :          0 :                && CONSTANT_P (XEXP (x, 1)))
     742                 :          0 :         return true;
     743                 :            :       return false;
     744                 :            : 
     745                 :          0 :     case PRE_MODIFY:
     746                 :            :       /* Similar to the above; allow positive offsets.  Further, since
     747                 :            :          auto-inc is only allowed in memories, the register must be a
     748                 :            :          pointer.  */
     749                 :          0 :       if (CONST_INT_P (XEXP (x, 1))
     750                 :          0 :           && INTVAL (XEXP (x, 1)) > 0)
     751                 :            :         return true;
     752                 :          0 :       return nonzero_address_p (XEXP (x, 0));
     753                 :            : 
     754                 :            :     case PRE_INC:
     755                 :            :       /* Similarly.  Further, the offset is always positive.  */
     756                 :            :       return true;
     757                 :            : 
     758                 :          0 :     case PRE_DEC:
     759                 :          0 :     case POST_DEC:
     760                 :          0 :     case POST_INC:
     761                 :          0 :     case POST_MODIFY:
     762                 :          0 :       return nonzero_address_p (XEXP (x, 0));
     763                 :            : 
     764                 :          0 :     case LO_SUM:
     765                 :          0 :       return nonzero_address_p (XEXP (x, 1));
     766                 :            : 
     767                 :    9670050 :     default:
     768                 :    9670050 :       break;
     769                 :            :     }
     770                 :            : 
     771                 :            :   /* If it isn't one of the case above, might be zero.  */
     772                 :    9670050 :   return false;
     773                 :            : }
     774                 :            : 
     775                 :            : /* Return 1 if X refers to a memory location whose address
     776                 :            :    cannot be compared reliably with constant addresses,
     777                 :            :    or if X refers to a BLKmode memory object.
     778                 :            :    FOR_ALIAS is nonzero if we are called from alias analysis; if it is
     779                 :            :    zero, we are slightly more conservative.  */
     780                 :            : 
     781                 :            : bool
     782                 :          0 : rtx_addr_varies_p (const_rtx x, bool for_alias)
     783                 :            : {
     784                 :          0 :   enum rtx_code code;
     785                 :          0 :   int i;
     786                 :          0 :   const char *fmt;
     787                 :            : 
     788                 :          0 :   if (x == 0)
     789                 :            :     return 0;
     790                 :            : 
     791                 :          0 :   code = GET_CODE (x);
     792                 :          0 :   if (code == MEM)
     793                 :          0 :     return GET_MODE (x) == BLKmode || rtx_varies_p (XEXP (x, 0), for_alias);
     794                 :            : 
     795                 :          0 :   fmt = GET_RTX_FORMAT (code);
     796                 :          0 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     797                 :          0 :     if (fmt[i] == 'e')
     798                 :            :       {
     799                 :          0 :         if (rtx_addr_varies_p (XEXP (x, i), for_alias))
     800                 :            :           return 1;
     801                 :            :       }
     802                 :          0 :     else if (fmt[i] == 'E')
     803                 :            :       {
     804                 :            :         int j;
     805                 :          0 :         for (j = 0; j < XVECLEN (x, i); j++)
     806                 :          0 :           if (rtx_addr_varies_p (XVECEXP (x, i, j), for_alias))
     807                 :            :             return 1;
     808                 :            :       }
     809                 :            :   return 0;
     810                 :            : }
     811                 :            : 
     812                 :            : /* Return the CALL in X if there is one.  */
     813                 :            : 
     814                 :            : rtx
     815                 :   20122700 : get_call_rtx_from (const rtx_insn *insn)
     816                 :            : {
     817                 :   20122700 :   rtx x = PATTERN (insn);
     818                 :   20122700 :   if (GET_CODE (x) == PARALLEL)
     819                 :    1124890 :     x = XVECEXP (x, 0, 0);
     820                 :   20122700 :   if (GET_CODE (x) == SET)
     821                 :    7181850 :     x = SET_SRC (x);
     822                 :   20122700 :   if (GET_CODE (x) == CALL && MEM_P (XEXP (x, 0)))
     823                 :   20122700 :     return x;
     824                 :            :   return NULL_RTX;
     825                 :            : }
     826                 :            : 
     827                 :            : /* Get the declaration of the function called by INSN.  */
     828                 :            : 
     829                 :            : tree
     830                 :  138412000 : get_call_fndecl (const rtx_insn *insn)
     831                 :            : {
     832                 :  138412000 :   rtx note, datum;
     833                 :            : 
     834                 :  138412000 :   note = find_reg_note (insn, REG_CALL_DECL, NULL_RTX);
     835                 :  138412000 :   if (note == NULL_RTX)
     836                 :            :     return NULL_TREE;
     837                 :            : 
     838                 :  136655000 :   datum = XEXP (note, 0);
     839                 :  136655000 :   if (datum != NULL_RTX)
     840                 :  130123000 :     return SYMBOL_REF_DECL (datum);
     841                 :            : 
     842                 :            :   return NULL_TREE;
     843                 :            : }
     844                 :            : 
     845                 :            : /* Return the value of the integer term in X, if one is apparent;
     846                 :            :    otherwise return 0.
     847                 :            :    Only obvious integer terms are detected.
     848                 :            :    This is used in cse.c with the `related_value' field.  */
     849                 :            : 
     850                 :            : HOST_WIDE_INT
     851                 :     262288 : get_integer_term (const_rtx x)
     852                 :            : {
     853                 :     262288 :   if (GET_CODE (x) == CONST)
     854                 :     149576 :     x = XEXP (x, 0);
     855                 :            : 
     856                 :     262288 :   if (GET_CODE (x) == MINUS
     857                 :          0 :       && CONST_INT_P (XEXP (x, 1)))
     858                 :          0 :     return - INTVAL (XEXP (x, 1));
     859                 :     262288 :   if (GET_CODE (x) == PLUS
     860                 :     149576 :       && CONST_INT_P (XEXP (x, 1)))
     861                 :     149576 :     return INTVAL (XEXP (x, 1));
     862                 :            :   return 0;
     863                 :            : }
     864                 :            : 
     865                 :            : /* If X is a constant, return the value sans apparent integer term;
     866                 :            :    otherwise return 0.
     867                 :            :    Only obvious integer terms are detected.  */
     868                 :            : 
     869                 :            : rtx
     870                 :     833120 : get_related_value (const_rtx x)
     871                 :            : {
     872                 :     833120 :   if (GET_CODE (x) != CONST)
     873                 :            :     return 0;
     874                 :     833120 :   x = XEXP (x, 0);
     875                 :     833120 :   if (GET_CODE (x) == PLUS
     876                 :     811588 :       && CONST_INT_P (XEXP (x, 1)))
     877                 :     811588 :     return XEXP (x, 0);
     878                 :      21532 :   else if (GET_CODE (x) == MINUS
     879                 :          0 :            && CONST_INT_P (XEXP (x, 1)))
     880                 :          0 :     return XEXP (x, 0);
     881                 :            :   return 0;
     882                 :            : }
     883                 :            : 
     884                 :            : /* Return true if SYMBOL is a SYMBOL_REF and OFFSET + SYMBOL points
     885                 :            :    to somewhere in the same object or object_block as SYMBOL.  */
     886                 :            : 
     887                 :            : bool
     888                 :          0 : offset_within_block_p (const_rtx symbol, HOST_WIDE_INT offset)
     889                 :            : {
     890                 :          0 :   tree decl;
     891                 :            : 
     892                 :          0 :   if (GET_CODE (symbol) != SYMBOL_REF)
     893                 :            :     return false;
     894                 :            : 
     895                 :          0 :   if (offset == 0)
     896                 :            :     return true;
     897                 :            : 
     898                 :          0 :   if (offset > 0)
     899                 :            :     {
     900                 :          0 :       if (CONSTANT_POOL_ADDRESS_P (symbol)
     901                 :          0 :           && offset < (int) GET_MODE_SIZE (get_pool_mode (symbol)))
     902                 :          0 :         return true;
     903                 :            : 
     904                 :          0 :       decl = SYMBOL_REF_DECL (symbol);
     905                 :          0 :       if (decl && offset < int_size_in_bytes (TREE_TYPE (decl)))
     906                 :            :         return true;
     907                 :            :     }
     908                 :            : 
     909                 :          0 :   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol)
     910                 :          0 :       && SYMBOL_REF_BLOCK (symbol)
     911                 :          0 :       && SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0
     912                 :          0 :       && ((unsigned HOST_WIDE_INT) offset + SYMBOL_REF_BLOCK_OFFSET (symbol)
     913                 :          0 :           < (unsigned HOST_WIDE_INT) SYMBOL_REF_BLOCK (symbol)->size))
     914                 :          0 :     return true;
     915                 :            : 
     916                 :            :   return false;
     917                 :            : }
     918                 :            : 
     919                 :            : /* Split X into a base and a constant offset, storing them in *BASE_OUT
     920                 :            :    and *OFFSET_OUT respectively.  */
     921                 :            : 
     922                 :            : void
     923                 :          0 : split_const (rtx x, rtx *base_out, rtx *offset_out)
     924                 :            : {
     925                 :          0 :   if (GET_CODE (x) == CONST)
     926                 :            :     {
     927                 :          0 :       x = XEXP (x, 0);
     928                 :          0 :       if (GET_CODE (x) == PLUS && CONST_INT_P (XEXP (x, 1)))
     929                 :            :         {
     930                 :          0 :           *base_out = XEXP (x, 0);
     931                 :          0 :           *offset_out = XEXP (x, 1);
     932                 :          0 :           return;
     933                 :            :         }
     934                 :            :     }
     935                 :          0 :   *base_out = x;
     936                 :          0 :   *offset_out = const0_rtx;
     937                 :            : }
     938                 :            : 
     939                 :            : /* Express integer value X as some value Y plus a polynomial offset,
     940                 :            :    where Y is either const0_rtx, X or something within X (as opposed
     941                 :            :    to a new rtx).  Return the Y and store the offset in *OFFSET_OUT.  */
     942                 :            : 
     943                 :            : rtx
     944                 :  286411000 : strip_offset (rtx x, poly_int64_pod *offset_out)
     945                 :            : {
     946                 :  286411000 :   rtx base = const0_rtx;
     947                 :  286411000 :   rtx test = x;
     948                 :  286411000 :   if (GET_CODE (test) == CONST)
     949                 :    5574540 :     test = XEXP (test, 0);
     950                 :  286411000 :   if (GET_CODE (test) == PLUS)
     951                 :            :     {
     952                 :  227468000 :       base = XEXP (test, 0);
     953                 :  227468000 :       test = XEXP (test, 1);
     954                 :            :     }
     955                 :  286411000 :   if (poly_int_rtx_p (test, offset_out))
     956                 :  216007000 :     return base;
     957                 :   70403800 :   *offset_out = 0;
     958                 :   70403800 :   return x;
     959                 :            : }
     960                 :            : 
     961                 :            : /* Return the argument size in REG_ARGS_SIZE note X.  */
     962                 :            : 
     963                 :            : poly_int64
     964                 :    5514160 : get_args_size (const_rtx x)
     965                 :            : {
     966                 :    5514160 :   gcc_checking_assert (REG_NOTE_KIND (x) == REG_ARGS_SIZE);
     967                 :    5514160 :   return rtx_to_poly_int64 (XEXP (x, 0));
     968                 :            : }
     969                 :            : 
     970                 :            : /* Return the number of places FIND appears within X.  If COUNT_DEST is
     971                 :            :    zero, we do not count occurrences inside the destination of a SET.  */
     972                 :            : 
     973                 :            : int
     974                 :    5217600 : count_occurrences (const_rtx x, const_rtx find, int count_dest)
     975                 :            : {
     976                 :    5217600 :   int i, j;
     977                 :    5217600 :   enum rtx_code code;
     978                 :    5217600 :   const char *format_ptr;
     979                 :    5217600 :   int count;
     980                 :            : 
     981                 :    5217600 :   if (x == find)
     982                 :            :     return 1;
     983                 :            : 
     984                 :    3662760 :   code = GET_CODE (x);
     985                 :            : 
     986                 :    3662760 :   switch (code)
     987                 :            :     {
     988                 :            :     case REG:
     989                 :            :     CASE_CONST_ANY:
     990                 :            :     case SYMBOL_REF:
     991                 :            :     case CODE_LABEL:
     992                 :            :     case PC:
     993                 :            :     case CC0:
     994                 :            :       return 0;
     995                 :            : 
     996                 :          0 :     case EXPR_LIST:
     997                 :          0 :       count = count_occurrences (XEXP (x, 0), find, count_dest);
     998                 :          0 :       if (XEXP (x, 1))
     999                 :          0 :         count += count_occurrences (XEXP (x, 1), find, count_dest);
    1000                 :            :       return count;
    1001                 :            : 
    1002                 :      13258 :     case MEM:
    1003                 :      13258 :       if (MEM_P (find) && rtx_equal_p (x, find))
    1004                 :            :         return 1;
    1005                 :            :       break;
    1006                 :            : 
    1007                 :          0 :     case SET:
    1008                 :          0 :       if (SET_DEST (x) == find && ! count_dest)
    1009                 :          0 :         return count_occurrences (SET_SRC (x), find, count_dest);
    1010                 :            :       break;
    1011                 :            : 
    1012                 :            :     default:
    1013                 :            :       break;
    1014                 :            :     }
    1015                 :            : 
    1016                 :    1799230 :   format_ptr = GET_RTX_FORMAT (code);
    1017                 :    1799230 :   count = 0;
    1018                 :            : 
    1019                 :    5427000 :   for (i = 0; i < GET_RTX_LENGTH (code); i++)
    1020                 :            :     {
    1021                 :    3627760 :       switch (*format_ptr++)
    1022                 :            :         {
    1023                 :    3555880 :         case 'e':
    1024                 :    3555880 :           count += count_occurrences (XEXP (x, i), find, count_dest);
    1025                 :    3555880 :           break;
    1026                 :            : 
    1027                 :            :         case 'E':
    1028                 :      83645 :           for (j = 0; j < XVECLEN (x, i); j++)
    1029                 :      67529 :             count += count_occurrences (XVECEXP (x, i, j), find, count_dest);
    1030                 :            :           break;
    1031                 :            :         }
    1032                 :            :     }
    1033                 :            :   return count;
    1034                 :            : }
    1035                 :            : 
    1036                 :            : 
    1037                 :            : /* Return TRUE if OP is a register or subreg of a register that
    1038                 :            :    holds an unsigned quantity.  Otherwise, return FALSE.  */
    1039                 :            : 
    1040                 :            : bool
    1041                 :          0 : unsigned_reg_p (rtx op)
    1042                 :            : {
    1043                 :          0 :   if (REG_P (op)
    1044                 :          0 :       && REG_EXPR (op)
    1045                 :          0 :       && TYPE_UNSIGNED (TREE_TYPE (REG_EXPR (op))))
    1046                 :            :     return true;
    1047                 :            : 
    1048                 :          0 :   if (GET_CODE (op) == SUBREG
    1049                 :          0 :       && SUBREG_PROMOTED_SIGN (op))
    1050                 :          0 :     return true;
    1051                 :            : 
    1052                 :            :   return false;
    1053                 :            : }
    1054                 :            : 
    1055                 :            : 
    1056                 :            : /* Nonzero if register REG appears somewhere within IN.
    1057                 :            :    Also works if REG is not a register; in this case it checks
    1058                 :            :    for a subexpression of IN that is Lisp "equal" to REG.  */
    1059                 :            : 
    1060                 :            : int
    1061                 :  656938000 : reg_mentioned_p (const_rtx reg, const_rtx in)
    1062                 :            : {
    1063                 :  656938000 :   const char *fmt;
    1064                 :  656938000 :   int i;
    1065                 :  656938000 :   enum rtx_code code;
    1066                 :            : 
    1067                 :  656938000 :   if (in == 0)
    1068                 :            :     return 0;
    1069                 :            : 
    1070                 :  655422000 :   if (reg == in)
    1071                 :            :     return 1;
    1072                 :            : 
    1073                 :  587648000 :   if (GET_CODE (in) == LABEL_REF)
    1074                 :    9856630 :     return reg == label_ref_label (in);
    1075                 :            : 
    1076                 :  577791000 :   code = GET_CODE (in);
    1077                 :            : 
    1078                 :  577791000 :   switch (code)
    1079                 :            :     {
    1080                 :            :       /* Compare registers by number.  */
    1081                 :  141524000 :     case REG:
    1082                 :  266608000 :       return REG_P (reg) && REGNO (in) == REGNO (reg);
    1083                 :            : 
    1084                 :            :       /* These codes have no constituent expressions
    1085                 :            :          and are unique.  */
    1086                 :            :     case SCRATCH:
    1087                 :            :     case CC0:
    1088                 :            :     case PC:
    1089                 :            :       return 0;
    1090                 :            : 
    1091                 :            :     CASE_CONST_ANY:
    1092                 :            :       /* These are kept unique for a given value.  */
    1093                 :            :       return 0;
    1094                 :            : 
    1095                 :  325550000 :     default:
    1096                 :  325550000 :       break;
    1097                 :            :     }
    1098                 :            : 
    1099                 :  325550000 :   if (GET_CODE (reg) == code && rtx_equal_p (reg, in))
    1100                 :            :     return 1;
    1101                 :            : 
    1102                 :  325396000 :   fmt = GET_RTX_FORMAT (code);
    1103                 :            : 
    1104                 :  722578000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1105                 :            :     {
    1106                 :  556204000 :       if (fmt[i] == 'E')
    1107                 :            :         {
    1108                 :   16068900 :           int j;
    1109                 :   35478700 :           for (j = XVECLEN (in, i) - 1; j >= 0; j--)
    1110                 :   31422500 :             if (reg_mentioned_p (reg, XVECEXP (in, i, j)))
    1111                 :            :               return 1;
    1112                 :            :         }
    1113                 :  540135000 :       else if (fmt[i] == 'e'
    1114                 :  540135000 :                && reg_mentioned_p (reg, XEXP (in, i)))
    1115                 :            :         return 1;
    1116                 :            :     }
    1117                 :            :   return 0;
    1118                 :            : }
    1119                 :            : 
    1120                 :            : /* Return 1 if in between BEG and END, exclusive of BEG and END, there is
    1121                 :            :    no CODE_LABEL insn.  */
    1122                 :            : 
    1123                 :            : int
    1124                 :          0 : no_labels_between_p (const rtx_insn *beg, const rtx_insn *end)
    1125                 :            : {
    1126                 :          0 :   rtx_insn *p;
    1127                 :          0 :   if (beg == end)
    1128                 :            :     return 0;
    1129                 :          0 :   for (p = NEXT_INSN (beg); p != end; p = NEXT_INSN (p))
    1130                 :          0 :     if (LABEL_P (p))
    1131                 :            :       return 0;
    1132                 :            :   return 1;
    1133                 :            : }
    1134                 :            : 
    1135                 :            : /* Nonzero if register REG is used in an insn between
    1136                 :            :    FROM_INSN and TO_INSN (exclusive of those two).  */
    1137                 :            : 
    1138                 :            : int
    1139                 :   10691700 : reg_used_between_p (const_rtx reg, const rtx_insn *from_insn,
    1140                 :            :                     const rtx_insn *to_insn)
    1141                 :            : {
    1142                 :   10691700 :   rtx_insn *insn;
    1143                 :            : 
    1144                 :   10691700 :   if (from_insn == to_insn)
    1145                 :            :     return 0;
    1146                 :            : 
    1147                 :  144597000 :   for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
    1148                 :   67169400 :     if (NONDEBUG_INSN_P (insn)
    1149                 :   67169400 :         && (reg_overlap_mentioned_p (reg, PATTERN (insn))
    1150                 :   39567500 :            || (CALL_P (insn) && find_reg_fusage (insn, USE, reg))))
    1151                 :     216446 :       return 1;
    1152                 :            :   return 0;
    1153                 :            : }
    1154                 :            : 
    1155                 :            : /* Nonzero if the old value of X, a register, is referenced in BODY.  If X
    1156                 :            :    is entirely replaced by a new value and the only use is as a SET_DEST,
    1157                 :            :    we do not consider it a reference.  */
    1158                 :            : 
    1159                 :            : int
    1160                 :   75451400 : reg_referenced_p (const_rtx x, const_rtx body)
    1161                 :            : {
    1162                 :   75451400 :   int i;
    1163                 :            : 
    1164                 :   75451400 :   switch (GET_CODE (body))
    1165                 :            :     {
    1166                 :   54359500 :     case SET:
    1167                 :   54359500 :       if (reg_overlap_mentioned_p (x, SET_SRC (body)))
    1168                 :            :         return 1;
    1169                 :            : 
    1170                 :            :       /* If the destination is anything other than CC0, PC, a REG or a SUBREG
    1171                 :            :          of a REG that occupies all of the REG, the insn references X if
    1172                 :            :          it is mentioned in the destination.  */
    1173                 :   37696300 :       if (GET_CODE (SET_DEST (body)) != CC0
    1174                 :   37696300 :           && GET_CODE (SET_DEST (body)) != PC
    1175                 :   36648600 :           && !REG_P (SET_DEST (body))
    1176                 :    1727940 :           && ! (GET_CODE (SET_DEST (body)) == SUBREG
    1177                 :     294282 :                 && REG_P (SUBREG_REG (SET_DEST (body)))
    1178                 :     294282 :                 && !read_modify_subreg_p (SET_DEST (body)))
    1179                 :   39026600 :           && reg_overlap_mentioned_p (x, SET_DEST (body)))
    1180                 :     350978 :         return 1;
    1181                 :            :       return 0;
    1182                 :            : 
    1183                 :       6610 :     case ASM_OPERANDS:
    1184                 :      15650 :       for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
    1185                 :      14516 :         if (reg_overlap_mentioned_p (x, ASM_OPERANDS_INPUT (body, i)))
    1186                 :            :           return 1;
    1187                 :            :       return 0;
    1188                 :            : 
    1189                 :     600186 :     case CALL:
    1190                 :     600186 :     case USE:
    1191                 :     600186 :     case IF_THEN_ELSE:
    1192                 :     600186 :       return reg_overlap_mentioned_p (x, body);
    1193                 :            : 
    1194                 :          0 :     case TRAP_IF:
    1195                 :          0 :       return reg_overlap_mentioned_p (x, TRAP_CONDITION (body));
    1196                 :            : 
    1197                 :       1988 :     case PREFETCH:
    1198                 :       1988 :       return reg_overlap_mentioned_p (x, XEXP (body, 0));
    1199                 :            : 
    1200                 :      15274 :     case UNSPEC:
    1201                 :      15274 :     case UNSPEC_VOLATILE:
    1202                 :      31240 :       for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
    1203                 :      19084 :         if (reg_overlap_mentioned_p (x, XVECEXP (body, 0, i)))
    1204                 :            :           return 1;
    1205                 :            :       return 0;
    1206                 :            : 
    1207                 :   10687200 :     case PARALLEL:
    1208                 :   30653300 :       for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
    1209                 :   22367800 :         if (reg_referenced_p (x, XVECEXP (body, 0, i)))
    1210                 :            :           return 1;
    1211                 :            :       return 0;
    1212                 :            : 
    1213                 :    9776810 :     case CLOBBER:
    1214                 :    9776810 :       if (MEM_P (XEXP (body, 0)))
    1215                 :       9310 :         if (reg_overlap_mentioned_p (x, XEXP (XEXP (body, 0), 0)))
    1216                 :          0 :           return 1;
    1217                 :            :       return 0;
    1218                 :            : 
    1219                 :          0 :     case COND_EXEC:
    1220                 :          0 :       if (reg_overlap_mentioned_p (x, COND_EXEC_TEST (body)))
    1221                 :            :         return 1;
    1222                 :          0 :       return reg_referenced_p (x, COND_EXEC_CODE (body));
    1223                 :            : 
    1224                 :            :     default:
    1225                 :            :       return 0;
    1226                 :            :     }
    1227                 :            : }
    1228                 :            : 
    1229                 :            : /* Nonzero if register REG is set or clobbered in an insn between
    1230                 :            :    FROM_INSN and TO_INSN (exclusive of those two).  */
    1231                 :            : 
    1232                 :            : int
    1233                 :   37797400 : reg_set_between_p (const_rtx reg, const rtx_insn *from_insn,
    1234                 :            :                    const rtx_insn *to_insn)
    1235                 :            : {
    1236                 :   37797400 :   const rtx_insn *insn;
    1237                 :            : 
    1238                 :   37797400 :   if (from_insn == to_insn)
    1239                 :            :     return 0;
    1240                 :            : 
    1241                 :  245361000 :   for (insn = NEXT_INSN (from_insn); insn != to_insn; insn = NEXT_INSN (insn))
    1242                 :  104619000 :     if (INSN_P (insn) && reg_set_p (reg, insn))
    1243                 :            :       return 1;
    1244                 :            :   return 0;
    1245                 :            : }
    1246                 :            : 
    1247                 :            : /* Return true if REG is set or clobbered inside INSN.  */
    1248                 :            : 
    1249                 :            : int
    1250                 :  175258000 : reg_set_p (const_rtx reg, const_rtx insn)
    1251                 :            : {
    1252                 :            :   /* After delay slot handling, call and branch insns might be in a
    1253                 :            :      sequence.  Check all the elements there.  */
    1254                 :  175258000 :   if (INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
    1255                 :            :     {
    1256                 :          0 :       for (int i = 0; i < XVECLEN (PATTERN (insn), 0); ++i)
    1257                 :          0 :         if (reg_set_p (reg, XVECEXP (PATTERN (insn), 0, i)))
    1258                 :            :           return true;
    1259                 :            : 
    1260                 :            :       return false;
    1261                 :            :     }
    1262                 :            : 
    1263                 :            :   /* We can be passed an insn or part of one.  If we are passed an insn,
    1264                 :            :      check if a side-effect of the insn clobbers REG.  */
    1265                 :  175258000 :   if (INSN_P (insn)
    1266                 :  175258000 :       && (FIND_REG_INC_NOTE (insn, reg)
    1267                 :            :           || (CALL_P (insn)
    1268                 :    3400410 :               && ((REG_P (reg)
    1269                 :    3400410 :                    && REGNO (reg) < FIRST_PSEUDO_REGISTER
    1270                 :    1983120 :                    && (insn_callee_abi (as_a<const rtx_insn *> (insn))
    1271                 :     991561 :                        .clobbers_reg_p (GET_MODE (reg), REGNO (reg))))
    1272                 :    2836320 :                   || MEM_P (reg)
    1273                 :    2836320 :                   || find_reg_fusage (insn, CLOBBER, reg)))))
    1274                 :     564089 :     return true;
    1275                 :            : 
    1276                 :            :   /* There are no REG_INC notes for SP autoinc.  */
    1277                 :  174694000 :   if (reg == stack_pointer_rtx && INSN_P (insn))
    1278                 :            :     {
    1279                 :    8862320 :       subrtx_var_iterator::array_type array;
    1280                 :   37361800 :       FOR_EACH_SUBRTX_VAR (iter, array, PATTERN (insn), NONCONST)
    1281                 :            :         {
    1282                 :   33323100 :           rtx mem = *iter;
    1283                 :   33323100 :           if (mem
    1284                 :   33323100 :               && MEM_P (mem)
    1285                 :    3970800 :               && GET_RTX_CLASS (GET_CODE (XEXP (mem, 0))) == RTX_AUTOINC)
    1286                 :            :             {
    1287                 :     784916 :               if (XEXP (XEXP (mem, 0), 0) == stack_pointer_rtx)
    1288                 :     784916 :                 return true;
    1289                 :   32538200 :               iter.skip_subrtxes ();
    1290                 :            :             }
    1291                 :            :         }
    1292                 :            :     }
    1293                 :            : 
    1294                 :  173909000 :   return set_of (reg, insn) != NULL_RTX;
    1295                 :            : }
    1296                 :            : 
    1297                 :            : /* Similar to reg_set_between_p, but check all registers in X.  Return 0
    1298                 :            :    only if none of them are modified between START and END.  Return 1 if
    1299                 :            :    X contains a MEM; this routine does use memory aliasing.  */
    1300                 :            : 
    1301                 :            : int
    1302                 :   98585100 : modified_between_p (const_rtx x, const rtx_insn *start, const rtx_insn *end)
    1303                 :            : {
    1304                 :   98585100 :   const enum rtx_code code = GET_CODE (x);
    1305                 :   98585100 :   const char *fmt;
    1306                 :   98585100 :   int i, j;
    1307                 :   98585100 :   rtx_insn *insn;
    1308                 :            : 
    1309                 :   98585100 :   if (start == end)
    1310                 :            :     return 0;
    1311                 :            : 
    1312                 :   98585100 :   switch (code)
    1313                 :            :     {
    1314                 :            :     CASE_CONST_ANY:
    1315                 :            :     case CONST:
    1316                 :            :     case SYMBOL_REF:
    1317                 :            :     case LABEL_REF:
    1318                 :            :       return 0;
    1319                 :            : 
    1320                 :        486 :     case PC:
    1321                 :        486 :     case CC0:
    1322                 :        486 :       return 1;
    1323                 :            : 
    1324                 :    7091070 :     case MEM:
    1325                 :    7091070 :       if (modified_between_p (XEXP (x, 0), start, end))
    1326                 :            :         return 1;
    1327                 :    7085480 :       if (MEM_READONLY_P (x))
    1328                 :            :         return 0;
    1329                 :   44017900 :       for (insn = NEXT_INSN (start); insn != end; insn = NEXT_INSN (insn))
    1330                 :   18955100 :         if (memory_modified_in_insn_p (x, insn))
    1331                 :            :           return 1;
    1332                 :            :       return 0;
    1333                 :            : 
    1334                 :   36839100 :     case REG:
    1335                 :   36839100 :       return reg_set_between_p (x, start, end);
    1336                 :            : 
    1337                 :   30890000 :     default:
    1338                 :   30890000 :       break;
    1339                 :            :     }
    1340                 :            : 
    1341                 :   30890000 :   fmt = GET_RTX_FORMAT (code);
    1342                 :   90627600 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1343                 :            :     {
    1344                 :   60507000 :       if (fmt[i] == 'e' && modified_between_p (XEXP (x, i), start, end))
    1345                 :            :         return 1;
    1346                 :            : 
    1347                 :   59738300 :       else if (fmt[i] == 'E')
    1348                 :    2379970 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1349                 :    1749620 :           if (modified_between_p (XVECEXP (x, i, j), start, end))
    1350                 :            :             return 1;
    1351                 :            :     }
    1352                 :            : 
    1353                 :            :   return 0;
    1354                 :            : }
    1355                 :            : 
    1356                 :            : /* Similar to reg_set_p, but check all registers in X.  Return 0 only if none
    1357                 :            :    of them are modified in INSN.  Return 1 if X contains a MEM; this routine
    1358                 :            :    does use memory aliasing.  */
    1359                 :            : 
    1360                 :            : int
    1361                 :  139857000 : modified_in_p (const_rtx x, const_rtx insn)
    1362                 :            : {
    1363                 :  139857000 :   const enum rtx_code code = GET_CODE (x);
    1364                 :  139857000 :   const char *fmt;
    1365                 :  139857000 :   int i, j;
    1366                 :            : 
    1367                 :  139857000 :   switch (code)
    1368                 :            :     {
    1369                 :            :     CASE_CONST_ANY:
    1370                 :            :     case CONST:
    1371                 :            :     case SYMBOL_REF:
    1372                 :            :     case LABEL_REF:
    1373                 :            :       return 0;
    1374                 :            : 
    1375                 :     589053 :     case PC:
    1376                 :     589053 :     case CC0:
    1377                 :     589053 :       return 1;
    1378                 :            : 
    1379                 :    5855320 :     case MEM:
    1380                 :    5855320 :       if (modified_in_p (XEXP (x, 0), insn))
    1381                 :            :         return 1;
    1382                 :    5828310 :       if (MEM_READONLY_P (x))
    1383                 :            :         return 0;
    1384                 :    5606560 :       if (memory_modified_in_insn_p (x, insn))
    1385                 :     286061 :         return 1;
    1386                 :            :       return 0;
    1387                 :            : 
    1388                 :   55439500 :     case REG:
    1389                 :   55439500 :       return reg_set_p (x, insn);
    1390                 :            : 
    1391                 :   43776100 :     default:
    1392                 :   43776100 :       break;
    1393                 :            :     }
    1394                 :            : 
    1395                 :   43776100 :   fmt = GET_RTX_FORMAT (code);
    1396                 :  124515000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1397                 :            :     {
    1398                 :   85291400 :       if (fmt[i] == 'e' && modified_in_p (XEXP (x, i), insn))
    1399                 :            :         return 1;
    1400                 :            : 
    1401                 :   80741900 :       else if (fmt[i] == 'E')
    1402                 :     302648 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1403                 :     158707 :           if (modified_in_p (XVECEXP (x, i, j), insn))
    1404                 :            :             return 1;
    1405                 :            :     }
    1406                 :            : 
    1407                 :            :   return 0;
    1408                 :            : }
    1409                 :            : 
    1410                 :            : /* Return true if X is a SUBREG and if storing a value to X would
    1411                 :            :    preserve some of its SUBREG_REG.  For example, on a normal 32-bit
    1412                 :            :    target, using a SUBREG to store to one half of a DImode REG would
    1413                 :            :    preserve the other half.  */
    1414                 :            : 
    1415                 :            : bool
    1416                 :   82577100 : read_modify_subreg_p (const_rtx x)
    1417                 :            : {
    1418                 :   82577100 :   if (GET_CODE (x) != SUBREG)
    1419                 :            :     return false;
    1420                 :   22214900 :   poly_uint64 isize = GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)));
    1421                 :   22214900 :   poly_uint64 osize = GET_MODE_SIZE (GET_MODE (x));
    1422                 :   11107400 :   poly_uint64 regsize = REGMODE_NATURAL_SIZE (GET_MODE (SUBREG_REG (x)));
    1423                 :            :   /* The inner and outer modes of a subreg must be ordered, so that we
    1424                 :            :      can tell whether they're paradoxical or partial.  */
    1425                 :   11107400 :   gcc_checking_assert (ordered_p (isize, osize));
    1426                 :   11107400 :   return (maybe_gt (isize, osize) && maybe_gt (isize, regsize));
    1427                 :            : }
    1428                 :            : 
    1429                 :            : /* Helper function for set_of.  */
    1430                 :            : struct set_of_data
    1431                 :            :   {
    1432                 :            :     const_rtx found;
    1433                 :            :     const_rtx pat;
    1434                 :            :   };
    1435                 :            : 
    1436                 :            : static void
    1437                 :  183021000 : set_of_1 (rtx x, const_rtx pat, void *data1)
    1438                 :            : {
    1439                 :  183021000 :   struct set_of_data *const data = (struct set_of_data *) (data1);
    1440                 :  183021000 :   if (rtx_equal_p (x, data->pat)
    1441                 :  183021000 :       || (!MEM_P (x) && reg_overlap_mentioned_p (data->pat, x)))
    1442                 :   38249400 :     data->found = pat;
    1443                 :  183021000 : }
    1444                 :            : 
    1445                 :            : /* Give an INSN, return a SET or CLOBBER expression that does modify PAT
    1446                 :            :    (either directly or via STRICT_LOW_PART and similar modifiers).  */
    1447                 :            : const_rtx
    1448                 :  205075000 : set_of (const_rtx pat, const_rtx insn)
    1449                 :            : {
    1450                 :  205075000 :   struct set_of_data data;
    1451                 :  205075000 :   data.found = NULL_RTX;
    1452                 :  205075000 :   data.pat = pat;
    1453                 :  205075000 :   note_pattern_stores (INSN_P (insn) ? PATTERN (insn) : insn, set_of_1, &data);
    1454                 :  205075000 :   return data.found;
    1455                 :            : }
    1456                 :            : 
    1457                 :            : /* Add all hard register in X to *PSET.  */
    1458                 :            : void
    1459                 :    2657150 : find_all_hard_regs (const_rtx x, HARD_REG_SET *pset)
    1460                 :            : {
    1461                 :    2657150 :   subrtx_iterator::array_type array;
    1462                 :    7129810 :   FOR_EACH_SUBRTX (iter, array, x, NONCONST)
    1463                 :            :     {
    1464                 :    4472660 :       const_rtx x = *iter;
    1465                 :    4472660 :       if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
    1466                 :    6754120 :         add_to_hard_reg_set (pset, GET_MODE (x), REGNO (x));
    1467                 :            :     }
    1468                 :    2657150 : }
    1469                 :            : 
    1470                 :            : /* This function, called through note_stores, collects sets and
    1471                 :            :    clobbers of hard registers in a HARD_REG_SET, which is pointed to
    1472                 :            :    by DATA.  */
    1473                 :            : void
    1474                 :   15003200 : record_hard_reg_sets (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
    1475                 :            : {
    1476                 :   15003200 :   HARD_REG_SET *pset = (HARD_REG_SET *)data;
    1477                 :   15003200 :   if (REG_P (x) && HARD_REGISTER_P (x))
    1478                 :    9696400 :     add_to_hard_reg_set (pset, GET_MODE (x), REGNO (x));
    1479                 :   15003200 : }
    1480                 :            : 
    1481                 :            : /* Examine INSN, and compute the set of hard registers written by it.
    1482                 :            :    Store it in *PSET.  Should only be called after reload.
    1483                 :            : 
    1484                 :            :    IMPLICIT is true if we should include registers that are fully-clobbered
    1485                 :            :    by calls.  This should be used with caution, since it doesn't include
    1486                 :            :    partially-clobbered registers.  */
    1487                 :            : void
    1488                 :   11457800 : find_all_hard_reg_sets (const rtx_insn *insn, HARD_REG_SET *pset, bool implicit)
    1489                 :            : {
    1490                 :   11457800 :   rtx link;
    1491                 :            : 
    1492                 :   11457800 :   CLEAR_HARD_REG_SET (*pset);
    1493                 :   11457800 :   note_stores (insn, record_hard_reg_sets, pset);
    1494                 :   11457800 :   if (CALL_P (insn) && implicit)
    1495                 :          0 :     *pset |= insn_callee_abi (insn).full_reg_clobbers ();
    1496                 :   22666100 :   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    1497                 :   11208300 :     if (REG_NOTE_KIND (link) == REG_INC)
    1498                 :          0 :       record_hard_reg_sets (XEXP (link, 0), NULL, pset);
    1499                 :   11457800 : }
    1500                 :            : 
    1501                 :            : /* Like record_hard_reg_sets, but called through note_uses.  */
    1502                 :            : void
    1503                 :    2657150 : record_hard_reg_uses (rtx *px, void *data)
    1504                 :            : {
    1505                 :    2657150 :   find_all_hard_regs (*px, (HARD_REG_SET *) data);
    1506                 :    2657150 : }
    1507                 :            : 
    1508                 :            : /* Given an INSN, return a SET expression if this insn has only a single SET.
    1509                 :            :    It may also have CLOBBERs, USEs, or SET whose output
    1510                 :            :    will not be used, which we ignore.  */
    1511                 :            : 
    1512                 :            : rtx
    1513                 : 1133230000 : single_set_2 (const rtx_insn *insn, const_rtx pat)
    1514                 :            : {
    1515                 : 1133230000 :   rtx set = NULL;
    1516                 : 1133230000 :   int set_verified = 1;
    1517                 : 1133230000 :   int i;
    1518                 :            : 
    1519                 : 1133230000 :   if (GET_CODE (pat) == PARALLEL)
    1520                 :            :     {
    1521                 : 1337000000 :       for (i = 0; i < XVECLEN (pat, 0); i++)
    1522                 :            :         {
    1523                 :  912980000 :           rtx sub = XVECEXP (pat, 0, i);
    1524                 :  912980000 :           switch (GET_CODE (sub))
    1525                 :            :             {
    1526                 :            :             case USE:
    1527                 :            :             case CLOBBER:
    1528                 :            :               break;
    1529                 :            : 
    1530                 :  462538000 :             case SET:
    1531                 :            :               /* We can consider insns having multiple sets, where all
    1532                 :            :                  but one are dead as single set insns.  In common case
    1533                 :            :                  only single set is present in the pattern so we want
    1534                 :            :                  to avoid checking for REG_UNUSED notes unless necessary.
    1535                 :            : 
    1536                 :            :                  When we reach set first time, we just expect this is
    1537                 :            :                  the single set we are looking for and only when more
    1538                 :            :                  sets are found in the insn, we check them.  */
    1539                 :  462538000 :               if (!set_verified)
    1540                 :            :                 {
    1541                 :   24929700 :                   if (find_reg_note (insn, REG_UNUSED, SET_DEST (set))
    1542                 :   24929700 :                       && !side_effects_p (set))
    1543                 :            :                     set = NULL;
    1544                 :            :                   else
    1545                 :            :                     set_verified = 1;
    1546                 :            :                 }
    1547                 :  462538000 :               if (!set)
    1548                 :            :                 set = sub, set_verified = 0;
    1549                 :   16375500 :               else if (!find_reg_note (insn, REG_UNUSED, SET_DEST (sub))
    1550                 :   16375500 :                        || side_effects_p (sub))
    1551                 :   12283800 :                 return NULL_RTX;
    1552                 :            :               break;
    1553                 :            : 
    1554                 :            :             default:
    1555                 :            :               return NULL_RTX;
    1556                 :            :             }
    1557                 :            :         }
    1558                 :            :     }
    1559                 :            :   return set;
    1560                 :            : }
    1561                 :            : 
    1562                 :            : /* Given an INSN, return nonzero if it has more than one SET, else return
    1563                 :            :    zero.  */
    1564                 :            : 
    1565                 :            : int
    1566                 :  153543000 : multiple_sets (const_rtx insn)
    1567                 :            : {
    1568                 :  153543000 :   int found;
    1569                 :  153543000 :   int i;
    1570                 :            : 
    1571                 :            :   /* INSN must be an insn.  */
    1572                 :  153543000 :   if (! INSN_P (insn))
    1573                 :            :     return 0;
    1574                 :            : 
    1575                 :            :   /* Only a PARALLEL can have multiple SETs.  */
    1576                 :  153543000 :   if (GET_CODE (PATTERN (insn)) == PARALLEL)
    1577                 :            :     {
    1578                 :  138869000 :       for (i = 0, found = 0; i < XVECLEN (PATTERN (insn), 0); i++)
    1579                 :   93701200 :         if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
    1580                 :            :           {
    1581                 :            :             /* If we have already found a SET, then return now.  */
    1582                 :   47419100 :             if (found)
    1583                 :            :               return 1;
    1584                 :            :             else
    1585                 :            :               found = 1;
    1586                 :            :           }
    1587                 :            :     }
    1588                 :            : 
    1589                 :            :   /* Either zero or one SET.  */
    1590                 :            :   return 0;
    1591                 :            : }
    1592                 :            : 
    1593                 :            : /* Return nonzero if the destination of SET equals the source
    1594                 :            :    and there are no side effects.  */
    1595                 :            : 
    1596                 :            : int
    1597                 :  879832000 : set_noop_p (const_rtx set)
    1598                 :            : {
    1599                 :  879832000 :   rtx src = SET_SRC (set);
    1600                 :  879832000 :   rtx dst = SET_DEST (set);
    1601                 :            : 
    1602                 :  879832000 :   if (dst == pc_rtx && src == pc_rtx)
    1603                 :            :     return 1;
    1604                 :            : 
    1605                 :  879826000 :   if (MEM_P (dst) && MEM_P (src))
    1606                 :    9986820 :     return rtx_equal_p (dst, src) && !side_effects_p (dst);
    1607                 :            : 
    1608                 :  869840000 :   if (GET_CODE (dst) == ZERO_EXTRACT)
    1609                 :      56587 :     return rtx_equal_p (XEXP (dst, 0), src)
    1610                 :          0 :            && !BITS_BIG_ENDIAN && XEXP (dst, 2) == const0_rtx
    1611                 :      56587 :            && !side_effects_p (src);
    1612                 :            : 
    1613                 :  869783000 :   if (GET_CODE (dst) == STRICT_LOW_PART)
    1614                 :     185613 :     dst = XEXP (dst, 0);
    1615                 :            : 
    1616                 :  869783000 :   if (GET_CODE (src) == SUBREG && GET_CODE (dst) == SUBREG)
    1617                 :            :     {
    1618                 :     264437 :       if (maybe_ne (SUBREG_BYTE (src), SUBREG_BYTE (dst)))
    1619                 :            :         return 0;
    1620                 :     245180 :       src = SUBREG_REG (src);
    1621                 :     245180 :       dst = SUBREG_REG (dst);
    1622                 :            :     }
    1623                 :            : 
    1624                 :            :   /* It is a NOOP if destination overlaps with selected src vector
    1625                 :            :      elements.  */
    1626                 :  869764000 :   if (GET_CODE (src) == VEC_SELECT
    1627                 :    3109220 :       && REG_P (XEXP (src, 0)) && REG_P (dst)
    1628                 :    1155890 :       && HARD_REGISTER_P (XEXP (src, 0))
    1629                 :  869960000 :       && HARD_REGISTER_P (dst))
    1630                 :            :     {
    1631                 :     196208 :       int i;
    1632                 :     196208 :       rtx par = XEXP (src, 1);
    1633                 :     196208 :       rtx src0 = XEXP (src, 0);
    1634                 :     196208 :       poly_int64 c0 = rtx_to_poly_int64 (XVECEXP (par, 0, 0));
    1635                 :     392416 :       poly_int64 offset = GET_MODE_UNIT_SIZE (GET_MODE (src0)) * c0;
    1636                 :            : 
    1637                 :     410574 :       for (i = 1; i < XVECLEN (par, 0); i++)
    1638                 :     299345 :         if (maybe_ne (rtx_to_poly_int64 (XVECEXP (par, 0, i)), c0 + i))
    1639                 :            :           return 0;
    1640                 :     111229 :       return
    1641                 :     111229 :         REG_CAN_CHANGE_MODE_P (REGNO (dst), GET_MODE (src0), GET_MODE (dst))
    1642                 :     222458 :         && simplify_subreg_regno (REGNO (src0), GET_MODE (src0),
    1643                 :     213986 :                                   offset, GET_MODE (dst)) == (int) REGNO (dst);
    1644                 :            :     }
    1645                 :            : 
    1646                 :  226042000 :   return (REG_P (src) && REG_P (dst)
    1647                 : 1214400000 :           && REGNO (src) == REGNO (dst));
    1648                 :            : }
    1649                 :            : 
    1650                 :            : /* Return nonzero if an insn consists only of SETs, each of which only sets a
    1651                 :            :    value to itself.  */
    1652                 :            : 
    1653                 :            : int
    1654                 :  565608000 : noop_move_p (const rtx_insn *insn)
    1655                 :            : {
    1656                 :  565608000 :   rtx pat = PATTERN (insn);
    1657                 :            : 
    1658                 :  565608000 :   if (INSN_CODE (insn) == NOOP_MOVE_INSN_CODE)
    1659                 :            :     return 1;
    1660                 :            : 
    1661                 :            :   /* Insns carrying these notes are useful later on.  */
    1662                 :  565604000 :   if (find_reg_note (insn, REG_EQUAL, NULL_RTX))
    1663                 :            :     return 0;
    1664                 :            : 
    1665                 :            :   /* Check the code to be executed for COND_EXEC.  */
    1666                 :  544778000 :   if (GET_CODE (pat) == COND_EXEC)
    1667                 :          0 :     pat = COND_EXEC_CODE (pat);
    1668                 :            : 
    1669                 :  544778000 :   if (GET_CODE (pat) == SET && set_noop_p (pat))
    1670                 :            :     return 1;
    1671                 :            : 
    1672                 :  544775000 :   if (GET_CODE (pat) == PARALLEL)
    1673                 :            :     {
    1674                 :            :       int i;
    1675                 :            :       /* If nothing but SETs of registers to themselves,
    1676                 :            :          this insn can also be deleted.  */
    1677                 :   73770700 :       for (i = 0; i < XVECLEN (pat, 0); i++)
    1678                 :            :         {
    1679                 :   73770700 :           rtx tem = XVECEXP (pat, 0, i);
    1680                 :            : 
    1681                 :   73770700 :           if (GET_CODE (tem) == USE || GET_CODE (tem) == CLOBBER)
    1682                 :      14223 :             continue;
    1683                 :            : 
    1684                 :   73756400 :           if (GET_CODE (tem) != SET || ! set_noop_p (tem))
    1685                 :   73756400 :             return 0;
    1686                 :            :         }
    1687                 :            : 
    1688                 :            :       return 1;
    1689                 :            :     }
    1690                 :            :   return 0;
    1691                 :            : }
    1692                 :            : 
    1693                 :            : 
    1694                 :            : /* Return nonzero if register in range [REGNO, ENDREGNO)
    1695                 :            :    appears either explicitly or implicitly in X
    1696                 :            :    other than being stored into.
    1697                 :            : 
    1698                 :            :    References contained within the substructure at LOC do not count.
    1699                 :            :    LOC may be zero, meaning don't ignore anything.  */
    1700                 :            : 
    1701                 :            : bool
    1702                 :  832586000 : refers_to_regno_p (unsigned int regno, unsigned int endregno, const_rtx x,
    1703                 :            :                    rtx *loc)
    1704                 :            : {
    1705                 : 1286850000 :   int i;
    1706                 : 1286850000 :   unsigned int x_regno;
    1707                 : 1286850000 :   RTX_CODE code;
    1708                 : 1286850000 :   const char *fmt;
    1709                 :            : 
    1710                 : 1286850000 :  repeat:
    1711                 :            :   /* The contents of a REG_NONNEG note is always zero, so we must come here
    1712                 :            :      upon repeat in case the last REG_NOTE is a REG_NONNEG note.  */
    1713                 : 1286850000 :   if (x == 0)
    1714                 :            :     return false;
    1715                 :            : 
    1716                 : 1286850000 :   code = GET_CODE (x);
    1717                 :            : 
    1718                 : 1286850000 :   switch (code)
    1719                 :            :     {
    1720                 :  517369000 :     case REG:
    1721                 :  517369000 :       x_regno = REGNO (x);
    1722                 :            : 
    1723                 :            :       /* If we modifying the stack, frame, or argument pointer, it will
    1724                 :            :          clobber a virtual register.  In fact, we could be more precise,
    1725                 :            :          but it isn't worth it.  */
    1726                 :  517369000 :       if ((x_regno == STACK_POINTER_REGNUM
    1727                 :  517369000 :            || (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
    1728                 :  517369000 :                && x_regno == ARG_POINTER_REGNUM)
    1729                 :  492793000 :            || x_regno == FRAME_POINTER_REGNUM)
    1730                 :   74781700 :           && regno >= FIRST_VIRTUAL_REGISTER && regno <= LAST_VIRTUAL_REGISTER)
    1731                 :            :         return true;
    1732                 :            : 
    1733                 :  517369000 :       return endregno > x_regno && regno < END_REGNO (x);
    1734                 :            : 
    1735                 :   22757700 :     case SUBREG:
    1736                 :            :       /* If this is a SUBREG of a hard reg, we can see exactly which
    1737                 :            :          registers are being modified.  Otherwise, handle normally.  */
    1738                 :   22757700 :       if (REG_P (SUBREG_REG (x))
    1739                 :   22757700 :           && REGNO (SUBREG_REG (x)) < FIRST_PSEUDO_REGISTER)
    1740                 :            :         {
    1741                 :       6275 :           unsigned int inner_regno = subreg_regno (x);
    1742                 :       6275 :           unsigned int inner_endregno
    1743                 :            :             = inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
    1744                 :       6275 :                              ? subreg_nregs (x) : 1);
    1745                 :            : 
    1746                 :       6275 :           return endregno > inner_regno && regno < inner_endregno;
    1747                 :            :         }
    1748                 :            :       break;
    1749                 :            : 
    1750                 :   57421400 :     case CLOBBER:
    1751                 :   57421400 :     case SET:
    1752                 :   57421400 :       if (&SET_DEST (x) != loc
    1753                 :            :           /* Note setting a SUBREG counts as referring to the REG it is in for
    1754                 :            :              a pseudo but not for hard registers since we can
    1755                 :            :              treat each word individually.  */
    1756                 :   57421400 :           && ((GET_CODE (SET_DEST (x)) == SUBREG
    1757                 :     888538 :                && loc != &SUBREG_REG (SET_DEST (x))
    1758                 :     888538 :                && REG_P (SUBREG_REG (SET_DEST (x)))
    1759                 :     888538 :                && REGNO (SUBREG_REG (SET_DEST (x))) >= FIRST_PSEUDO_REGISTER
    1760                 :     888538 :                && refers_to_regno_p (regno, endregno,
    1761                 :            :                                      SUBREG_REG (SET_DEST (x)), loc))
    1762                 :   57391400 :               || (!REG_P (SET_DEST (x))
    1763                 :    9158270 :                   && refers_to_regno_p (regno, endregno, SET_DEST (x), loc))))
    1764                 :     108499 :         return true;
    1765                 :            : 
    1766                 :   57312900 :       if (code == CLOBBER || loc == &SET_SRC (x))
    1767                 :            :         return false;
    1768                 :   47818100 :       x = SET_SRC (x);
    1769                 :   47818100 :       goto repeat;
    1770                 :            : 
    1771                 :            :     default:
    1772                 :            :       break;
    1773                 :            :     }
    1774                 :            : 
    1775                 :            :   /* X does not match, so try its subexpressions.  */
    1776                 :            : 
    1777                 :  712049000 :   fmt = GET_RTX_FORMAT (code);
    1778                 : 1435370000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    1779                 :            :     {
    1780                 : 1134330000 :       if (fmt[i] == 'e' && loc != &XEXP (x, i))
    1781                 :            :         {
    1782                 :  699097000 :           if (i == 0)
    1783                 :            :             {
    1784                 :  406441000 :               x = XEXP (x, 0);
    1785                 :  406441000 :               goto repeat;
    1786                 :            :             }
    1787                 :            :           else
    1788                 :  292657000 :             if (refers_to_regno_p (regno, endregno, XEXP (x, i), loc))
    1789                 :            :               return true;
    1790                 :            :         }
    1791                 :  435230000 :       else if (fmt[i] == 'E')
    1792                 :            :         {
    1793                 :   26271100 :           int j;
    1794                 :   87465000 :           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    1795                 :   62360600 :             if (loc != &XVECEXP (x, i, j)
    1796                 :   62360600 :                 && refers_to_regno_p (regno, endregno, XVECEXP (x, i, j), loc))
    1797                 :            :               return true;
    1798                 :            :         }
    1799                 :            :     }
    1800                 :            :   return false;
    1801                 :            : }
    1802                 :            : 
    1803                 :            : /* Nonzero if modifying X will affect IN.  If X is a register or a SUBREG,
    1804                 :            :    we check if any register number in X conflicts with the relevant register
    1805                 :            :    numbers.  If X is a constant, return 0.  If X is a MEM, return 1 iff IN
    1806                 :            :    contains a MEM (we don't bother checking for memory addresses that can't
    1807                 :            :    conflict because we expect this to be a rare case.  */
    1808                 :            : 
    1809                 :            : int
    1810                 :  386514000 : reg_overlap_mentioned_p (const_rtx x, const_rtx in)
    1811                 :            : {
    1812                 :  386514000 :   unsigned int regno, endregno;
    1813                 :            : 
    1814                 :            :   /* If either argument is a constant, then modifying X cannot
    1815                 :            :      affect IN.  Here we look at IN, we can profitably combine
    1816                 :            :      CONSTANT_P (x) with the switch statement below.  */
    1817                 :  386514000 :   if (CONSTANT_P (in))
    1818                 :            :     return 0;
    1819                 :            : 
    1820                 :  370650000 :  recurse:
    1821                 :  370650000 :   switch (GET_CODE (x))
    1822                 :            :     {
    1823                 :         52 :     case CLOBBER:
    1824                 :         52 :     case STRICT_LOW_PART:
    1825                 :         52 :     case ZERO_EXTRACT:
    1826                 :         52 :     case SIGN_EXTRACT:
    1827                 :            :       /* Overly conservative.  */
    1828                 :         52 :       x = XEXP (x, 0);
    1829                 :         52 :       goto recurse;
    1830                 :            : 
    1831                 :     899412 :     case SUBREG:
    1832                 :     899412 :       regno = REGNO (SUBREG_REG (x));
    1833                 :     899412 :       if (regno < FIRST_PSEUDO_REGISTER)
    1834                 :          0 :         regno = subreg_regno (x);
    1835                 :    1798820 :       endregno = regno + (regno < FIRST_PSEUDO_REGISTER
    1836                 :     899412 :                           ? subreg_nregs (x) : 1);
    1837                 :     899412 :       goto do_reg;
    1838                 :            : 
    1839                 :  367386000 :     case REG:
    1840                 :  367386000 :       regno = REGNO (x);
    1841                 :  367386000 :       endregno = END_REGNO (x);
    1842                 :  368285000 :     do_reg:
    1843                 :  368285000 :       return refers_to_regno_p (regno, endregno, in, (rtx*) 0);
    1844                 :            : 
    1845                 :    1159970 :     case MEM:
    1846                 :    1159970 :       {
    1847                 :    1159970 :         const char *fmt;
    1848                 :    1159970 :         int i;
    1849                 :            : 
    1850                 :    1159970 :         if (MEM_P (in))
    1851                 :            :           return 1;
    1852                 :            : 
    1853                 :    1068740 :         fmt = GET_RTX_FORMAT (GET_CODE (in));
    1854                 :    2285230 :         for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--)
    1855                 :    1255770 :           if (fmt[i] == 'e')
    1856                 :            :             {
    1857                 :     356622 :               if (reg_overlap_mentioned_p (x, XEXP (in, i)))
    1858                 :            :                 return 1;
    1859                 :            :             }
    1860                 :     899147 :           else if (fmt[i] == 'E')
    1861                 :            :             {
    1862                 :      20766 :               int j;
    1863                 :      89251 :               for (j = XVECLEN (in, i) - 1; j >= 0; --j)
    1864                 :      74746 :                 if (reg_overlap_mentioned_p (x, XVECEXP (in, i, j)))
    1865                 :            :                   return 1;
    1866                 :            :             }
    1867                 :            : 
    1868                 :            :         return 0;
    1869                 :            :       }
    1870                 :            : 
    1871                 :    1158800 :     case SCRATCH:
    1872                 :    1158800 :     case PC:
    1873                 :    1158800 :     case CC0:
    1874                 :    1158800 :       return reg_mentioned_p (x, in);
    1875                 :            : 
    1876                 :          0 :     case PARALLEL:
    1877                 :          0 :       {
    1878                 :          0 :         int i;
    1879                 :            : 
    1880                 :            :         /* If any register in here refers to it we return true.  */
    1881                 :          0 :         for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
    1882                 :          0 :           if (XEXP (XVECEXP (x, 0, i), 0) != 0
    1883                 :          0 :               && reg_overlap_mentioned_p (XEXP (XVECEXP (x, 0, i), 0), in))
    1884                 :            :             return 1;
    1885                 :            :         return 0;
    1886                 :            :       }
    1887                 :            : 
    1888                 :      46209 :     default:
    1889                 :      46209 :       gcc_assert (CONSTANT_P (x));
    1890                 :            :       return 0;
    1891                 :            :     }
    1892                 :            : }
    1893                 :            : 
    1894                 :            : /* Call FUN on each register or MEM that is stored into or clobbered by X.
    1895                 :            :    (X would be the pattern of an insn).  DATA is an arbitrary pointer,
    1896                 :            :    ignored by note_stores, but passed to FUN.
    1897                 :            : 
    1898                 :            :    FUN receives three arguments:
    1899                 :            :    1. the REG, MEM, CC0 or PC being stored in or clobbered,
    1900                 :            :    2. the SET or CLOBBER rtx that does the store,
    1901                 :            :    3. the pointer DATA provided to note_stores.
    1902                 :            : 
    1903                 :            :   If the item being stored in or clobbered is a SUBREG of a hard register,
    1904                 :            :   the SUBREG will be passed.  */
    1905                 :            : 
    1906                 :            : void
    1907                 : 3559710000 : note_pattern_stores (const_rtx x,
    1908                 :            :                      void (*fun) (rtx, const_rtx, void *), void *data)
    1909                 :            : {
    1910                 : 3559710000 :   int i;
    1911                 :            : 
    1912                 : 3559710000 :   if (GET_CODE (x) == COND_EXEC)
    1913                 :          0 :     x = COND_EXEC_CODE (x);
    1914                 :            : 
    1915                 : 3559710000 :   if (GET_CODE (x) == SET || GET_CODE (x) == CLOBBER)
    1916                 :            :     {
    1917                 : 2573260000 :       rtx dest = SET_DEST (x);
    1918                 :            : 
    1919                 : 2585140000 :       while ((GET_CODE (dest) == SUBREG
    1920                 :   11298500 :               && (!REG_P (SUBREG_REG (dest))
    1921                 :   11298500 :                   || REGNO (SUBREG_REG (dest)) >= FIRST_PSEUDO_REGISTER))
    1922                 : 2573840000 :              || GET_CODE (dest) == ZERO_EXTRACT
    1923                 : 5158830000 :              || GET_CODE (dest) == STRICT_LOW_PART)
    1924                 :   11880900 :         dest = XEXP (dest, 0);
    1925                 :            : 
    1926                 :            :       /* If we have a PARALLEL, SET_DEST is a list of EXPR_LIST expressions,
    1927                 :            :          each of whose first operand is a register.  */
    1928                 : 2573260000 :       if (GET_CODE (dest) == PARALLEL)
    1929                 :            :         {
    1930                 :    1010200 :           for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
    1931                 :     653381 :             if (XEXP (XVECEXP (dest, 0, i), 0) != 0)
    1932                 :     653381 :               (*fun) (XEXP (XVECEXP (dest, 0, i), 0), x, data);
    1933                 :            :         }
    1934                 :            :       else
    1935                 : 2572900000 :         (*fun) (dest, x, data);
    1936                 :            :     }
    1937                 :            : 
    1938                 :  986455000 :   else if (GET_CODE (x) == PARALLEL)
    1939                 : 1050370000 :     for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
    1940                 :  709985000 :       note_pattern_stores (XVECEXP (x, 0, i), fun, data);
    1941                 : 3559710000 : }
    1942                 :            : 
    1943                 :            : /* Same, but for an instruction.  If the instruction is a call, include
    1944                 :            :    any CLOBBERs in its CALL_INSN_FUNCTION_USAGE.  */
    1945                 :            : 
    1946                 :            : void
    1947                 : 2035330000 : note_stores (const rtx_insn *insn,
    1948                 :            :              void (*fun) (rtx, const_rtx, void *), void *data)
    1949                 :            : {
    1950                 : 2035330000 :   if (CALL_P (insn))
    1951                 :  111195000 :     for (rtx link = CALL_INSN_FUNCTION_USAGE (insn);
    1952                 :  293517000 :          link; link = XEXP (link, 1))
    1953                 :  182322000 :       if (GET_CODE (XEXP (link, 0)) == CLOBBER)
    1954                 :    3310250 :         note_pattern_stores (XEXP (link, 0), fun, data);
    1955                 : 2035330000 :   note_pattern_stores (PATTERN (insn), fun, data);
    1956                 : 2035330000 : }
    1957                 :            : 
    1958                 :            : /* Like notes_stores, but call FUN for each expression that is being
    1959                 :            :    referenced in PBODY, a pointer to the PATTERN of an insn.  We only call
    1960                 :            :    FUN for each expression, not any interior subexpressions.  FUN receives a
    1961                 :            :    pointer to the expression and the DATA passed to this function.
    1962                 :            : 
    1963                 :            :    Note that this is not quite the same test as that done in reg_referenced_p
    1964                 :            :    since that considers something as being referenced if it is being
    1965                 :            :    partially set, while we do not.  */
    1966                 :            : 
    1967                 :            : void
    1968                 :  694599000 : note_uses (rtx *pbody, void (*fun) (rtx *, void *), void *data)
    1969                 :            : {
    1970                 :  694599000 :   rtx body = *pbody;
    1971                 :  694599000 :   int i;
    1972                 :            : 
    1973                 :  694599000 :   switch (GET_CODE (body))
    1974                 :            :     {
    1975                 :          0 :     case COND_EXEC:
    1976                 :          0 :       (*fun) (&COND_EXEC_TEST (body), data);
    1977                 :          0 :       note_uses (&COND_EXEC_CODE (body), fun, data);
    1978                 :          0 :       return;
    1979                 :            : 
    1980                 :   57026200 :     case PARALLEL:
    1981                 :  178230000 :       for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
    1982                 :  121203000 :         note_uses (&XVECEXP (body, 0, i), fun, data);
    1983                 :            :       return;
    1984                 :            : 
    1985                 :          0 :     case SEQUENCE:
    1986                 :          0 :       for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
    1987                 :          0 :         note_uses (&PATTERN (XVECEXP (body, 0, i)), fun, data);
    1988                 :            :       return;
    1989                 :            : 
    1990                 :    3973810 :     case USE:
    1991                 :    3973810 :       (*fun) (&XEXP (body, 0), data);
    1992                 :    3973810 :       return;
    1993                 :            : 
    1994                 :     218670 :     case ASM_OPERANDS:
    1995                 :     281845 :       for (i = ASM_OPERANDS_INPUT_LENGTH (body) - 1; i >= 0; i--)
    1996                 :      63175 :         (*fun) (&ASM_OPERANDS_INPUT (body, i), data);
    1997                 :            :       return;
    1998                 :            : 
    1999                 :      84270 :     case TRAP_IF:
    2000                 :      84270 :       (*fun) (&TRAP_CONDITION (body), data);
    2001                 :      84270 :       return;
    2002                 :            : 
    2003                 :       8767 :     case PREFETCH:
    2004                 :       8767 :       (*fun) (&XEXP (body, 0), data);
    2005                 :       8767 :       return;
    2006                 :            : 
    2007                 :    2376870 :     case UNSPEC:
    2008                 :    2376870 :     case UNSPEC_VOLATILE:
    2009                 :    4775280 :       for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
    2010                 :    2398410 :         (*fun) (&XVECEXP (body, 0, i), data);
    2011                 :            :       return;
    2012                 :            : 
    2013                 :   54204800 :     case CLOBBER:
    2014                 :   54204800 :       if (MEM_P (XEXP (body, 0)))
    2015                 :    2269950 :         (*fun) (&XEXP (XEXP (body, 0), 0), data);
    2016                 :            :       return;
    2017                 :            : 
    2018                 :  355077000 :     case SET:
    2019                 :  355077000 :       {
    2020                 :  355077000 :         rtx dest = SET_DEST (body);
    2021                 :            : 
    2022                 :            :         /* For sets we replace everything in source plus registers in memory
    2023                 :            :            expression in store and operands of a ZERO_EXTRACT.  */
    2024                 :  355077000 :         (*fun) (&SET_SRC (body), data);
    2025                 :            : 
    2026                 :  355077000 :         if (GET_CODE (dest) == ZERO_EXTRACT)
    2027                 :            :           {
    2028                 :      22219 :             (*fun) (&XEXP (dest, 1), data);
    2029                 :      22219 :             (*fun) (&XEXP (dest, 2), data);
    2030                 :            :           }
    2031                 :            : 
    2032                 :  356736000 :         while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART)
    2033                 :    1658420 :           dest = XEXP (dest, 0);
    2034                 :            : 
    2035                 :  355077000 :         if (MEM_P (dest))
    2036                 :   71370500 :           (*fun) (&XEXP (dest, 0), data);
    2037                 :            :       }
    2038                 :            :       return;
    2039                 :            : 
    2040                 :  221628000 :     default:
    2041                 :            :       /* All the other possibilities never store.  */
    2042                 :  221628000 :       (*fun) (pbody, data);
    2043                 :  221628000 :       return;
    2044                 :            :     }
    2045                 :            : }
    2046                 :            : 
    2047                 :            : /* Return nonzero if X's old contents don't survive after INSN.
    2048                 :            :    This will be true if X is (cc0) or if X is a register and
    2049                 :            :    X dies in INSN or because INSN entirely sets X.
    2050                 :            : 
    2051                 :            :    "Entirely set" means set directly and not through a SUBREG, or
    2052                 :            :    ZERO_EXTRACT, so no trace of the old contents remains.
    2053                 :            :    Likewise, REG_INC does not count.
    2054                 :            : 
    2055                 :            :    REG may be a hard or pseudo reg.  Renumbering is not taken into account,
    2056                 :            :    but for this use that makes no difference, since regs don't overlap
    2057                 :            :    during their lifetimes.  Therefore, this function may be used
    2058                 :            :    at any time after deaths have been computed.
    2059                 :            : 
    2060                 :            :    If REG is a hard reg that occupies multiple machine registers, this
    2061                 :            :    function will only return 1 if each of those registers will be replaced
    2062                 :            :    by INSN.  */
    2063                 :            : 
    2064                 :            : int
    2065                 :   66786000 : dead_or_set_p (const rtx_insn *insn, const_rtx x)
    2066                 :            : {
    2067                 :   66786000 :   unsigned int regno, end_regno;
    2068                 :   66786000 :   unsigned int i;
    2069                 :            : 
    2070                 :            :   /* Can't use cc0_rtx below since this file is used by genattrtab.c.  */
    2071                 :   66786000 :   if (GET_CODE (x) == CC0)
    2072                 :            :     return 1;
    2073                 :            : 
    2074                 :   66786000 :   gcc_assert (REG_P (x));
    2075                 :            : 
    2076                 :   66786000 :   regno = REGNO (x);
    2077                 :   66786000 :   end_regno = END_REGNO (x);
    2078                 :  119126000 :   for (i = regno; i < end_regno; i++)
    2079                 :   66787000 :     if (! dead_or_set_regno_p (insn, i))
    2080                 :            :       return 0;
    2081                 :            : 
    2082                 :            :   return 1;
    2083                 :            : }
    2084                 :            : 
    2085                 :            : /* Return TRUE iff DEST is a register or subreg of a register, is a
    2086                 :            :    complete rather than read-modify-write destination, and contains
    2087                 :            :    register TEST_REGNO.  */
    2088                 :            : 
    2089                 :            : static bool
    2090                 :   54619700 : covers_regno_no_parallel_p (const_rtx dest, unsigned int test_regno)
    2091                 :            : {
    2092                 :   54619700 :   unsigned int regno, endregno;
    2093                 :            : 
    2094                 :   54619700 :   if (GET_CODE (dest) == SUBREG && !read_modify_subreg_p (dest))
    2095                 :     126450 :     dest = SUBREG_REG (dest);
    2096                 :            : 
    2097                 :   54619700 :   if (!REG_P (dest))
    2098                 :            :     return false;
    2099                 :            : 
    2100                 :   50396100 :   regno = REGNO (dest);
    2101                 :   50396100 :   endregno = END_REGNO (dest);
    2102                 :   50396100 :   return (test_regno >= regno && test_regno < endregno);
    2103                 :            : }
    2104                 :            : 
    2105                 :            : /* Like covers_regno_no_parallel_p, but also handles PARALLELs where
    2106                 :            :    any member matches the covers_regno_no_parallel_p criteria.  */
    2107                 :            : 
    2108                 :            : static bool
    2109                 :   54619500 : covers_regno_p (const_rtx dest, unsigned int test_regno)
    2110                 :            : {
    2111                 :   54619500 :   if (GET_CODE (dest) == PARALLEL)
    2112                 :            :     {
    2113                 :            :       /* Some targets place small structures in registers for return
    2114                 :            :          values of functions, and those registers are wrapped in
    2115                 :            :          PARALLELs that we may see as the destination of a SET.  */
    2116                 :        376 :       int i;
    2117                 :            : 
    2118                 :        978 :       for (i = XVECLEN (dest, 0) - 1; i >= 0; i--)
    2119                 :            :         {
    2120                 :        602 :           rtx inner = XEXP (XVECEXP (dest, 0, i), 0);
    2121                 :        602 :           if (inner != NULL_RTX
    2122                 :        602 :               && covers_regno_no_parallel_p (inner, test_regno))
    2123                 :            :             return true;
    2124                 :            :         }
    2125                 :            : 
    2126                 :            :       return false;
    2127                 :            :     }
    2128                 :            :   else
    2129                 :   54619100 :     return covers_regno_no_parallel_p (dest, test_regno);
    2130                 :            : }
    2131                 :            : 
    2132                 :            : /* Utility function for dead_or_set_p to check an individual register. */
    2133                 :            : 
    2134                 :            : int
    2135                 :   68193300 : dead_or_set_regno_p (const rtx_insn *insn, unsigned int test_regno)
    2136                 :            : {
    2137                 :   68193300 :   const_rtx pattern;
    2138                 :            : 
    2139                 :            :   /* See if there is a death note for something that includes TEST_REGNO.  */
    2140                 :   68193300 :   if (find_regno_note (insn, REG_DEAD, test_regno))
    2141                 :            :     return 1;
    2142                 :            : 
    2143                 :   43262000 :   if (CALL_P (insn)
    2144                 :   43262000 :       && find_regno_fusage (insn, CLOBBER, test_regno))
    2145                 :            :     return 1;
    2146                 :            : 
    2147                 :   43262000 :   pattern = PATTERN (insn);
    2148                 :            : 
    2149                 :            :   /* If a COND_EXEC is not executed, the value survives.  */
    2150                 :   43262000 :   if (GET_CODE (pattern) == COND_EXEC)
    2151                 :            :     return 0;
    2152                 :            : 
    2153                 :   43262000 :   if (GET_CODE (pattern) == SET || GET_CODE (pattern) == CLOBBER)
    2154                 :   31820900 :     return covers_regno_p (SET_DEST (pattern), test_regno);
    2155                 :   11441100 :   else if (GET_CODE (pattern) == PARALLEL)
    2156                 :            :     {
    2157                 :   11293300 :       int i;
    2158                 :            : 
    2159                 :   26504100 :       for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
    2160                 :            :         {
    2161                 :   23005500 :           rtx body = XVECEXP (pattern, 0, i);
    2162                 :            : 
    2163                 :   23005500 :           if (GET_CODE (body) == COND_EXEC)
    2164                 :          0 :             body = COND_EXEC_CODE (body);
    2165                 :            : 
    2166                 :   23005500 :           if ((GET_CODE (body) == SET || GET_CODE (body) == CLOBBER)
    2167                 :   23005500 :               && covers_regno_p (SET_DEST (body), test_regno))
    2168                 :            :             return 1;
    2169                 :            :         }
    2170                 :            :     }
    2171                 :            : 
    2172                 :            :   return 0;
    2173                 :            : }
    2174                 :            : 
    2175                 :            : /* Return the reg-note of kind KIND in insn INSN, if there is one.
    2176                 :            :    If DATUM is nonzero, look for one whose datum is DATUM.  */
    2177                 :            : 
    2178                 :            : rtx
    2179                 : 5963930000 : find_reg_note (const_rtx insn, enum reg_note kind, const_rtx datum)
    2180                 :            : {
    2181                 : 5963930000 :   rtx link;
    2182                 :            : 
    2183                 : 5963930000 :   gcc_checking_assert (insn);
    2184                 :            : 
    2185                 :            :   /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN.  */
    2186                 : 5963930000 :   if (! INSN_P (insn))
    2187                 :            :     return 0;
    2188                 : 5890150000 :   if (datum == 0)
    2189                 :            :     {
    2190                 :11042800000 :       for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    2191                 : 6084740000 :         if (REG_NOTE_KIND (link) == kind)
    2192                 :  688029000 :           return link;
    2193                 :            :       return 0;
    2194                 :            :     }
    2195                 :            : 
    2196                 :  454293000 :   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    2197                 :  270992000 :     if (REG_NOTE_KIND (link) == kind && datum == XEXP (link, 0))
    2198                 :   60769900 :       return link;
    2199                 :            :   return 0;
    2200                 :            : }
    2201                 :            : 
    2202                 :            : /* Return the reg-note of kind KIND in insn INSN which applies to register
    2203                 :            :    number REGNO, if any.  Return 0 if there is no such reg-note.  Note that
    2204                 :            :    the REGNO of this NOTE need not be REGNO if REGNO is a hard register;
    2205                 :            :    it might be the case that the note overlaps REGNO.  */
    2206                 :            : 
    2207                 :            : rtx
    2208                 :  224765000 : find_regno_note (const_rtx insn, enum reg_note kind, unsigned int regno)
    2209                 :            : {
    2210                 :  224765000 :   rtx link;
    2211                 :            : 
    2212                 :            :   /* Ignore anything that is not an INSN, JUMP_INSN or CALL_INSN.  */
    2213                 :  224765000 :   if (! INSN_P (insn))
    2214                 :            :     return 0;
    2215                 :            : 
    2216                 :  332707000 :   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    2217                 :  204584000 :     if (REG_NOTE_KIND (link) == kind
    2218                 :            :         /* Verify that it is a register, so that scratch and MEM won't cause a
    2219                 :            :            problem here.  */
    2220                 :  139064000 :         && REG_P (XEXP (link, 0))
    2221                 :  139064000 :         && REGNO (XEXP (link, 0)) <= regno
    2222                 :  316709000 :         && END_REGNO (XEXP (link, 0)) > regno)
    2223                 :   95021400 :       return link;
    2224                 :            :   return 0;
    2225                 :            : }
    2226                 :            : 
    2227                 :            : /* Return a REG_EQUIV or REG_EQUAL note if insn has only a single set and
    2228                 :            :    has such a note.  */
    2229                 :            : 
    2230                 :            : rtx
    2231                 : 1014420000 : find_reg_equal_equiv_note (const_rtx insn)
    2232                 :            : {
    2233                 : 1014420000 :   rtx link;
    2234                 :            : 
    2235                 : 1014420000 :   if (!INSN_P (insn))
    2236                 :            :     return 0;
    2237                 :            : 
    2238                 : 1757250000 :   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    2239                 :  797299000 :     if (REG_NOTE_KIND (link) == REG_EQUAL
    2240                 :  797299000 :         || REG_NOTE_KIND (link) == REG_EQUIV)
    2241                 :            :       {
    2242                 :            :         /* FIXME: We should never have REG_EQUAL/REG_EQUIV notes on
    2243                 :            :            insns that have multiple sets.  Checking single_set to
    2244                 :            :            make sure of this is not the proper check, as explained
    2245                 :            :            in the comment in set_unique_reg_note.
    2246                 :            : 
    2247                 :            :            This should be changed into an assert.  */
    2248                 :   50702600 :         if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
    2249                 :            :           return 0;
    2250                 :   50702600 :         return link;
    2251                 :            :       }
    2252                 :            :   return NULL;
    2253                 :            : }
    2254                 :            : 
    2255                 :            : /* Check whether INSN is a single_set whose source is known to be
    2256                 :            :    equivalent to a constant.  Return that constant if so, otherwise
    2257                 :            :    return null.  */
    2258                 :            : 
    2259                 :            : rtx
    2260                 :    1543820 : find_constant_src (const rtx_insn *insn)
    2261                 :            : {
    2262                 :    1543820 :   rtx note, set, x;
    2263                 :            : 
    2264                 :    1543820 :   set = single_set (insn);
    2265                 :    1543820 :   if (set)
    2266                 :            :     {
    2267                 :    1543820 :       x = avoid_constant_pool_reference (SET_SRC (set));
    2268                 :    1543820 :       if (CONSTANT_P (x))
    2269                 :            :         return x;
    2270                 :            :     }
    2271                 :            : 
    2272                 :    1085240 :   note = find_reg_equal_equiv_note (insn);
    2273                 :    1085240 :   if (note && CONSTANT_P (XEXP (note, 0)))
    2274                 :        990 :     return XEXP (note, 0);
    2275                 :            : 
    2276                 :            :   return NULL_RTX;
    2277                 :            : }
    2278                 :            : 
    2279                 :            : /* Return true if DATUM, or any overlap of DATUM, of kind CODE is found
    2280                 :            :    in the CALL_INSN_FUNCTION_USAGE information of INSN.  */
    2281                 :            : 
    2282                 :            : int
    2283                 :   10057200 : find_reg_fusage (const_rtx insn, enum rtx_code code, const_rtx datum)
    2284                 :            : {
    2285                 :            :   /* If it's not a CALL_INSN, it can't possibly have a
    2286                 :            :      CALL_INSN_FUNCTION_USAGE field, so don't bother checking.  */
    2287                 :   10057200 :   if (!CALL_P (insn))
    2288                 :            :     return 0;
    2289                 :            : 
    2290                 :   10057200 :   gcc_assert (datum);
    2291                 :            : 
    2292                 :   10057200 :   if (!REG_P (datum))
    2293                 :            :     {
    2294                 :       6693 :       rtx link;
    2295                 :            : 
    2296                 :       6693 :       for (link = CALL_INSN_FUNCTION_USAGE (insn);
    2297                 :       8229 :            link;
    2298                 :       1536 :            link = XEXP (link, 1))
    2299                 :       1536 :         if (GET_CODE (XEXP (link, 0)) == code
    2300                 :       1536 :             && rtx_equal_p (datum, XEXP (XEXP (link, 0), 0)))
    2301                 :            :           return 1;
    2302                 :            :     }
    2303                 :            :   else
    2304                 :            :     {
    2305                 :   10050500 :       unsigned int regno = REGNO (datum);
    2306                 :            : 
    2307                 :            :       /* CALL_INSN_FUNCTION_USAGE information cannot contain references
    2308                 :            :          to pseudo registers, so don't bother checking.  */
    2309                 :            : 
    2310                 :   10050500 :       if (regno < FIRST_PSEUDO_REGISTER)
    2311                 :            :         {
    2312                 :    5755670 :           unsigned int end_regno = END_REGNO (datum);
    2313                 :    5755670 :           unsigned int i;
    2314                 :            : 
    2315                 :    6185520 :           for (i = regno; i < end_regno; i++)
    2316                 :    5755680 :             if (find_regno_fusage (insn, code, i))
    2317                 :            :               return 1;
    2318                 :            :         }
    2319                 :            :     }
    2320                 :            : 
    2321                 :            :   return 0;
    2322                 :            : }
    2323                 :            : 
    2324                 :            : /* Return true if REGNO, or any overlap of REGNO, of kind CODE is found
    2325                 :            :    in the CALL_INSN_FUNCTION_USAGE information of INSN.  */
    2326                 :            : 
    2327                 :            : int
    2328                 :    5903020 : find_regno_fusage (const_rtx insn, enum rtx_code code, unsigned int regno)
    2329                 :            : {
    2330                 :    5903020 :   rtx link;
    2331                 :            : 
    2332                 :            :   /* CALL_INSN_FUNCTION_USAGE information cannot contain references
    2333                 :            :      to pseudo registers, so don't bother checking.  */
    2334                 :            : 
    2335                 :    5903020 :   if (regno >= FIRST_PSEUDO_REGISTER
    2336                 :    5859660 :       || !CALL_P (insn) )
    2337                 :            :     return 0;
    2338                 :            : 
    2339                 :   14198700 :   for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
    2340                 :            :     {
    2341                 :   13666100 :       rtx op, reg;
    2342                 :            : 
    2343                 :   13666100 :       if (GET_CODE (op = XEXP (link, 0)) == code
    2344                 :   12754700 :           && REG_P (reg = XEXP (op, 0))
    2345                 :   12754700 :           && REGNO (reg) <= regno
    2346                 :   22978600 :           && END_REGNO (reg) > regno)
    2347                 :            :         return 1;
    2348                 :            :     }
    2349                 :            : 
    2350                 :            :   return 0;
    2351                 :            : }
    2352                 :            : 
    2353                 :            : 
    2354                 :            : /* Return true if KIND is an integer REG_NOTE.  */
    2355                 :            : 
    2356                 :            : static bool
    2357                 :  533619000 : int_reg_note_p (enum reg_note kind)
    2358                 :            : {
    2359                 :  533619000 :   return kind == REG_BR_PROB;
    2360                 :            : }
    2361                 :            : 
    2362                 :            : /* Allocate a register note with kind KIND and datum DATUM.  LIST is
    2363                 :            :    stored as the pointer to the next register note.  */
    2364                 :            : 
    2365                 :            : rtx
    2366                 :  530299000 : alloc_reg_note (enum reg_note kind, rtx datum, rtx list)
    2367                 :            : {
    2368                 :  530299000 :   rtx note;
    2369                 :            : 
    2370                 :  530299000 :   gcc_checking_assert (!int_reg_note_p (kind));
    2371                 :  530299000 :   switch (kind)
    2372                 :            :     {
    2373                 :      21457 :     case REG_CC_SETTER:
    2374                 :      21457 :     case REG_CC_USER:
    2375                 :      21457 :     case REG_LABEL_TARGET:
    2376                 :      21457 :     case REG_LABEL_OPERAND:
    2377                 :      21457 :     case REG_TM:
    2378                 :            :       /* These types of register notes use an INSN_LIST rather than an
    2379                 :            :          EXPR_LIST, so that copying is done right and dumps look
    2380                 :            :          better.  */
    2381                 :      21457 :       note = alloc_INSN_LIST (datum, list);
    2382                 :      21457 :       PUT_REG_NOTE_KIND (note, kind);
    2383                 :      21457 :       break;
    2384                 :            : 
    2385                 :  530278000 :     default:
    2386                 :  530278000 :       note = alloc_EXPR_LIST (kind, datum, list);
    2387                 :  530278000 :       break;
    2388                 :            :     }
    2389                 :            : 
    2390                 :  530299000 :   return note;
    2391                 :            : }
    2392                 :            : 
    2393                 :            : /* Add register note with kind KIND and datum DATUM to INSN.  */
    2394                 :            : 
    2395                 :            : void
    2396                 :  526291000 : add_reg_note (rtx insn, enum reg_note kind, rtx datum)
    2397                 :            : {
    2398                 :  526291000 :   REG_NOTES (insn) = alloc_reg_note (kind, datum, REG_NOTES (insn));
    2399                 :  526291000 : }
    2400                 :            : 
    2401                 :            : /* Add an integer register note with kind KIND and datum DATUM to INSN.  */
    2402                 :            : 
    2403                 :            : void
    2404                 :    3319690 : add_int_reg_note (rtx_insn *insn, enum reg_note kind, int datum)
    2405                 :            : {
    2406                 :    3319690 :   gcc_checking_assert (int_reg_note_p (kind));
    2407                 :    3319690 :   REG_NOTES (insn) = gen_rtx_INT_LIST ((machine_mode) kind,
    2408                 :            :                                        datum, REG_NOTES (insn));
    2409                 :    3319690 : }
    2410                 :            : 
    2411                 :            : /* Add a REG_ARGS_SIZE note to INSN with value VALUE.  */
    2412                 :            : 
    2413                 :            : void
    2414                 :    5568060 : add_args_size_note (rtx_insn *insn, poly_int64 value)
    2415                 :            : {
    2416                 :    5568060 :   gcc_checking_assert (!find_reg_note (insn, REG_ARGS_SIZE, NULL_RTX));
    2417                 :    8561130 :   add_reg_note (insn, REG_ARGS_SIZE, gen_int_mode (value, Pmode));
    2418                 :    5568060 : }
    2419                 :            : 
    2420                 :            : /* Add a register note like NOTE to INSN.  */
    2421                 :            : 
    2422                 :            : void
    2423                 :          0 : add_shallow_copy_of_reg_note (rtx_insn *insn, rtx note)
    2424                 :            : {
    2425                 :          0 :   if (GET_CODE (note) == INT_LIST)
    2426                 :          0 :     add_int_reg_note (insn, REG_NOTE_KIND (note), XINT (note, 0));
    2427                 :            :   else
    2428                 :          0 :     add_reg_note (insn, REG_NOTE_KIND (note), XEXP (note, 0));
    2429                 :          0 : }
    2430                 :            : 
    2431                 :            : /* Duplicate NOTE and return the copy.  */
    2432                 :            : rtx
    2433                 :    1430890 : duplicate_reg_note (rtx note)
    2434                 :            : {
    2435                 :    1430890 :   reg_note kind = REG_NOTE_KIND (note);
    2436                 :            : 
    2437                 :    1430890 :   if (GET_CODE (note) == INT_LIST)
    2438                 :     142944 :     return gen_rtx_INT_LIST ((machine_mode) kind, XINT (note, 0), NULL_RTX);
    2439                 :    1287940 :   else if (GET_CODE (note) == EXPR_LIST)
    2440                 :    1287940 :     return alloc_reg_note (kind, copy_insn_1 (XEXP (note, 0)), NULL_RTX);
    2441                 :            :   else
    2442                 :          0 :     return alloc_reg_note (kind, XEXP (note, 0), NULL_RTX);
    2443                 :            : }
    2444                 :            : 
    2445                 :            : /* Remove register note NOTE from the REG_NOTES of INSN.  */
    2446                 :            : 
    2447                 :            : void
    2448                 :    5187000 : remove_note (rtx_insn *insn, const_rtx note)
    2449                 :            : {
    2450                 :    5187000 :   rtx link;
    2451                 :            : 
    2452                 :    5187000 :   if (note == NULL_RTX)
    2453                 :            :     return;
    2454                 :            : 
    2455                 :    4686380 :   if (REG_NOTES (insn) == note)
    2456                 :    4463830 :     REG_NOTES (insn) = XEXP (note, 1);
    2457                 :            :   else
    2458                 :     663435 :     for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
    2459                 :     663435 :       if (XEXP (link, 1) == note)
    2460                 :            :         {
    2461                 :     222552 :           XEXP (link, 1) = XEXP (note, 1);
    2462                 :     222552 :           break;
    2463                 :            :         }
    2464                 :            : 
    2465                 :    4686380 :   switch (REG_NOTE_KIND (note))
    2466                 :            :     {
    2467                 :    1498090 :     case REG_EQUAL:
    2468                 :    1498090 :     case REG_EQUIV:
    2469                 :    1498090 :       df_notes_rescan (insn);
    2470                 :    1498090 :       break;
    2471                 :            :     default:
    2472                 :            :       break;
    2473                 :            :     }
    2474                 :            : }
    2475                 :            : 
    2476                 :            : /* Remove REG_EQUAL and/or REG_EQUIV notes if INSN has such notes.
    2477                 :            :    Return true if any note has been removed.  */
    2478                 :            : 
    2479                 :            : bool
    2480                 :      10073 : remove_reg_equal_equiv_notes (rtx_insn *insn)
    2481                 :            : {
    2482                 :      10073 :   rtx *loc;
    2483                 :      10073 :   bool ret = false;
    2484                 :            : 
    2485                 :      10073 :   loc = &REG_NOTES (insn);
    2486                 :      10252 :   while (*loc)
    2487                 :            :     {
    2488                 :        179 :       enum reg_note kind = REG_NOTE_KIND (*loc);
    2489                 :        179 :       if (kind == REG_EQUAL || kind == REG_EQUIV)
    2490                 :            :         {
    2491                 :          0 :           *loc = XEXP (*loc, 1);
    2492                 :          0 :           ret = true;
    2493                 :            :         }
    2494                 :            :       else
    2495                 :        179 :         loc = &XEXP (*loc, 1);
    2496                 :            :     }
    2497                 :      10073 :   return ret;
    2498                 :            : }
    2499                 :            : 
    2500                 :            : /* Remove all REG_EQUAL and REG_EQUIV notes referring to REGNO.  */
    2501                 :            : 
    2502                 :            : void
    2503                 :    2812020 : remove_reg_equal_equiv_notes_for_regno (unsigned int regno)
    2504                 :            : {
    2505                 :    2812020 :   df_ref eq_use;
    2506                 :            : 
    2507                 :    2812020 :   if (!df)
    2508                 :            :     return;
    2509                 :            : 
    2510                 :            :   /* This loop is a little tricky.  We cannot just go down the chain because
    2511                 :            :      it is being modified by some actions in the loop.  So we just iterate
    2512                 :            :      over the head.  We plan to drain the list anyway.  */
    2513                 :    2904230 :   while ((eq_use = DF_REG_EQ_USE_CHAIN (regno)) != NULL)
    2514                 :            :     {
    2515                 :      92210 :       rtx_insn *insn = DF_REF_INSN (eq_use);
    2516                 :      92210 :       rtx note = find_reg_equal_equiv_note (insn);
    2517                 :            : 
    2518                 :            :       /* This assert is generally triggered when someone deletes a REG_EQUAL
    2519                 :            :          or REG_EQUIV note by hacking the list manually rather than calling
    2520                 :            :          remove_note.  */
    2521                 :      92210 :       gcc_assert (note);
    2522                 :            : 
    2523                 :      92210 :       remove_note (insn, note);
    2524                 :            :     }
    2525                 :            : }
    2526                 :            : 
    2527                 :            : /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
    2528                 :            :    return 1 if it is found.  A simple equality test is used to determine if
    2529                 :            :    NODE matches.  */
    2530                 :            : 
    2531                 :            : bool
    2532                 :          0 : in_insn_list_p (const rtx_insn_list *listp, const rtx_insn *node)
    2533                 :            : {
    2534                 :          0 :   const_rtx x;
    2535                 :            : 
    2536                 :          0 :   for (x = listp; x; x = XEXP (x, 1))
    2537                 :          0 :     if (node == XEXP (x, 0))
    2538                 :            :       return true;
    2539                 :            : 
    2540                 :            :   return false;
    2541                 :            : }
    2542                 :            : 
    2543                 :            : /* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
    2544                 :            :    remove that entry from the list if it is found.
    2545                 :            : 
    2546                 :            :    A simple equality test is used to determine if NODE matches.  */
    2547                 :            : 
    2548                 :            : void
    2549                 :          0 : remove_node_from_expr_list (const_rtx node, rtx_expr_list **listp)
    2550                 :            : {
    2551                 :          0 :   rtx_expr_list *temp = *listp;
    2552                 :          0 :   rtx_expr_list *prev = NULL;
    2553                 :            : 
    2554                 :          0 :   while (temp)
    2555                 :            :     {
    2556                 :          0 :       if (node == temp->element ())
    2557                 :            :         {
    2558                 :            :           /* Splice the node out of the list.  */
    2559                 :          0 :           if (prev)
    2560                 :          0 :             XEXP (prev, 1) = temp->next ();
    2561                 :            :           else
    2562                 :          0 :             *listp = temp->next ();
    2563                 :            : 
    2564                 :          0 :           return;
    2565                 :            :         }
    2566                 :            : 
    2567                 :          0 :       prev = temp;
    2568                 :          0 :       temp = temp->next ();
    2569                 :            :     }
    2570                 :            : }
    2571                 :            : 
    2572                 :            : /* Search LISTP (an INSN_LIST) for an entry whose first operand is NODE and
    2573                 :            :    remove that entry from the list if it is found.
    2574                 :            : 
    2575                 :            :    A simple equality test is used to determine if NODE matches.  */
    2576                 :            : 
    2577                 :            : void
    2578                 :    4652090 : remove_node_from_insn_list (const rtx_insn *node, rtx_insn_list **listp)
    2579                 :            : {
    2580                 :    4652090 :   rtx_insn_list *temp = *listp;
    2581                 :    4652090 :   rtx_insn_list *prev = NULL;
    2582                 :            : 
    2583                 :    4667920 :   while (temp)
    2584                 :            :     {
    2585                 :      15852 :       if (node == temp->insn ())
    2586                 :            :         {
    2587                 :            :           /* Splice the node out of the list.  */
    2588                 :         19 :           if (prev)
    2589                 :          0 :             XEXP (prev, 1) = temp->next ();
    2590                 :            :           else
    2591                 :         19 :             *listp = temp->next ();
    2592                 :            : 
    2593                 :         19 :           return;
    2594                 :            :         }
    2595                 :            : 
    2596                 :      15833 :       prev = temp;
    2597                 :    4683750 :       temp = temp->next ();
    2598                 :            :     }
    2599                 :            : }
    2600                 :            : 
    2601                 :            : /* Nonzero if X contains any volatile instructions.  These are instructions
    2602                 :            :    which may cause unpredictable machine state instructions, and thus no
    2603                 :            :    instructions or register uses should be moved or combined across them.
    2604                 :            :    This includes only volatile asms and UNSPEC_VOLATILE instructions.  */
    2605                 :            : 
    2606                 :            : int
    2607                 :  399727000 : volatile_insn_p (const_rtx x)
    2608                 :            : {
    2609                 :  399727000 :   const RTX_CODE code = GET_CODE (x);
    2610                 :  399727000 :   switch (code)
    2611                 :            :     {
    2612                 :            :     case LABEL_REF:
    2613                 :            :     case SYMBOL_REF:
    2614                 :            :     case CONST:
    2615                 :            :     CASE_CONST_ANY:
    2616                 :            :     case CC0:
    2617                 :            :     case PC:
    2618                 :            :     case REG:
    2619                 :            :     case SCRATCH:
    2620                 :            :     case CLOBBER:
    2621                 :            :     case ADDR_VEC:
    2622                 :            :     case ADDR_DIFF_VEC:
    2623                 :            :     case CALL:
    2624                 :            :     case MEM:
    2625                 :            :       return 0;
    2626                 :            : 
    2627                 :     295463 :     case UNSPEC_VOLATILE:
    2628                 :     295463 :       return 1;
    2629                 :            : 
    2630                 :     198232 :     case ASM_INPUT:
    2631                 :     198232 :     case ASM_OPERANDS:
    2632                 :     198232 :       if (MEM_VOLATILE_P (x))
    2633                 :            :         return 1;
    2634                 :            : 
    2635                 :  186784000 :     default:
    2636                 :  186784000 :       break;
    2637                 :            :     }
    2638                 :            : 
    2639                 :            :   /* Recursively scan the operands of this expression.  */
    2640                 :            : 
    2641                 :  186784000 :   {
    2642                 :  186784000 :     const char *const fmt = GET_RTX_FORMAT (code);
    2643                 :  186784000 :     int i;
    2644                 :            : 
    2645                 :  511507000 :     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    2646                 :            :       {
    2647                 :  324965000 :         if (fmt[i] == 'e')
    2648                 :            :           {
    2649                 :  251618000 :             if (volatile_insn_p (XEXP (x, i)))
    2650                 :            :               return 1;
    2651                 :            :           }
    2652                 :   73347000 :         else if (fmt[i] == 'E')
    2653                 :            :           {
    2654                 :            :             int j;
    2655                 :   44060800 :             for (j = 0; j < XVECLEN (x, i); j++)
    2656                 :   30244400 :               if (volatile_insn_p (XVECEXP (x, i, j)))
    2657                 :            :                 return 1;
    2658                 :            :           }
    2659                 :            :       }
    2660                 :            :   }
    2661                 :            :   return 0;
    2662                 :            : }
    2663                 :            : 
    2664                 :            : /* Nonzero if X contains any volatile memory references
    2665                 :            :    UNSPEC_VOLATILE operations or volatile ASM_OPERANDS expressions.  */
    2666                 :            : 
    2667                 :            : int
    2668                 : 2598270000 : volatile_refs_p (const_rtx x)
    2669                 :            : {
    2670                 : 2598270000 :   const RTX_CODE code = GET_CODE (x);
    2671                 : 2598270000 :   switch (code)
    2672                 :            :     {
    2673                 :            :     case LABEL_REF:
    2674                 :            :     case SYMBOL_REF:
    2675                 :            :     case CONST:
    2676                 :            :     CASE_CONST_ANY:
    2677                 :            :     case CC0:
    2678                 :            :     case PC:
    2679                 :            :     case REG:
    2680                 :            :     case SCRATCH:
    2681                 :            :     case CLOBBER:
    2682                 :            :     case ADDR_VEC:
    2683                 :            :     case ADDR_DIFF_VEC:
    2684                 :            :       return 0;
    2685                 :            : 
    2686                 :    1813540 :     case UNSPEC_VOLATILE:
    2687                 :    1813540 :       return 1;
    2688                 :            : 
    2689                 :  212058000 :     case MEM:
    2690                 :  212058000 :     case ASM_INPUT:
    2691                 :  212058000 :     case ASM_OPERANDS:
    2692                 :  212058000 :       if (MEM_VOLATILE_P (x))
    2693                 :            :         return 1;
    2694                 :            : 
    2695                 : 1132580000 :     default:
    2696                 : 1132580000 :       break;
    2697                 :            :     }
    2698                 :            : 
    2699                 :            :   /* Recursively scan the operands of this expression.  */
    2700                 :            : 
    2701                 : 1132580000 :   {
    2702                 : 1132580000 :     const char *const fmt = GET_RTX_FORMAT (code);
    2703                 : 1132580000 :     int i;
    2704                 :            : 
    2705                 : 3318760000 :     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    2706                 :            :       {
    2707                 : 2197460000 :         if (fmt[i] == 'e')
    2708                 :            :           {
    2709                 : 1942770000 :             if (volatile_refs_p (XEXP (x, i)))
    2710                 :            :               return 1;
    2711                 :            :           }
    2712                 :  254689000 :         else if (fmt[i] == 'E')
    2713                 :            :           {
    2714                 :            :             int j;
    2715                 :   85662000 :             for (j = 0; j < XVECLEN (x, i); j++)
    2716                 :   58247000 :               if (volatile_refs_p (XVECEXP (x, i, j)))
    2717                 :            :                 return 1;
    2718                 :            :           }
    2719                 :            :       }
    2720                 :            :   }
    2721                 :            :   return 0;
    2722                 :            : }
    2723                 :            : 
    2724                 :            : /* Similar to above, except that it also rejects register pre- and post-
    2725                 :            :    incrementing.  */
    2726                 :            : 
    2727                 :            : int
    2728                 : 3115800000 : side_effects_p (const_rtx x)
    2729                 :            : {
    2730                 : 3115800000 :   const RTX_CODE code = GET_CODE (x);
    2731                 : 3115800000 :   switch (code)
    2732                 :            :     {
    2733                 :            :     case LABEL_REF:
    2734                 :            :     case SYMBOL_REF:
    2735                 :            :     case CONST:
    2736                 :            :     CASE_CONST_ANY:
    2737                 :            :     case CC0:
    2738                 :            :     case PC:
    2739                 :            :     case REG:
    2740                 :            :     case SCRATCH:
    2741                 :            :     case ADDR_VEC:
    2742                 :            :     case ADDR_DIFF_VEC:
    2743                 :            :     case VAR_LOCATION:
    2744                 :            :       return 0;
    2745                 :            : 
    2746                 :   38613100 :     case CLOBBER:
    2747                 :            :       /* Reject CLOBBER with a non-VOID mode.  These are made by combine.c
    2748                 :            :          when some combination can't be done.  If we see one, don't think
    2749                 :            :          that we can simplify the expression.  */
    2750                 :   38613100 :       return (GET_MODE (x) != VOIDmode);
    2751                 :            : 
    2752                 :   33116700 :     case PRE_INC:
    2753                 :   33116700 :     case PRE_DEC:
    2754                 :   33116700 :     case POST_INC:
    2755                 :   33116700 :     case POST_DEC:
    2756                 :   33116700 :     case PRE_MODIFY:
    2757                 :   33116700 :     case POST_MODIFY:
    2758                 :   33116700 :     case CALL:
    2759                 :   33116700 :     case UNSPEC_VOLATILE:
    2760                 :   33116700 :       return 1;
    2761                 :            : 
    2762                 :  220070000 :     case MEM:
    2763                 :  220070000 :     case ASM_INPUT:
    2764                 :  220070000 :     case ASM_OPERANDS:
    2765                 :  220070000 :       if (MEM_VOLATILE_P (x))
    2766                 :            :         return 1;
    2767                 :            : 
    2768                 : 1123860000 :     default:
    2769                 : 1123860000 :       break;
    2770                 :            :     }
    2771                 :            : 
    2772                 :            :   /* Recursively scan the operands of this expression.  */
    2773                 :            : 
    2774                 : 1123860000 :   {
    2775                 : 1123860000 :     const char *fmt = GET_RTX_FORMAT (code);
    2776                 : 1123860000 :     int i;
    2777                 :            : 
    2778                 : 3328770000 :     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    2779                 :            :       {
    2780                 : 2246260000 :         if (fmt[i] == 'e')
    2781                 :            :           {
    2782                 : 1930190000 :             if (side_effects_p (XEXP (x, i)))
    2783                 :            :               return 1;
    2784                 :            :           }
    2785                 :  316071000 :         else if (fmt[i] == 'E')
    2786                 :            :           {
    2787                 :            :             int j;
    2788                 :  167384000 :             for (j = 0; j < XVECLEN (x, i); j++)
    2789                 :  108243000 :               if (side_effects_p (XVECEXP (x, i, j)))
    2790                 :            :                 return 1;
    2791                 :            :           }
    2792                 :            :       }
    2793                 :            :   }
    2794                 :            :   return 0;
    2795                 :            : }
    2796                 :            : 
    2797                 :            : /* Return nonzero if evaluating rtx X might cause a trap.
    2798                 :            :    FLAGS controls how to consider MEMs.  A nonzero means the context
    2799                 :            :    of the access may have changed from the original, such that the
    2800                 :            :    address may have become invalid.  */
    2801                 :            : 
    2802                 :            : int
    2803                 : 6296800000 : may_trap_p_1 (const_rtx x, unsigned flags)
    2804                 :            : {
    2805                 : 6296800000 :   int i;
    2806                 : 6296800000 :   enum rtx_code code;
    2807                 : 6296800000 :   const char *fmt;
    2808                 :            : 
    2809                 :            :   /* We make no distinction currently, but this function is part of
    2810                 :            :      the internal target-hooks ABI so we keep the parameter as
    2811                 :            :      "unsigned flags".  */
    2812                 : 6296800000 :   bool code_changed = flags != 0;
    2813                 :            : 
    2814                 : 6296800000 :   if (x == 0)
    2815                 :            :     return 0;
    2816                 : 6296800000 :   code = GET_CODE (x);
    2817                 : 6296800000 :   switch (code)
    2818                 :            :     {
    2819                 :            :       /* Handle these cases quickly.  */
    2820                 :            :     CASE_CONST_ANY:
    2821                 :            :     case SYMBOL_REF:
    2822                 :            :     case LABEL_REF:
    2823                 :            :     case CONST:
    2824                 :            :     case PC:
    2825                 :            :     case CC0:
    2826                 :            :     case REG:
    2827                 :            :     case SCRATCH:
    2828                 :            :       return 0;
    2829                 :            : 
    2830                 :    3193320 :     case UNSPEC:
    2831                 :    3193320 :       return targetm.unspec_may_trap_p (x, flags);
    2832                 :            : 
    2833                 :   20001900 :     case UNSPEC_VOLATILE:
    2834                 :   20001900 :     case ASM_INPUT:
    2835                 :   20001900 :     case TRAP_IF:
    2836                 :   20001900 :       return 1;
    2837                 :            : 
    2838                 :     239332 :     case ASM_OPERANDS:
    2839                 :     239332 :       return MEM_VOLATILE_P (x);
    2840                 :            : 
    2841                 :            :       /* Memory ref can trap unless it's a static var or a stack slot.  */
    2842                 :  836583000 :     case MEM:
    2843                 :            :       /* Recognize specific pattern of stack checking probes.  */
    2844                 :  836583000 :       if (flag_stack_check
    2845                 :        332 :           && MEM_VOLATILE_P (x)
    2846                 :  836583000 :           && XEXP (x, 0) == stack_pointer_rtx)
    2847                 :            :         return 1;
    2848                 :  836583000 :       if (/* MEM_NOTRAP_P only relates to the actual position of the memory
    2849                 :            :              reference; moving it out of context such as when moving code
    2850                 :            :              when optimizing, might cause its address to become invalid.  */
    2851                 :            :           code_changed
    2852                 :  836583000 :           || !MEM_NOTRAP_P (x))
    2853                 :            :         {
    2854                 :  410758000 :           poly_int64 size = MEM_SIZE_KNOWN_P (x) ? MEM_SIZE (x) : -1;
    2855                 :  326035000 :           return rtx_addr_can_trap_p_1 (XEXP (x, 0), 0, size,
    2856                 :  326035000 :                                         GET_MODE (x), code_changed);
    2857                 :            :         }
    2858                 :            : 
    2859                 :            :       return 0;
    2860                 :            : 
    2861                 :            :       /* Division by a non-constant might trap.  */
    2862                 :     613156 :     case DIV:
    2863                 :     613156 :     case MOD:
    2864                 :     613156 :     case UDIV:
    2865                 :     613156 :     case UMOD:
    2866                 :     613156 :       if (HONOR_SNANS (x))
    2867                 :            :         return 1;
    2868                 :     612735 :       if (FLOAT_MODE_P (GET_MODE (x)))
    2869                 :     242461 :         return flag_trapping_math;
    2870                 :     370274 :       if (!CONSTANT_P (XEXP (x, 1)) || (XEXP (x, 1) == const0_rtx))
    2871                 :            :         return 1;
    2872                 :      38636 :       if (GET_CODE (XEXP (x, 1)) == CONST_VECTOR)
    2873                 :            :         {
    2874                 :            :           /* For CONST_VECTOR, return 1 if any element is or might be zero.  */
    2875                 :          0 :           unsigned int n_elts;
    2876                 :          0 :           rtx op = XEXP (x, 1);
    2877                 :          0 :           if (!GET_MODE_NUNITS (GET_MODE (op)).is_constant (&n_elts))
    2878                 :            :             {
    2879                 :            :               if (!CONST_VECTOR_DUPLICATE_P (op))
    2880                 : 6296800000 :                 return 1;
    2881                 :            :               for (unsigned i = 0; i < (unsigned int) XVECLEN (op, 0); i++)
    2882                 :            :                 if (CONST_VECTOR_ENCODED_ELT (op, i) == const0_rtx)
    2883                 :            :                   return 1;
    2884                 :            :             }
    2885                 :            :           else
    2886                 :          0 :             for (unsigned i = 0; i < n_elts; i++)
    2887                 :          0 :               if (CONST_VECTOR_ELT (op, i) == const0_rtx)
    2888                 :            :                 return 1;
    2889                 :            :         }
    2890                 :            :       break;
    2891                 :            : 
    2892                 :       4792 :     case EXPR_LIST:
    2893                 :            :       /* An EXPR_LIST is used to represent a function call.  This
    2894                 :            :          certainly may trap.  */
    2895                 :       4792 :       return 1;
    2896                 :            : 
    2897                 :  126522000 :     case GE:
    2898                 :  126522000 :     case GT:
    2899                 :  126522000 :     case LE:
    2900                 :  126522000 :     case LT:
    2901                 :  126522000 :     case LTGT:
    2902                 :  126522000 :     case COMPARE:
    2903                 :            :       /* Some floating point comparisons may trap.  */
    2904                 :  126522000 :       if (!flag_trapping_math)
    2905                 :            :         break;
    2906                 :            :       /* ??? There is no machine independent way to check for tests that trap
    2907                 :            :          when COMPARE is used, though many targets do make this distinction.
    2908                 :            :          For instance, sparc uses CCFPE for compares which generate exceptions
    2909                 :            :          and CCFP for compares which do not generate exceptions.  */
    2910                 :  125307000 :       if (HONOR_NANS (x))
    2911                 :            :         return 1;
    2912                 :            :       /* But often the compare has some CC mode, so check operand
    2913                 :            :          modes as well.  */
    2914                 :  125301000 :       if (HONOR_NANS (XEXP (x, 0))
    2915                 :  125301000 :           || HONOR_NANS (XEXP (x, 1)))
    2916                 :    1225550 :         return 1;
    2917                 :            :       break;
    2918                 :            : 
    2919                 :   22820300 :     case EQ:
    2920                 :   22820300 :     case NE:
    2921                 :   22820300 :       if (HONOR_SNANS (x))
    2922                 :            :         return 1;
    2923                 :            :       /* Often comparison is CC mode, so check operand modes.  */
    2924                 :   22820300 :       if (HONOR_SNANS (XEXP (x, 0))
    2925                 :   22820300 :           || HONOR_SNANS (XEXP (x, 1)))
    2926                 :          0 :         return 1;
    2927                 :            :       break;
    2928                 :            : 
    2929                 :     273436 :     case FIX:
    2930                 :            :       /* Conversion of floating point might trap.  */
    2931                 :     273436 :       if (flag_trapping_math && HONOR_NANS (XEXP (x, 0)))
    2932                 :            :         return 1;
    2933                 :            :       break;
    2934                 :            : 
    2935                 :            :     case NEG:
    2936                 :            :     case ABS:
    2937                 :            :     case SUBREG:
    2938                 :            :     case VEC_MERGE:
    2939                 :            :     case VEC_SELECT:
    2940                 :            :     case VEC_CONCAT:
    2941                 :            :     case VEC_DUPLICATE:
    2942                 :            :       /* These operations don't trap even with floating point.  */
    2943                 :            :       break;
    2944                 :            : 
    2945                 : 2352590000 :     default:
    2946                 :            :       /* Any floating arithmetic may trap.  */
    2947                 : 2352590000 :       if (FLOAT_MODE_P (GET_MODE (x)) && flag_trapping_math)
    2948                 :            :         return 1;
    2949                 :            :     }
    2950                 :            : 
    2951                 : 2540290000 :   fmt = GET_RTX_FORMAT (code);
    2952                 : 6922020000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    2953                 :            :     {
    2954                 : 4523020000 :       if (fmt[i] == 'e')
    2955                 :            :         {
    2956                 : 4228270000 :           if (may_trap_p_1 (XEXP (x, i), flags))
    2957                 :            :             return 1;
    2958                 :            :         }
    2959                 :  294745000 :       else if (fmt[i] == 'E')
    2960                 :            :         {
    2961                 :            :           int j;
    2962                 :  651594000 :           for (j = 0; j < XVECLEN (x, i); j++)
    2963                 :  448724000 :             if (may_trap_p_1 (XVECEXP (x, i, j), flags))
    2964                 :            :               return 1;
    2965                 :            :         }
    2966                 :            :     }
    2967                 :            :   return 0;
    2968                 :            : }
    2969                 :            : 
    2970                 :            : /* Return nonzero if evaluating rtx X might cause a trap.  */
    2971                 :            : 
    2972                 :            : int
    2973                 : 1607960000 : may_trap_p (const_rtx x)
    2974                 :            : {
    2975                 : 1607960000 :   return may_trap_p_1 (x, 0);
    2976                 :            : }
    2977                 :            : 
    2978                 :            : /* Same as above, but additionally return nonzero if evaluating rtx X might
    2979                 :            :    cause a fault.  We define a fault for the purpose of this function as a
    2980                 :            :    erroneous execution condition that cannot be encountered during the normal
    2981                 :            :    execution of a valid program; the typical example is an unaligned memory
    2982                 :            :    access on a strict alignment machine.  The compiler guarantees that it
    2983                 :            :    doesn't generate code that will fault from a valid program, but this
    2984                 :            :    guarantee doesn't mean anything for individual instructions.  Consider
    2985                 :            :    the following example:
    2986                 :            : 
    2987                 :            :       struct S { int d; union { char *cp; int *ip; }; };
    2988                 :            : 
    2989                 :            :       int foo(struct S *s)
    2990                 :            :       {
    2991                 :            :         if (s->d == 1)
    2992                 :            :           return *s->ip;
    2993                 :            :         else
    2994                 :            :           return *s->cp;
    2995                 :            :       }
    2996                 :            : 
    2997                 :            :    on a strict alignment machine.  In a valid program, foo will never be
    2998                 :            :    invoked on a structure for which d is equal to 1 and the underlying
    2999                 :            :    unique field of the union not aligned on a 4-byte boundary, but the
    3000                 :            :    expression *s->ip might cause a fault if considered individually.
    3001                 :            : 
    3002                 :            :    At the RTL level, potentially problematic expressions will almost always
    3003                 :            :    verify may_trap_p; for example, the above dereference can be emitted as
    3004                 :            :    (mem:SI (reg:P)) and this expression is may_trap_p for a generic register.
    3005                 :            :    However, suppose that foo is inlined in a caller that causes s->cp to
    3006                 :            :    point to a local character variable and guarantees that s->d is not set
    3007                 :            :    to 1; foo may have been effectively translated into pseudo-RTL as:
    3008                 :            : 
    3009                 :            :       if ((reg:SI) == 1)
    3010                 :            :         (set (reg:SI) (mem:SI (%fp - 7)))
    3011                 :            :       else
    3012                 :            :         (set (reg:QI) (mem:QI (%fp - 7)))
    3013                 :            : 
    3014                 :            :    Now (mem:SI (%fp - 7)) is considered as not may_trap_p since it is a
    3015                 :            :    memory reference to a stack slot, but it will certainly cause a fault
    3016                 :            :    on a strict alignment machine.  */
    3017                 :            : 
    3018                 :            : int
    3019                 :    7986630 : may_trap_or_fault_p (const_rtx x)
    3020                 :            : {
    3021                 :    7986630 :   return may_trap_p_1 (x, 1);
    3022                 :            : }
    3023                 :            : 
    3024                 :            : /* Replace any occurrence of FROM in X with TO.  The function does
    3025                 :            :    not enter into CONST_DOUBLE for the replace.
    3026                 :            : 
    3027                 :            :    Note that copying is not done so X must not be shared unless all copies
    3028                 :            :    are to be modified.
    3029                 :            : 
    3030                 :            :    ALL_REGS is true if we want to replace all REGs equal to FROM, not just
    3031                 :            :    those pointer-equal ones.  */
    3032                 :            : 
    3033                 :            : rtx
    3034                 :    5399500 : replace_rtx (rtx x, rtx from, rtx to, bool all_regs)
    3035                 :            : {
    3036                 :    5399500 :   int i, j;
    3037                 :    5399500 :   const char *fmt;
    3038                 :            : 
    3039                 :    5399500 :   if (x == from)
    3040                 :            :     return to;
    3041                 :            : 
    3042                 :            :   /* Allow this function to make replacements in EXPR_LISTs.  */
    3043                 :    3821210 :   if (x == 0)
    3044                 :            :     return 0;
    3045                 :            : 
    3046                 :    3821210 :   if (all_regs
    3047                 :     153254 :       && REG_P (x)
    3048                 :      40652 :       && REG_P (from)
    3049                 :    3861860 :       && REGNO (x) == REGNO (from))
    3050                 :            :     {
    3051                 :          0 :       gcc_assert (GET_MODE (x) == GET_MODE (from));
    3052                 :            :       return to;
    3053                 :            :     }
    3054                 :    3821210 :   else if (GET_CODE (x) == SUBREG)
    3055                 :            :     {
    3056                 :      28719 :       rtx new_rtx = replace_rtx (SUBREG_REG (x), from, to, all_regs);
    3057                 :            : 
    3058                 :      28719 :       if (CONST_INT_P (new_rtx))
    3059                 :            :         {
    3060                 :          4 :           x = simplify_subreg (GET_MODE (x), new_rtx,
    3061                 :          2 :                                GET_MODE (SUBREG_REG (x)),
    3062                 :          2 :                                SUBREG_BYTE (x));
    3063                 :          2 :           gcc_assert (x);
    3064                 :            :         }
    3065                 :            :       else
    3066                 :      28717 :         SUBREG_REG (x) = new_rtx;
    3067                 :            : 
    3068                 :      28719 :       return x;
    3069                 :            :     }
    3070                 :    3792490 :   else if (GET_CODE (x) == ZERO_EXTEND)
    3071                 :            :     {
    3072                 :      28404 :       rtx new_rtx = replace_rtx (XEXP (x, 0), from, to, all_regs);
    3073                 :            : 
    3074                 :      28404 :       if (CONST_INT_P (new_rtx))
    3075                 :            :         {
    3076                 :          4 :           x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
    3077                 :          2 :                                         new_rtx, GET_MODE (XEXP (x, 0)));
    3078                 :          2 :           gcc_assert (x);
    3079                 :            :         }
    3080                 :            :       else
    3081                 :      28402 :         XEXP (x, 0) = new_rtx;
    3082                 :            : 
    3083                 :      28404 :       return x;
    3084                 :            :     }
    3085                 :            : 
    3086                 :    3764090 :   fmt = GET_RTX_FORMAT (GET_CODE (x));
    3087                 :    9409590 :   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
    3088                 :            :     {
    3089                 :    5645500 :       if (fmt[i] == 'e')
    3090                 :    3620840 :         XEXP (x, i) = replace_rtx (XEXP (x, i), from, to, all_regs);
    3091                 :    2024660 :       else if (fmt[i] == 'E')
    3092                 :      84771 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    3093                 :      68100 :           XVECEXP (x, i, j) = replace_rtx (XVECEXP (x, i, j),
    3094                 :            :                                            from, to, all_regs);
    3095                 :            :     }
    3096                 :            : 
    3097                 :            :   return x;
    3098                 :            : }
    3099                 :            : 
    3100                 :            : /* Replace occurrences of the OLD_LABEL in *LOC with NEW_LABEL.  Also track
    3101                 :            :    the change in LABEL_NUSES if UPDATE_LABEL_NUSES.  */
    3102                 :            : 
    3103                 :            : void
    3104                 :       2361 : replace_label (rtx *loc, rtx old_label, rtx new_label, bool update_label_nuses)
    3105                 :            : {
    3106                 :            :   /* Handle jump tables specially, since ADDR_{DIFF_,}VECs can be long.  */
    3107                 :       2361 :   rtx x = *loc;
    3108                 :       2361 :   if (JUMP_TABLE_DATA_P (x))
    3109                 :            :     {
    3110                 :          4 :       x = PATTERN (x);
    3111                 :          4 :       rtvec vec = XVEC (x, GET_CODE (x) == ADDR_DIFF_VEC);
    3112                 :          4 :       int len = GET_NUM_ELEM (vec);
    3113                 :         36 :       for (int i = 0; i < len; ++i)
    3114                 :            :         {
    3115                 :         32 :           rtx ref = RTVEC_ELT (vec, i);
    3116                 :         32 :           if (XEXP (ref, 0) == old_label)
    3117                 :            :             {
    3118                 :          0 :               XEXP (ref, 0) = new_label;
    3119                 :          0 :               if (update_label_nuses)
    3120                 :            :                 {
    3121                 :          0 :                   ++LABEL_NUSES (new_label);
    3122                 :          0 :                   --LABEL_NUSES (old_label);
    3123                 :            :                 }
    3124                 :            :             }
    3125                 :            :         }
    3126                 :          4 :       return;
    3127                 :            :     }
    3128                 :            : 
    3129                 :            :   /* If this is a JUMP_INSN, then we also need to fix the JUMP_LABEL
    3130                 :            :      field.  This is not handled by the iterator because it doesn't
    3131                 :            :      handle unprinted ('0') fields.  */
    3132                 :       2357 :   if (JUMP_P (x) && JUMP_LABEL (x) == old_label)
    3133                 :          4 :     JUMP_LABEL (x) = new_label;
    3134                 :            : 
    3135                 :       4714 :   subrtx_ptr_iterator::array_type array;
    3136                 :      15914 :   FOR_EACH_SUBRTX_PTR (iter, array, loc, ALL)
    3137                 :            :     {
    3138                 :      13557 :       rtx *loc = *iter;
    3139                 :      13557 :       if (rtx x = *loc)
    3140                 :            :         {
    3141                 :      11702 :           if (GET_CODE (x) == SYMBOL_REF
    3142                 :      11702 :               && CONSTANT_POOL_ADDRESS_P (x))
    3143                 :            :             {
    3144                 :          0 :               rtx c = get_pool_constant (x);
    3145                 :          0 :               if (rtx_referenced_p (old_label, c))
    3146                 :            :                 {
    3147                 :            :                   /* Create a copy of constant C; replace the label inside
    3148                 :            :                      but do not update LABEL_NUSES because uses in constant pool
    3149                 :            :                      are not counted.  */
    3150                 :          0 :                   rtx new_c = copy_rtx (c);
    3151                 :          0 :                   replace_label (&new_c, old_label, new_label, false);
    3152                 :            : 
    3153                 :            :                   /* Add the new constant NEW_C to constant pool and replace
    3154                 :            :                      the old reference to constant by new reference.  */
    3155                 :          0 :                   rtx new_mem = force_const_mem (get_pool_mode (x), new_c);
    3156                 :          0 :                   *loc = replace_rtx (x, x, XEXP (new_mem, 0));
    3157                 :            :                 }
    3158                 :            :             }
    3159                 :            : 
    3160                 :      11702 :           if ((GET_CODE (x) == LABEL_REF
    3161                 :      11702 :                || GET_CODE (x) == INSN_LIST)
    3162                 :        172 :               && XEXP (x, 0) == old_label)
    3163                 :            :             {
    3164                 :         12 :               XEXP (x, 0) = new_label;
    3165                 :         12 :               if (update_label_nuses)
    3166                 :            :                 {
    3167                 :          0 :                   ++LABEL_NUSES (new_label);
    3168                 :          0 :                   --LABEL_NUSES (old_label);
    3169                 :            :                 }
    3170                 :            :             }
    3171                 :            :         }
    3172                 :            :     }
    3173                 :            : }
    3174                 :            : 
    3175                 :            : void
    3176                 :       2361 : replace_label_in_insn (rtx_insn *insn, rtx_insn *old_label,
    3177                 :            :                        rtx_insn *new_label, bool update_label_nuses)
    3178                 :            : {
    3179                 :       2361 :   rtx insn_as_rtx = insn;
    3180                 :       2361 :   replace_label (&insn_as_rtx, old_label, new_label, update_label_nuses);
    3181                 :       2361 :   gcc_checking_assert (insn_as_rtx == insn);
    3182                 :       2361 : }
    3183                 :            : 
    3184                 :            : /* Return true if X is referenced in BODY.  */
    3185                 :            : 
    3186                 :            : bool
    3187                 :     222259 : rtx_referenced_p (const_rtx x, const_rtx body)
    3188                 :            : {
    3189                 :     222259 :   subrtx_iterator::array_type array;
    3190                 :    1037870 :   FOR_EACH_SUBRTX (iter, array, body, ALL)
    3191                 :     833514 :     if (const_rtx y = *iter)
    3192                 :            :       {
    3193                 :            :         /* Check if a label_ref Y refers to label X.  */
    3194                 :     832746 :         if (GET_CODE (y) == LABEL_REF
    3195                 :       1167 :             && LABEL_P (x)
    3196                 :     833909 :             && label_ref_label (y) == x)
    3197                 :      17904 :           return true;
    3198                 :            : 
    3199                 :     832746 :         if (rtx_equal_p (x, y))
    3200                 :            :           return true;
    3201                 :            : 
    3202                 :            :         /* If Y is a reference to pool constant traverse the constant.  */
    3203                 :     814842 :         if (GET_CODE (y) == SYMBOL_REF
    3204                 :     814842 :             && CONSTANT_POOL_ADDRESS_P (y))
    3205                 :     815610 :           iter.substitute (get_pool_constant (y));
    3206                 :            :       }
    3207                 :     204355 :   return false;
    3208                 :            : }
    3209                 :            : 
    3210                 :            : /* If INSN is a tablejump return true and store the label (before jump table) to
    3211                 :            :    *LABELP and the jump table to *TABLEP.  LABELP and TABLEP may be NULL.  */
    3212                 :            : 
    3213                 :            : bool
    3214                 :   65590200 : tablejump_p (const rtx_insn *insn, rtx_insn **labelp,
    3215                 :            :              rtx_jump_table_data **tablep)
    3216                 :            : {
    3217                 :   65590200 :   if (!JUMP_P (insn))
    3218                 :            :     return false;
    3219                 :            : 
    3220                 :   48247400 :   rtx target = JUMP_LABEL (insn);
    3221                 :   48247400 :   if (target == NULL_RTX || ANY_RETURN_P (target))
    3222                 :            :     return false;
    3223                 :            : 
    3224                 :   46159200 :   rtx_insn *label = as_a<rtx_insn *> (target);
    3225                 :   46159200 :   rtx_insn *table = next_insn (label);
    3226                 :   46159200 :   if (table == NULL_RTX || !JUMP_TABLE_DATA_P (table))
    3227                 :            :     return false;
    3228                 :            : 
    3229                 :      67099 :   if (labelp)
    3230                 :      29357 :     *labelp = label;
    3231                 :      67099 :   if (tablep)
    3232                 :      65604 :     *tablep = as_a <rtx_jump_table_data *> (table);
    3233                 :            :   return true;
    3234                 :            : }
    3235                 :            : 
    3236                 :            : /* For INSN known to satisfy tablejump_p, determine if it actually is a
    3237                 :            :    CASESI.  Return the insn pattern if so, NULL_RTX otherwise.  */
    3238                 :            : 
    3239                 :            : rtx
    3240                 :      14507 : tablejump_casesi_pattern (const rtx_insn *insn)
    3241                 :            : {
    3242                 :      14507 :   rtx tmp;
    3243                 :            : 
    3244                 :      14507 :   if ((tmp = single_set (insn)) != NULL
    3245                 :      14507 :       && SET_DEST (tmp) == pc_rtx
    3246                 :      14507 :       && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
    3247                 :      14507 :       && GET_CODE (XEXP (SET_SRC (tmp), 2)) == LABEL_REF)
    3248                 :          0 :     return tmp;
    3249                 :            : 
    3250                 :            :   return NULL_RTX;
    3251                 :            : }
    3252                 :            : 
    3253                 :            : /* A subroutine of computed_jump_p, return 1 if X contains a REG or MEM or
    3254                 :            :    constant that is not in the constant pool and not in the condition
    3255                 :            :    of an IF_THEN_ELSE.  */
    3256                 :            : 
    3257                 :            : static int
    3258                 :       1701 : computed_jump_p_1 (const_rtx x)
    3259                 :            : {
    3260                 :       1701 :   const enum rtx_code code = GET_CODE (x);
    3261                 :       1701 :   int i, j;
    3262                 :       1701 :   const char *fmt;
    3263                 :            : 
    3264                 :       1701 :   switch (code)
    3265                 :            :     {
    3266                 :            :     case LABEL_REF:
    3267                 :            :     case PC:
    3268                 :            :       return 0;
    3269                 :            : 
    3270                 :       1485 :     case CONST:
    3271                 :       1485 :     CASE_CONST_ANY:
    3272                 :       1485 :     case SYMBOL_REF:
    3273                 :       1485 :     case REG:
    3274                 :       1485 :       return 1;
    3275                 :            : 
    3276                 :        216 :     case MEM:
    3277                 :        216 :       return ! (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
    3278                 :        216 :                 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)));
    3279                 :            : 
    3280                 :          0 :     case IF_THEN_ELSE:
    3281                 :          0 :       return (computed_jump_p_1 (XEXP (x, 1))
    3282                 :          0 :               || computed_jump_p_1 (XEXP (x, 2)));
    3283                 :            : 
    3284                 :          0 :     default:
    3285                 :          0 :       break;
    3286                 :            :     }
    3287                 :            : 
    3288                 :          0 :   fmt = GET_RTX_FORMAT (code);
    3289                 :          0 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3290                 :            :     {
    3291                 :          0 :       if (fmt[i] == 'e'
    3292                 :          0 :           && computed_jump_p_1 (XEXP (x, i)))
    3293                 :            :         return 1;
    3294                 :            : 
    3295                 :          0 :       else if (fmt[i] == 'E')
    3296                 :          0 :         for (j = 0; j < XVECLEN (x, i); j++)
    3297                 :          0 :           if (computed_jump_p_1 (XVECEXP (x, i, j)))
    3298                 :            :             return 1;
    3299                 :            :     }
    3300                 :            : 
    3301                 :            :   return 0;
    3302                 :            : }
    3303                 :            : 
    3304                 :            : /* Return nonzero if INSN is an indirect jump (aka computed jump).
    3305                 :            : 
    3306                 :            :    Tablejumps and casesi insns are not considered indirect jumps;
    3307                 :            :    we can recognize them by a (use (label_ref)).  */
    3308                 :            : 
    3309                 :            : int
    3310                 :   28290400 : computed_jump_p (const rtx_insn *insn)
    3311                 :            : {
    3312                 :   28290400 :   int i;
    3313                 :   28290400 :   if (JUMP_P (insn))
    3314                 :            :     {
    3315                 :   25687300 :       rtx pat = PATTERN (insn);
    3316                 :            : 
    3317                 :            :       /* If we have a JUMP_LABEL set, we're not a computed jump.  */
    3318                 :   25687300 :       if (JUMP_LABEL (insn) != NULL)
    3319                 :            :         return 0;
    3320                 :            : 
    3321                 :       1980 :       if (GET_CODE (pat) == PARALLEL)
    3322                 :            :         {
    3323                 :        255 :           int len = XVECLEN (pat, 0);
    3324                 :        255 :           int has_use_labelref = 0;
    3325                 :            : 
    3326                 :        765 :           for (i = len - 1; i >= 0; i--)
    3327                 :        510 :             if (GET_CODE (XVECEXP (pat, 0, i)) == USE
    3328                 :          0 :                 && (GET_CODE (XEXP (XVECEXP (pat, 0, i), 0))
    3329                 :            :                     == LABEL_REF))
    3330                 :            :               {
    3331                 :            :                 has_use_labelref = 1;
    3332                 :            :                 break;
    3333                 :            :               }
    3334                 :            : 
    3335                 :        255 :           if (! has_use_labelref)
    3336                 :        765 :             for (i = len - 1; i >= 0; i--)
    3337                 :        510 :               if (GET_CODE (XVECEXP (pat, 0, i)) == SET
    3338                 :          0 :                   && SET_DEST (XVECEXP (pat, 0, i)) == pc_rtx
    3339                 :        510 :                   && computed_jump_p_1 (SET_SRC (XVECEXP (pat, 0, i))))
    3340                 :            :                 return 1;
    3341                 :            :         }
    3342                 :       1725 :       else if (GET_CODE (pat) == SET
    3343                 :       1701 :                && SET_DEST (pat) == pc_rtx
    3344                 :       3426 :                && computed_jump_p_1 (SET_SRC (pat)))
    3345                 :       1701 :         return 1;
    3346                 :            :     }
    3347                 :            :   return 0;
    3348                 :            : }
    3349                 :            : 
    3350                 :            : 
    3351                 :            : 
    3352                 :            : /* MEM has a PRE/POST-INC/DEC/MODIFY address X.  Extract the operands of
    3353                 :            :    the equivalent add insn and pass the result to FN, using DATA as the
    3354                 :            :    final argument.  */
    3355                 :            : 
    3356                 :            : static int
    3357                 :   19601900 : for_each_inc_dec_find_inc_dec (rtx mem, for_each_inc_dec_fn fn, void *data)
    3358                 :            : {
    3359                 :   19601900 :   rtx x = XEXP (mem, 0);
    3360                 :   19601900 :   switch (GET_CODE (x))
    3361                 :            :     {
    3362                 :    2430260 :     case PRE_INC:
    3363                 :    2430260 :     case POST_INC:
    3364                 :    2430260 :       {
    3365                 :    4860530 :         poly_int64 size = GET_MODE_SIZE (GET_MODE (mem));
    3366                 :    2430260 :         rtx r1 = XEXP (x, 0);
    3367                 :    2430260 :         rtx c = gen_int_mode (size, GET_MODE (r1));
    3368                 :    2430260 :         return fn (mem, x, r1, r1, c, data);
    3369                 :            :       }
    3370                 :            : 
    3371                 :   16794900 :     case PRE_DEC:
    3372                 :   16794900 :     case POST_DEC:
    3373                 :   16794900 :       {
    3374                 :   33589900 :         poly_int64 size = GET_MODE_SIZE (GET_MODE (mem));
    3375                 :   16794900 :         rtx r1 = XEXP (x, 0);
    3376                 :   16794900 :         rtx c = gen_int_mode (-size, GET_MODE (r1));
    3377                 :   16794900 :         return fn (mem, x, r1, r1, c, data);
    3378                 :            :       }
    3379                 :            : 
    3380                 :     376661 :     case PRE_MODIFY:
    3381                 :     376661 :     case POST_MODIFY:
    3382                 :     376661 :       {
    3383                 :     376661 :         rtx r1 = XEXP (x, 0);
    3384                 :     376661 :         rtx add = XEXP (x, 1);
    3385                 :     376661 :         return fn (mem, x, r1, add, NULL, data);
    3386                 :            :       }
    3387                 :            : 
    3388                 :          0 :     default:
    3389                 :          0 :       gcc_unreachable ();
    3390                 :            :     }
    3391                 :            : }
    3392                 :            : 
    3393                 :            : /* Traverse *LOC looking for MEMs that have autoinc addresses.
    3394                 :            :    For each such autoinc operation found, call FN, passing it
    3395                 :            :    the innermost enclosing MEM, the operation itself, the RTX modified
    3396                 :            :    by the operation, two RTXs (the second may be NULL) that, once
    3397                 :            :    added, represent the value to be held by the modified RTX
    3398                 :            :    afterwards, and DATA.  FN is to return 0 to continue the
    3399                 :            :    traversal or any other value to have it returned to the caller of
    3400                 :            :    for_each_inc_dec.  */
    3401                 :            : 
    3402                 :            : int
    3403                 :  627971000 : for_each_inc_dec (rtx x,
    3404                 :            :                   for_each_inc_dec_fn fn,
    3405                 :            :                   void *data)
    3406                 :            : {
    3407                 :  627971000 :   subrtx_var_iterator::array_type array;
    3408                 : 3390330000 :   FOR_EACH_SUBRTX_VAR (iter, array, x, NONCONST)
    3409                 :            :     {
    3410                 : 2762360000 :       rtx mem = *iter;
    3411                 : 2762360000 :       if (mem
    3412                 : 2762360000 :           && MEM_P (mem)
    3413                 :  177378000 :           && GET_RTX_CLASS (GET_CODE (XEXP (mem, 0))) == RTX_AUTOINC)
    3414                 :            :         {
    3415                 :   19601900 :           int res = for_each_inc_dec_find_inc_dec (mem, fn, data);
    3416                 :   19601900 :           if (res != 0)
    3417                 :          0 :             return res;
    3418                 : 2762360000 :           iter.skip_subrtxes ();
    3419                 :            :         }
    3420                 :            :     }
    3421                 :  627971000 :   return 0;
    3422                 :            : }
    3423                 :            : 
    3424                 :            : 
    3425                 :            : /* Searches X for any reference to REGNO, returning the rtx of the
    3426                 :            :    reference found if any.  Otherwise, returns NULL_RTX.  */
    3427                 :            : 
    3428                 :            : rtx
    3429                 :          0 : regno_use_in (unsigned int regno, rtx x)
    3430                 :            : {
    3431                 :          0 :   const char *fmt;
    3432                 :          0 :   int i, j;
    3433                 :          0 :   rtx tem;
    3434                 :            : 
    3435                 :          0 :   if (REG_P (x) && REGNO (x) == regno)
    3436                 :            :     return x;
    3437                 :            : 
    3438                 :          0 :   fmt = GET_RTX_FORMAT (GET_CODE (x));
    3439                 :          0 :   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
    3440                 :            :     {
    3441                 :          0 :       if (fmt[i] == 'e')
    3442                 :            :         {
    3443                 :          0 :           if ((tem = regno_use_in (regno, XEXP (x, i))))
    3444                 :          0 :             return tem;
    3445                 :            :         }
    3446                 :          0 :       else if (fmt[i] == 'E')
    3447                 :          0 :         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
    3448                 :          0 :           if ((tem = regno_use_in (regno , XVECEXP (x, i, j))))
    3449                 :          0 :             return tem;
    3450                 :            :     }
    3451                 :            : 
    3452                 :            :   return NULL_RTX;
    3453                 :            : }
    3454                 :            : 
    3455                 :            : /* Return a value indicating whether OP, an operand of a commutative
    3456                 :            :    operation, is preferred as the first or second operand.  The more
    3457                 :            :    positive the value, the stronger the preference for being the first
    3458                 :            :    operand.  */
    3459                 :            : 
    3460                 :            : int
    3461                 : 1246750000 : commutative_operand_precedence (rtx op)
    3462                 :            : {
    3463                 : 1246750000 :   enum rtx_code code = GET_CODE (op);
    3464                 :            : 
    3465                 :            :   /* Constants always become the second operand.  Prefer "nice" constants.  */
    3466                 : 1246750000 :   if (code == CONST_INT)
    3467                 :            :     return -10;
    3468                 :  767601000 :   if (code == CONST_WIDE_INT)
    3469                 :            :     return -9;
    3470                 :  767219000 :   if (code == CONST_POLY_INT)
    3471                 :            :     return -8;
    3472                 :  767219000 :   if (code == CONST_DOUBLE)
    3473                 :            :     return -8;
    3474                 :  763079000 :   if (code == CONST_FIXED)
    3475                 :            :     return -8;
    3476                 :  763079000 :   op = avoid_constant_pool_reference (op);
    3477                 :  763079000 :   code = GET_CODE (op);
    3478                 :            : 
    3479                 :  763079000 :   switch (GET_RTX_CLASS (code))
    3480                 :            :     {
    3481                 :   12523800 :     case RTX_CONST_OBJ:
    3482                 :   12523800 :       if (code == CONST_INT)
    3483                 :            :         return -7;
    3484                 :   12523800 :       if (code == CONST_WIDE_INT)
    3485                 :            :         return -6;
    3486                 :   12523800 :       if (code == CONST_POLY_INT)
    3487                 :            :         return -5;
    3488                 :   12523800 :       if (code == CONST_DOUBLE)
    3489                 :            :         return -5;
    3490                 :   12263300 :       if (code == CONST_FIXED)
    3491                 :          0 :         return -5;
    3492                 :            :       return -4;
    3493                 :            : 
    3494                 :   25634900 :     case RTX_EXTRA:
    3495                 :            :       /* SUBREGs of objects should come second.  */
    3496                 :   25634900 :       if (code == SUBREG && OBJECT_P (SUBREG_REG (op)))
    3497                 :   15976600 :         return -3;
    3498                 :            :       return 0;
    3499                 :            : 
    3500                 :  570903000 :     case RTX_OBJ:
    3501                 :            :       /* Complex expressions should be the first, so decrease priority
    3502                 :            :          of objects.  Prefer pointer objects over non pointer objects.  */
    3503                 :  522317000 :       if ((REG_P (op) && REG_POINTER (op))
    3504                 :  895304000 :           || (MEM_P (op) && MEM_POINTER (op)))
    3505                 :  207078000 :         return -1;
    3506                 :            :       return -2;
    3507                 :            : 
    3508                 :            :     case RTX_COMM_ARITH:
    3509                 :            :       /* Prefer operands that are themselves commutative to be first.
    3510                 :            :          This helps to make things linear.  In particular,
    3511                 :            :          (and (and (reg) (reg)) (not (reg))) is canonical.  */
    3512                 :            :       return 4;
    3513                 :            : 
    3514                 :   43503600 :     case RTX_BIN_ARITH:
    3515                 :            :       /* If only one operand is a binary expression, it will be the first
    3516                 :            :          operand.  In particular,  (plus (minus (reg) (reg)) (neg (reg)))
    3517                 :            :          is canonical, although it will usually be further simplified.  */
    3518                 :   43503600 :       return 2;
    3519                 :            : 
    3520                 :   11494600 :     case RTX_UNARY:
    3521                 :            :       /* Then prefer NEG and NOT.  */
    3522                 :   11494600 :       if (code == NEG || code == NOT)
    3523                 :            :         return 1;
    3524                 :            :       /* FALLTHRU */
    3525                 :            : 
    3526                 :   20019900 :     default:
    3527                 :   20019900 :       return 0;
    3528                 :            :     }
    3529                 :            : }
    3530                 :            : 
    3531                 :            : /* Return 1 iff it is necessary to swap operands of commutative operation
    3532                 :            :    in order to canonicalize expression.  */
    3533                 :            : 
    3534                 :            : bool
    3535                 :  553658000 : swap_commutative_operands_p (rtx x, rtx y)
    3536                 :            : {
    3537                 :  553658000 :   return (commutative_operand_precedence (x)
    3538                 :  553658000 :           < commutative_operand_precedence (y));
    3539                 :            : }
    3540                 :            : 
    3541                 :            : /* Return 1 if X is an autoincrement side effect and the register is
    3542                 :            :    not the stack pointer.  */
    3543                 :            : int
    3544                 :          0 : auto_inc_p (const_rtx x)
    3545                 :            : {
    3546                 :          0 :   switch (GET_CODE (x))
    3547                 :            :     {
    3548                 :          0 :     case PRE_INC:
    3549                 :          0 :     case POST_INC:
    3550                 :          0 :     case PRE_DEC:
    3551                 :          0 :     case POST_DEC:
    3552                 :          0 :     case PRE_MODIFY:
    3553                 :          0 :     case POST_MODIFY:
    3554                 :            :       /* There are no REG_INC notes for SP.  */
    3555                 :          0 :       if (XEXP (x, 0) != stack_pointer_rtx)
    3556                 :          0 :         return 1;
    3557                 :            :     default:
    3558                 :            :       break;
    3559                 :            :     }
    3560                 :            :   return 0;
    3561                 :            : }
    3562                 :            : 
    3563                 :            : /* Return nonzero if IN contains a piece of rtl that has the address LOC.  */
    3564                 :            : int
    3565                 :     681846 : loc_mentioned_in_p (rtx *loc, const_rtx in)
    3566                 :            : {
    3567                 :     681846 :   enum rtx_code code;
    3568                 :     681846 :   const char *fmt;
    3569                 :     681846 :   int i, j;
    3570                 :            : 
    3571                 :     681846 :   if (!in)
    3572                 :            :     return 0;
    3573                 :            : 
    3574                 :     681846 :   code = GET_CODE (in);
    3575                 :     681846 :   fmt = GET_RTX_FORMAT (code);
    3576                 :    1368470 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    3577                 :            :     {
    3578                 :    1089190 :       if (fmt[i] == 'e')
    3579                 :            :         {
    3580                 :     661356 :           if (loc == &XEXP (in, i) || loc_mentioned_in_p (loc, XEXP (in, i)))
    3581                 :     401686 :             return 1;
    3582                 :            :         }
    3583                 :     427834 :       else if (fmt[i] == 'E')
    3584                 :      25075 :         for (j = XVECLEN (in, i) - 1; j >= 0; j--)
    3585                 :      19391 :           if (loc == &XVECEXP (in, i, j)
    3586                 :      19391 :               || loc_mentioned_in_p (loc, XVECEXP (in, i, j)))
    3587                 :        883 :             return 1;
    3588                 :            :     }
    3589                 :            :   return 0;
    3590                 :            : }
    3591                 :            : 
    3592                 :            : /* Reinterpret a subreg as a bit extraction from an integer and return
    3593                 :            :    the position of the least significant bit of the extracted value.
    3594                 :            :    In other words, if the extraction were performed as a shift right
    3595                 :            :    and mask, return the number of bits to shift right.
    3596                 :            : 
    3597                 :            :    The outer value of the subreg has OUTER_BYTES bytes and starts at
    3598                 :            :    byte offset SUBREG_BYTE within an inner value of INNER_BYTES bytes.  */
    3599                 :            : 
    3600                 :            : poly_uint64
    3601                 :   23089000 : subreg_size_lsb (poly_uint64 outer_bytes,
    3602                 :            :                  poly_uint64 inner_bytes,
    3603                 :            :                  poly_uint64 subreg_byte)
    3604                 :            : {
    3605                 :   23089000 :   poly_uint64 subreg_end, trailing_bytes, byte_pos;
    3606                 :            : 
    3607                 :            :   /* A paradoxical subreg begins at bit position 0.  */
    3608                 :   23089000 :   gcc_checking_assert (ordered_p (outer_bytes, inner_bytes));
    3609                 :   23089000 :   if (maybe_gt (outer_bytes, inner_bytes))
    3610                 :            :     {
    3611                 :        342 :       gcc_checking_assert (known_eq (subreg_byte, 0U));
    3612                 :        342 :       return 0;
    3613                 :            :     }
    3614                 :            : 
    3615                 :   23088600 :   subreg_end = subreg_byte + outer_bytes;
    3616                 :   23088600 :   trailing_bytes = inner_bytes - subreg_end;
    3617                 :   23088600 :   if (WORDS_BIG_ENDIAN && BYTES_BIG_ENDIAN)
    3618                 :            :     byte_pos = trailing_bytes;
    3619                 :   23088600 :   else if (!WORDS_BIG_ENDIAN && !BYTES_BIG_ENDIAN)
    3620                 :   23088600 :     byte_pos = subreg_byte;
    3621                 :            :   else
    3622                 :            :     {
    3623                 :            :       /* When bytes and words have opposite endianness, we must be able
    3624                 :            :          to split offsets into words and bytes at compile time.  */
    3625                 :            :       poly_uint64 leading_word_part
    3626                 :            :         = force_align_down (subreg_byte, UNITS_PER_WORD);
    3627                 :            :       poly_uint64 trailing_word_part
    3628                 :            :         = force_align_down (trailing_bytes, UNITS_PER_WORD);
    3629                 :            :       /* If the subreg crosses a word boundary ensure that
    3630                 :            :          it also begins and ends on a word boundary.  */
    3631                 :            :       gcc_assert (known_le (subreg_end - leading_word_part,
    3632                 :            :                             (unsigned int) UNITS_PER_WORD)
    3633                 :            :                   || (known_eq (leading_word_part, subreg_byte)
    3634                 :            :                       && known_eq (trailing_word_part, trailing_bytes)));
    3635                 :            :       if (WORDS_BIG_ENDIAN)
    3636                 :            :         byte_pos = trailing_word_part + (subreg_byte - leading_word_part);
    3637                 :            :       else
    3638                 :            :         byte_pos = leading_word_part + (trailing_bytes - trailing_word_part);
    3639                 :            :     }
    3640                 :            : 
    3641                 :   23088600 :   return byte_pos * BITS_PER_UNIT;
    3642                 :            : }
    3643                 :            : 
    3644                 :            : /* Given a subreg X, return the bit offset where the subreg begins
    3645                 :            :    (counting from the least significant bit of the reg).  */
    3646                 :            : 
    3647                 :            : poly_uint64
    3648                 :       8987 : subreg_lsb (const_rtx x)
    3649                 :            : {
    3650                 :       8987 :   return subreg_lsb_1 (GET_MODE (x), GET_MODE (SUBREG_REG (x)),
    3651                 :       8987 :                        SUBREG_BYTE (x));
    3652                 :            : }
    3653                 :            : 
    3654                 :            : /* Return the subreg byte offset for a subreg whose outer value has
    3655                 :            :    OUTER_BYTES bytes, whose inner value has INNER_BYTES bytes, and where
    3656                 :            :    there are LSB_SHIFT *bits* between the lsb of the outer value and the
    3657                 :            :    lsb of the inner value.  This is the inverse of the calculation
    3658                 :            :    performed by subreg_lsb_1 (which converts byte offsets to bit shifts).  */
    3659                 :            : 
    3660                 :            : poly_uint64
    3661                 :   22305900 : subreg_size_offset_from_lsb (poly_uint64 outer_bytes, poly_uint64 inner_bytes,
    3662                 :            :                              poly_uint64 lsb_shift)
    3663                 :            : {
    3664                 :            :   /* A paradoxical subreg begins at bit position 0.  */
    3665                 :   22305900 :   gcc_checking_assert (ordered_p (outer_bytes, inner_bytes));
    3666                 :   22305900 :   if (maybe_gt (outer_bytes, inner_bytes))
    3667                 :            :     {
    3668                 :          0 :       gcc_checking_assert (known_eq (lsb_shift, 0U));
    3669                 :          0 :       return 0;
    3670                 :            :     }
    3671                 :            : 
    3672                 :   22305900 :   poly_uint64 lower_bytes = exact_div (lsb_shift, BITS_PER_UNIT);
    3673                 :   22305900 :   poly_uint64 upper_bytes = inner_bytes - (lower_bytes + outer_bytes);
    3674                 :   22305900 :   if (WORDS_BIG_ENDIAN && BYTES_BIG_ENDIAN)
    3675                 :            :     return upper_bytes;
    3676                 :   22305900 :   else if (!WORDS_BIG_ENDIAN && !BYTES_BIG_ENDIAN)
    3677                 :   22305900 :     return lower_bytes;
    3678                 :            :   else
    3679                 :            :     {
    3680                 :            :       /* When bytes and words have opposite endianness, we must be able
    3681                 :            :          to split offsets into words and bytes at compile time.  */
    3682                 :            :       poly_uint64 lower_word_part = force_align_down (lower_bytes,
    3683                 :            :                                                       UNITS_PER_WORD);
    3684                 :            :       poly_uint64 upper_word_part = force_align_down (upper_bytes,
    3685                 :            :                                                       UNITS_PER_WORD);
    3686                 :            :       if (WORDS_BIG_ENDIAN)
    3687                 :            :         return upper_word_part + (lower_bytes - lower_word_part);
    3688                 :            :       else
    3689                 :            :         return lower_word_part + (upper_bytes - upper_word_part);
    3690                 :            :     }
    3691                 :            : }
    3692                 :            : 
    3693                 :            : /* Fill in information about a subreg of a hard register.
    3694                 :            :    xregno - A regno of an inner hard subreg_reg (or what will become one).
    3695                 :            :    xmode  - The mode of xregno.
    3696                 :            :    offset - The byte offset.
    3697                 :            :    ymode  - The mode of a top level SUBREG (or what may become one).
    3698                 :            :    info   - Pointer to structure to fill in.
    3699                 :            : 
    3700                 :            :    Rather than considering one particular inner register (and thus one
    3701                 :            :    particular "outer" register) in isolation, this function really uses
    3702                 :            :    XREGNO as a model for a sequence of isomorphic hard registers.  Thus the
    3703                 :            :    function does not check whether adding INFO->offset to XREGNO gives
    3704                 :            :    a valid hard register; even if INFO->offset + XREGNO is out of range,
    3705                 :            :    there might be another register of the same type that is in range.
    3706                 :            :    Likewise it doesn't check whether targetm.hard_regno_mode_ok accepts
    3707                 :            :    the new register, since that can depend on things like whether the final
    3708                 :            :    register number is even or odd.  Callers that want to check whether
    3709                 :            :    this particular subreg can be replaced by a simple (reg ...) should
    3710                 :            :    use simplify_subreg_regno.  */
    3711                 :            : 
    3712                 :            : void
    3713                 :   14282500 : subreg_get_info (unsigned int xregno, machine_mode xmode,
    3714                 :            :                  poly_uint64 offset, machine_mode ymode,
    3715                 :            :                  struct subreg_info *info)
    3716                 :            : {
    3717                 :   14282500 :   unsigned int nregs_xmode, nregs_ymode;
    3718                 :            : 
    3719                 :   14282500 :   gcc_assert (xregno < FIRST_PSEUDO_REGISTER);
    3720                 :            : 
    3721                 :   28565000 :   poly_uint64 xsize = GET_MODE_SIZE (xmode);
    3722                 :   28565000 :   poly_uint64 ysize = GET_MODE_SIZE (ymode);
    3723                 :            : 
    3724                 :   14282500 :   bool rknown = false;
    3725                 :            : 
    3726                 :            :   /* If the register representation of a non-scalar mode has holes in it,
    3727                 :            :      we expect the scalar units to be concatenated together, with the holes
    3728                 :            :      distributed evenly among the scalar units.  Each scalar unit must occupy
    3729                 :            :      at least one register.  */
    3730                 :   14282500 :   if (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode))
    3731                 :            :     {
    3732                 :            :       /* As a consequence, we must be dealing with a constant number of
    3733                 :            :          scalars, and thus a constant offset and number of units.  */
    3734                 :          0 :       HOST_WIDE_INT coffset = offset.to_constant ();
    3735                 :          0 :       HOST_WIDE_INT cysize = ysize.to_constant ();
    3736                 :          0 :       nregs_xmode = HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode);
    3737                 :          0 :       unsigned int nunits = GET_MODE_NUNITS (xmode).to_constant ();
    3738                 :          0 :       scalar_mode xmode_unit = GET_MODE_INNER (xmode);
    3739                 :          0 :       gcc_assert (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode_unit));
    3740                 :          0 :       gcc_assert (nregs_xmode
    3741                 :            :                   == (nunits
    3742                 :            :                       * HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode_unit)));
    3743                 :          0 :       gcc_assert (hard_regno_nregs (xregno, xmode)
    3744                 :            :                   == hard_regno_nregs (xregno, xmode_unit) * nunits);
    3745                 :            : 
    3746                 :            :       /* You can only ask for a SUBREG of a value with holes in the middle
    3747                 :            :          if you don't cross the holes.  (Such a SUBREG should be done by
    3748                 :            :          picking a different register class, or doing it in memory if
    3749                 :            :          necessary.)  An example of a value with holes is XCmode on 32-bit
    3750                 :            :          x86 with -m128bit-long-double; it's represented in 6 32-bit registers,
    3751                 :            :          3 for each part, but in memory it's two 128-bit parts.
    3752                 :            :          Padding is assumed to be at the end (not necessarily the 'high part')
    3753                 :            :          of each unit.  */
    3754                 :          0 :       if ((coffset / GET_MODE_SIZE (xmode_unit) + 1 < nunits)
    3755                 :          0 :           && (coffset / GET_MODE_SIZE (xmode_unit)
    3756                 :          0 :               != ((coffset + cysize - 1) / GET_MODE_SIZE (xmode_unit))))
    3757                 :            :         {
    3758                 :          0 :           info->representable_p = false;
    3759                 :          0 :           rknown = true;
    3760                 :            :         }
    3761                 :            :     }
    3762                 :            :   else
    3763                 :   14282500 :     nregs_xmode = hard_regno_nregs (xregno, xmode);
    3764                 :            : 
    3765                 :   14282500 :   nregs_ymode = hard_regno_nregs (xregno, ymode);
    3766                 :            : 
    3767                 :            :   /* Subreg sizes must be ordered, so that we can tell whether they are
    3768                 :            :      partial, paradoxical or complete.  */
    3769                 :   14282500 :   gcc_checking_assert (ordered_p (xsize, ysize));
    3770                 :            : 
    3771                 :            :   /* Paradoxical subregs are otherwise valid.  */
    3772                 :   14282500 :   if (!rknown && known_eq (offset, 0U) && maybe_gt (ysize, xsize))
    3773                 :            :     {
    3774                 :    3648780 :       info->representable_p = true;
    3775                 :            :       /* If this is a big endian paradoxical subreg, which uses more
    3776                 :            :          actual hard registers than the original register, we must
    3777                 :            :          return a negative offset so that we find the proper highpart
    3778                 :            :          of the register.
    3779                 :            : 
    3780                 :            :          We assume that the ordering of registers within a multi-register
    3781                 :            :          value has a consistent endianness: if bytes and register words
    3782                 :            :          have different endianness, the hard registers that make up a
    3783                 :            :          multi-register value must be at least word-sized.  */
    3784                 :    3648780 :       if (REG_WORDS_BIG_ENDIAN)
    3785                 :            :         info->offset = (int) nregs_xmode - (int) nregs_ymode;
    3786                 :            :       else
    3787                 :    3648780 :         info->offset = 0;
    3788                 :    3648780 :       info->nregs = nregs_ymode;
    3789                 :   14057900 :       return;
    3790                 :            :     }
    3791                 :            : 
    3792                 :            :   /* If registers store different numbers of bits in the different
    3793                 :            :      modes, we cannot generally form this subreg.  */
    3794                 :   10633700 :   poly_uint64 regsize_xmode, regsize_ymode;
    3795                 :    8679390 :   if (!HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode)
    3796                 :          0 :       && !HARD_REGNO_NREGS_HAS_PADDING (xregno, ymode)
    3797                 :   10633700 :       && multiple_p (xsize, nregs_xmode, &regsize_xmode)
    3798                 :   21267400 :       && multiple_p (ysize, nregs_ymode, &regsize_ymode))
    3799                 :            :     {
    3800                 :   10633700 :       if (!rknown
    3801                 :   10633700 :           && ((nregs_ymode > 1 && maybe_gt (regsize_xmode, regsize_ymode))
    3802                 :   10633700 :               || (nregs_xmode > 1 && maybe_gt (regsize_ymode, regsize_xmode))))
    3803                 :            :         {
    3804                 :        101 :           info->representable_p = false;
    3805                 :        101 :           if (!can_div_away_from_zero_p (ysize, regsize_xmode, &info->nregs)
    3806                 :        101 :               || !can_div_trunc_p (offset, regsize_xmode, &info->offset))
    3807                 :            :             /* Checked by validate_subreg.  We must know at compile time
    3808                 :            :                which inner registers are being accessed.  */
    3809                 :          0 :             gcc_unreachable ();
    3810                 :    6197600 :           return;
    3811                 :            :         }
    3812                 :            :       /* It's not valid to extract a subreg of mode YMODE at OFFSET that
    3813                 :            :          would go outside of XMODE.  */
    3814                 :   10633600 :       if (!rknown && maybe_gt (ysize + offset, xsize))
    3815                 :            :         {
    3816                 :          0 :           info->representable_p = false;
    3817                 :          0 :           info->nregs = nregs_ymode;
    3818                 :          0 :           if (!can_div_trunc_p (offset, regsize_xmode, &info->offset))
    3819                 :            :             /* Checked by validate_subreg.  We must know at compile time
    3820                 :            :                which inner registers are being accessed.  */
    3821                 :            :             gcc_unreachable ();
    3822                 :          0 :           return;
    3823                 :            :         }
    3824                 :            :       /* Quick exit for the simple and common case of extracting whole
    3825                 :            :          subregisters from a multiregister value.  */
    3826                 :            :       /* ??? It would be better to integrate this into the code below,
    3827                 :            :          if we can generalize the concept enough and figure out how
    3828                 :            :          odd-sized modes can coexist with the other weird cases we support.  */
    3829                 :   10633600 :       HOST_WIDE_INT count;
    3830                 :   10633600 :       if (!rknown
    3831                 :            :           && WORDS_BIG_ENDIAN == REG_WORDS_BIG_ENDIAN
    3832                 :   10633600 :           && known_eq (regsize_xmode, regsize_ymode)
    3833                 :   16831100 :           && constant_multiple_p (offset, regsize_ymode, &count))
    3834                 :            :         {
    3835                 :    6197500 :           info->representable_p = true;
    3836                 :    6197500 :           info->nregs = nregs_ymode;
    3837                 :    6197500 :           info->offset = count;
    3838                 :    6197500 :           gcc_assert (info->offset + info->nregs <= (int) nregs_xmode);
    3839                 :            :           return;
    3840                 :            :         }
    3841                 :            :     }
    3842                 :            : 
    3843                 :            :   /* Lowpart subregs are otherwise valid.  */
    3844                 :    4436130 :   if (!rknown && known_eq (offset, subreg_lowpart_offset (ymode, xmode)))
    3845                 :            :     {
    3846                 :    4211570 :       info->representable_p = true;
    3847                 :    4211570 :       rknown = true;
    3848                 :            : 
    3849                 :    4211570 :       if (known_eq (offset, 0U) || nregs_xmode == nregs_ymode)
    3850                 :            :         {
    3851                 :    4211570 :           info->offset = 0;
    3852                 :    4211570 :           info->nregs = nregs_ymode;
    3853                 :    4211570 :           return;
    3854                 :            :         }
    3855                 :            :     }
    3856                 :            : 
    3857                 :            :   /* Set NUM_BLOCKS to the number of independently-representable YMODE
    3858                 :            :      values there are in (reg:XMODE XREGNO).  We can view the register
    3859                 :            :      as consisting of this number of independent "blocks", where each
    3860                 :            :      block occupies NREGS_YMODE registers and contains exactly one
    3861                 :            :      representable YMODE value.  */
    3862                 :     224559 :   gcc_assert ((nregs_xmode % nregs_ymode) == 0);
    3863                 :     224559 :   unsigned int num_blocks = nregs_xmode / nregs_ymode;
    3864                 :            : 
    3865                 :            :   /* Calculate the number of bytes in each block.  This must always
    3866                 :            :      be exact, otherwise we don't know how to verify the constraint.
    3867                 :            :      These conditions may be relaxed but subreg_regno_offset would
    3868                 :            :      need to be redesigned.  */
    3869                 :     224559 :   poly_uint64 bytes_per_block = exact_div (xsize, num_blocks);
    3870                 :            : 
    3871                 :            :   /* Get the number of the first block that contains the subreg and the byte
    3872                 :            :      offset of the subreg from the start of that block.  */
    3873                 :     224559 :   unsigned int block_number;
    3874                 :     224559 :   poly_uint64 subblock_offset;
    3875                 :     224559 :   if (!can_div_trunc_p (offset, bytes_per_block, &block_number,
    3876                 :            :                         &subblock_offset))
    3877                 :            :     /* Checked by validate_subreg.  We must know at compile time which
    3878                 :            :        inner registers are being accessed.  */
    3879                 :            :     gcc_unreachable ();
    3880                 :            : 
    3881                 :     224559 :   if (!rknown)
    3882                 :            :     {
    3883                 :            :       /* Only the lowpart of each block is representable.  */
    3884                 :     224559 :       info->representable_p
    3885                 :     224559 :         = known_eq (subblock_offset,
    3886                 :            :                     subreg_size_lowpart_offset (ysize, bytes_per_block));
    3887                 :     224559 :       rknown = true;
    3888                 :            :     }
    3889                 :            : 
    3890                 :            :   /* We assume that the ordering of registers within a multi-register
    3891                 :            :      value has a consistent endianness: if bytes and register words
    3892                 :            :      have different endianness, the hard registers that make up a
    3893                 :            :      multi-register value must be at least word-sized.  */
    3894                 :     224559 :   if (WORDS_BIG_ENDIAN != REG_WORDS_BIG_ENDIAN)
    3895                 :            :     /* The block number we calculated above followed memory endianness.
    3896                 :            :        Convert it to register endianness by counting back from the end.
    3897                 :            :        (Note that, because of the assumption above, each block must be
    3898                 :            :        at least word-sized.)  */
    3899                 :            :     info->offset = (num_blocks - block_number - 1) * nregs_ymode;
    3900                 :            :   else
    3901                 :     224559 :     info->offset = block_number * nregs_ymode;
    3902                 :     224559 :   info->nregs = nregs_ymode;
    3903                 :            : }
    3904                 :            : 
    3905                 :            : /* This function returns the regno offset of a subreg expression.
    3906                 :            :    xregno - A regno of an inner hard subreg_reg (or what will become one).
    3907                 :            :    xmode  - The mode of xregno.
    3908                 :            :    offset - The byte offset.
    3909                 :            :    ymode  - The mode of a top level SUBREG (or what may become one).
    3910                 :            :    RETURN - The regno offset which would be used.  */
    3911                 :            : unsigned int
    3912                 :    2695090 : subreg_regno_offset (unsigned int xregno, machine_mode xmode,
    3913                 :            :                      poly_uint64 offset, machine_mode ymode)
    3914                 :            : {
    3915                 :    2695090 :   struct subreg_info info;
    3916                 :    2695090 :   subreg_get_info (xregno, xmode, offset, ymode, &info);
    3917                 :    2695090 :   return info.offset;
    3918                 :            : }
    3919                 :            : 
    3920                 :            : /* This function returns true when the offset is representable via
    3921                 :            :    subreg_offset in the given regno.
    3922                 :            :    xregno - A regno of an inner hard subreg_reg (or what will become one).
    3923                 :            :    xmode  - The mode of xregno.
    3924                 :            :    offset - The byte offset.
    3925                 :            :    ymode  - The mode of a top level SUBREG (or what may become one).
    3926                 :            :    RETURN - Whether the offset is representable.  */
    3927                 :            : bool
    3928                 :      17164 : subreg_offset_representable_p (unsigned int xregno, machine_mode xmode,
    3929                 :            :                                poly_uint64 offset, machine_mode ymode)
    3930                 :            : {
    3931                 :      17164 :   struct subreg_info info;
    3932                 :      17164 :   subreg_get_info (xregno, xmode, offset, ymode, &info);
    3933                 :      17164 :   return info.representable_p;
    3934                 :            : }
    3935                 :            : 
    3936                 :            : /* Return the number of a YMODE register to which
    3937                 :            : 
    3938                 :            :        (subreg:YMODE (reg:XMODE XREGNO) OFFSET)
    3939                 :            : 
    3940                 :            :    can be simplified.  Return -1 if the subreg can't be simplified.
    3941                 :            : 
    3942                 :            :    XREGNO is a hard register number.  */
    3943                 :            : 
    3944                 :            : int
    3945                 :   11691700 : simplify_subreg_regno (unsigned int xregno, machine_mode xmode,
    3946                 :            :                        poly_uint64 offset, machine_mode ymode)
    3947                 :            : {
    3948                 :   11691700 :   struct subreg_info info;
    3949                 :   11691700 :   unsigned int yregno;
    3950                 :            : 
    3951                 :            :   /* Give the backend a chance to disallow the mode change.  */
    3952                 :   11691700 :   if (GET_MODE_CLASS (xmode) != MODE_COMPLEX_INT
    3953                 :   11691700 :       && GET_MODE_CLASS (xmode) != MODE_COMPLEX_FLOAT
    3954                 :   11691700 :       && !REG_CAN_CHANGE_MODE_P (xregno, xmode, ymode))
    3955                 :            :     return -1;
    3956                 :            : 
    3957                 :            :   /* We shouldn't simplify stack-related registers.  */
    3958                 :   11680900 :   if ((!reload_completed || frame_pointer_needed)
    3959                 :    9804530 :       && xregno == FRAME_POINTER_REGNUM)
    3960                 :            :     return -1;
    3961                 :            : 
    3962                 :   11610600 :   if (FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
    3963                 :            :       && xregno == ARG_POINTER_REGNUM)
    3964                 :            :     return -1;
    3965                 :            : 
    3966                 :   11544400 :   if (xregno == STACK_POINTER_REGNUM
    3967                 :            :       /* We should convert hard stack register in LRA if it is
    3968                 :            :          possible.  */
    3969                 :      65499 :       && ! lra_in_progress)
    3970                 :            :     return -1;
    3971                 :            : 
    3972                 :            :   /* Try to get the register offset.  */
    3973                 :   11479000 :   subreg_get_info (xregno, xmode, offset, ymode, &info);
    3974                 :   11479000 :   if (!info.representable_p)
    3975                 :            :     return -1;
    3976                 :            : 
    3977                 :            :   /* Make sure that the offsetted register value is in range.  */
    3978                 :   11258900 :   yregno = xregno + info.offset;
    3979                 :   11258900 :   if (!HARD_REGISTER_NUM_P (yregno))
    3980                 :            :     return -1;
    3981                 :            : 
    3982                 :            :   /* See whether (reg:YMODE YREGNO) is valid.
    3983                 :            : 
    3984                 :            :      ??? We allow invalid registers if (reg:XMODE XREGNO) is also invalid.
    3985                 :            :      This is a kludge to work around how complex FP arguments are passed
    3986                 :            :      on IA-64 and should be fixed.  See PR target/49226.  */
    3987                 :   11258900 :   if (!targetm.hard_regno_mode_ok (yregno, ymode)
    3988                 :   11258900 :       && targetm.hard_regno_mode_ok (xregno, xmode))
    3989                 :            :     return -1;
    3990                 :            : 
    3991                 :   10619200 :   return (int) yregno;
    3992                 :            : }
    3993                 :            : 
    3994                 :            : /* Return the final regno that a subreg expression refers to.  */
    3995                 :            : unsigned int
    3996                 :       8219 : subreg_regno (const_rtx x)
    3997                 :            : {
    3998                 :       8219 :   unsigned int ret;
    3999                 :       8219 :   rtx subreg = SUBREG_REG (x);
    4000                 :       8219 :   int regno = REGNO (subreg);
    4001                 :            : 
    4002                 :      16438 :   ret = regno + subreg_regno_offset (regno,
    4003                 :       8219 :                                      GET_MODE (subreg),
    4004                 :       8219 :                                      SUBREG_BYTE (x),
    4005                 :       8219 :                                      GET_MODE (x));
    4006                 :       8219 :   return ret;
    4007                 :            : 
    4008                 :            : }
    4009                 :            : 
    4010                 :            : /* Return the number of registers that a subreg expression refers
    4011                 :            :    to.  */
    4012                 :            : unsigned int
    4013                 :      91216 : subreg_nregs (const_rtx x)
    4014                 :            : {
    4015                 :      91216 :   return subreg_nregs_with_regno (REGNO (SUBREG_REG (x)), x);
    4016                 :            : }
    4017                 :            : 
    4018                 :            : /* Return the number of registers that a subreg REG with REGNO
    4019                 :            :    expression refers to.  This is a copy of the rtlanal.c:subreg_nregs
    4020                 :            :    changed so that the regno can be passed in. */
    4021                 :            : 
    4022                 :            : unsigned int
    4023                 :      91216 : subreg_nregs_with_regno (unsigned int regno, const_rtx x)
    4024                 :            : {
    4025                 :      91216 :   struct subreg_info info;
    4026                 :      91216 :   rtx subreg = SUBREG_REG (x);
    4027                 :            : 
    4028                 :      91216 :   subreg_get_info (regno, GET_MODE (subreg), SUBREG_BYTE (x), GET_MODE (x),
    4029                 :            :                    &info);
    4030                 :      91216 :   return info.nregs;
    4031                 :            : }
    4032                 :            : 
    4033                 :            : struct parms_set_data
    4034                 :            : {
    4035                 :            :   int nregs;
    4036                 :            :   HARD_REG_SET regs;
    4037                 :            : };
    4038                 :            : 
    4039                 :            : /* Helper function for noticing stores to parameter registers.  */
    4040                 :            : static void
    4041                 :      36273 : parms_set (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
    4042                 :            : {
    4043                 :      36273 :   struct parms_set_data *const d = (struct parms_set_data *) data;
    4044                 :      36273 :   if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER
    4045                 :      72410 :       && TEST_HARD_REG_BIT (d->regs, REGNO (x)))
    4046                 :            :     {
    4047                 :      35836 :       CLEAR_HARD_REG_BIT (d->regs, REGNO (x));
    4048                 :      35836 :       d->nregs--;
    4049                 :            :     }
    4050                 :      36273 : }
    4051                 :            : 
    4052                 :            : /* Look backward for first parameter to be loaded.
    4053                 :            :    Note that loads of all parameters will not necessarily be
    4054                 :            :    found if CSE has eliminated some of them (e.g., an argument
    4055                 :            :    to the outer function is passed down as a parameter).
    4056                 :            :    Do not skip BOUNDARY.  */
    4057                 :            : rtx_insn *
    4058                 :      27990 : find_first_parameter_load (rtx_insn *call_insn, rtx_insn *boundary)
    4059                 :            : {
    4060                 :      27990 :   struct parms_set_data parm;
    4061                 :      27990 :   rtx p;
    4062                 :      27990 :   rtx_insn *before, *first_set;
    4063                 :            : 
    4064                 :            :   /* Since different machines initialize their parameter registers
    4065                 :            :      in different orders, assume nothing.  Collect the set of all
    4066                 :            :      parameter registers.  */
    4067                 :      27990 :   CLEAR_HARD_REG_SET (parm.regs);
    4068                 :      27990 :   parm.nregs = 0;
    4069                 :      66322 :   for (p = CALL_INSN_FUNCTION_USAGE (call_insn); p; p = XEXP (p, 1))
    4070                 :      38332 :     if (GET_CODE (XEXP (p, 0)) == USE
    4071                 :      38137 :         && REG_P (XEXP (XEXP (p, 0), 0))
    4072                 :      76469 :         && !STATIC_CHAIN_REG_P (XEXP (XEXP (p, 0), 0)))
    4073                 :            :       {
    4074                 :      37871 :         gcc_assert (REGNO (XEXP (XEXP (p, 0), 0)) < FIRST_PSEUDO_REGISTER);
    4075                 :            : 
    4076                 :            :         /* We only care about registers which can hold function
    4077                 :            :            arguments.  */
    4078                 :      37871 :         if (!FUNCTION_ARG_REGNO_P (REGNO (XEXP (XEXP (p, 0), 0))))
    4079                 :       1437 :           continue;
    4080                 :            : 
    4081                 :      36434 :         SET_HARD_REG_BIT (parm.regs, REGNO (XEXP (XEXP (p, 0), 0)));
    4082                 :      36434 :         parm.nregs++;
    4083                 :            :       }
    4084                 :            :   before = call_insn;
    4085                 :            :   first_set = call_insn;
    4086                 :            : 
    4087                 :            :   /* Search backward for the first set of a register in this set.  */
    4088                 :      63826 :   while (parm.nregs && before != boundary)
    4089                 :            :     {
    4090                 :      36273 :       before = PREV_INSN (before);
    4091                 :            : 
    4092                 :            :       /* It is possible that some loads got CSEed from one call to
    4093                 :            :          another.  Stop in that case.  */
    4094                 :      36273 :       if (CALL_P (before))
    4095                 :            :         break;
    4096                 :            : 
    4097                 :            :       /* Our caller needs either ensure that we will find all sets
    4098                 :            :          (in case code has not been optimized yet), or take care
    4099                 :            :          for possible labels in a way by setting boundary to preceding
    4100                 :            :          CODE_LABEL.  */
    4101                 :      36273 :       if (LABEL_P (before))
    4102                 :            :         {
    4103                 :          0 :           gcc_assert (before == boundary);
    4104                 :            :           break;
    4105                 :            :         }
    4106                 :            : 
    4107                 :      36273 :       if (INSN_P (before))
    4108                 :            :         {
    4109                 :      36273 :           int nregs_old = parm.nregs;
    4110                 :      36273 :           note_stores (before, parms_set, &parm);
    4111                 :            :           /* If we found something that did not set a parameter reg,
    4112                 :            :              we're done.  Do not keep going, as that might result
    4113                 :            :              in hoisting an insn before the setting of a pseudo
    4114                 :            :              that is used by the hoisted insn. */
    4115                 :      36273 :           if (nregs_old != parm.nregs)
    4116                 :            :             first_set = before;
    4117                 :            :           else
    4118                 :            :             break;
    4119                 :            :         }
    4120                 :            :     }
    4121                 :      27990 :   return first_set;
    4122                 :            : }
    4123                 :            : 
    4124                 :            : /* Return true if we should avoid inserting code between INSN and preceding
    4125                 :            :    call instruction.  */
    4126                 :            : 
    4127                 :            : bool
    4128                 :    6741850 : keep_with_call_p (const rtx_insn *insn)
    4129                 :            : {
    4130                 :    6741850 :   rtx set;
    4131                 :            : 
    4132                 :    6741850 :   if (INSN_P (insn) && (set = single_set (insn)) != NULL)
    4133                 :            :     {
    4134                 :    4647910 :       if (REG_P (SET_DEST (set))
    4135                 :    1126090 :           && REGNO (SET_DEST (set)) < FIRST_PSEUDO_REGISTER
    4136                 :    1126090 :           && fixed_regs[REGNO (SET_DEST (set))]
    4137                 :    4802760 :           && general_operand (SET_SRC (set), VOIDmode))
    4138                 :            :         return true;
    4139                 :    4647700 :       if (REG_P (SET_SRC (set))
    4140                 :     516609 :           && targetm.calls.function_value_regno_p (REGNO (SET_SRC (set)))
    4141                 :     330851 :           && REG_P (SET_DEST (set))
    4142                 :    4759600 :           && REGNO (SET_DEST (set)) >= FIRST_PSEUDO_REGISTER)
    4143                 :            :         return true;
    4144                 :            :       /* There may be a stack pop just after the call and before the store
    4145                 :            :          of the return register.  Search for the actual store when deciding
    4146                 :            :          if we can break or not.  */
    4147                 :    4647700 :       if (SET_DEST (set) == stack_pointer_rtx)
    4148                 :            :         {
    4149                 :            :           /* This CONST_CAST is okay because next_nonnote_insn just
    4150                 :            :              returns its argument and we assign it to a const_rtx
    4151                 :            :              variable.  */
    4152                 :     153907 :           const rtx_insn *i2
    4153                 :     153907 :             = next_nonnote_insn (const_cast<rtx_insn *> (insn));
    4154                 :     153907 :           if (i2 && keep_with_call_p (i2))
    4155                 :          0 :             return true;
    4156                 :            :         }
    4157                 :            :     }
    4158                 :            :   return false;
    4159                 :            : }
    4160                 :            : 
    4161                 :            : /* Return true if LABEL is a target of JUMP_INSN.  This applies only
    4162                 :            :    to non-complex jumps.  That is, direct unconditional, conditional,
    4163                 :            :    and tablejumps, but not computed jumps or returns.  It also does
    4164                 :            :    not apply to the fallthru case of a conditional jump.  */
    4165                 :            : 
    4166                 :            : bool
    4167                 :   14623900 : label_is_jump_target_p (const_rtx label, const rtx_insn *jump_insn)
    4168                 :            : {
    4169                 :   14623900 :   rtx tmp = JUMP_LABEL (jump_insn);
    4170                 :   14623900 :   rtx_jump_table_data *table;
    4171                 :            : 
    4172                 :   14623900 :   if (label == tmp)
    4173                 :            :     return true;
    4174                 :            : 
    4175                 :    2518840 :   if (tablejump_p (jump_insn, NULL, &table))
    4176                 :            :     {
    4177                 :          0 :       rtvec vec = table->get_labels ();
    4178                 :          0 :       int i, veclen = GET_NUM_ELEM (vec);
    4179                 :            : 
    4180                 :          0 :       for (i = 0; i < veclen; ++i)
    4181                 :          0 :         if (XEXP (RTVEC_ELT (vec, i), 0) == label)
    4182                 :            :           return true;
    4183                 :            :     }
    4184                 :            : 
    4185                 :    2518840 :   if (find_reg_note (jump_insn, REG_LABEL_TARGET, label))
    4186                 :        458 :     return true;
    4187                 :            : 
    4188                 :            :   return false;
    4189                 :            : }
    4190                 :            : 
    4191                 :            : 
    4192                 :            : /* Return an estimate of the cost of computing rtx X.
    4193                 :            :    One use is in cse, to decide which expression to keep in the hash table.
    4194                 :            :    Another is in rtl generation, to pick the cheapest way to multiply.
    4195                 :            :    Other uses like the latter are expected in the future.
    4196                 :            : 
    4197                 :            :    X appears as operand OPNO in an expression with code OUTER_CODE.
    4198                 :            :    SPEED specifies whether costs optimized for speed or size should
    4199                 :            :    be returned.  */
    4200                 :            : 
    4201                 :            : int
    4202                 : 9000500000 : rtx_cost (rtx x, machine_mode mode, enum rtx_code outer_code,
    4203                 :            :           int opno, bool speed)
    4204                 :            : {
    4205                 : 9000500000 :   int i, j;
    4206                 : 9000500000 :   enum rtx_code code;
    4207                 : 9000500000 :   const char *fmt;
    4208                 : 9000500000 :   int total;
    4209                 : 9000500000 :   int factor;
    4210                 : 9000500000 :   unsigned mode_size;
    4211                 :            : 
    4212                 : 9000500000 :   if (x == 0)
    4213                 :            :     return 0;
    4214                 :            : 
    4215                 : 9000500000 :   if (GET_CODE (x) == SET)
    4216                 :            :     /* A SET doesn't have a mode, so let's look at the SET_DEST to get
    4217                 :            :        the mode for the factor.  */
    4218                 :   30353200 :     mode = GET_MODE (SET_DEST (x));
    4219                 : 8970150000 :   else if (GET_MODE (x) != VOIDmode)
    4220                 : 6901720000 :     mode = GET_MODE (x);
    4221                 :            : 
    4222                 :18001000000 :   mode_size = estimated_poly_value (GET_MODE_SIZE (mode));
    4223                 :            : 
    4224                 :            :   /* A size N times larger than UNITS_PER_WORD likely needs N times as
    4225                 :            :      many insns, taking N times as long.  */
    4226                 : 9437350000 :   factor = mode_size > UNITS_PER_WORD ? mode_size / UNITS_PER_WORD : 1;
    4227                 :            : 
    4228                 :            :   /* Compute the default costs of certain things.
    4229                 :            :      Note that targetm.rtx_costs can override the defaults.  */
    4230                 :            : 
    4231                 : 9000500000 :   code = GET_CODE (x);
    4232                 : 9000500000 :   switch (code)
    4233                 :            :     {
    4234                 : 1264660000 :     case MULT:
    4235                 :            :       /* Multiplication has time-complexity O(N*N), where N is the
    4236                 :            :          number of units (translated from digits) when using
    4237                 :            :          schoolbook long multiplication.  */
    4238                 : 1264660000 :       total = factor * factor * COSTS_N_INSNS (5);
    4239                 : 1264660000 :       break;
    4240                 :   52033300 :     case DIV:
    4241                 :   52033300 :     case UDIV:
    4242                 :   52033300 :     case MOD:
    4243                 :   52033300 :     case UMOD:
    4244                 :            :       /* Similarly, complexity for schoolbook long division.  */
    4245                 :   52033300 :       total = factor * factor * COSTS_N_INSNS (7);
    4246                 :   52033300 :       break;
    4247                 :          0 :     case USE:
    4248                 :            :       /* Used in combine.c as a marker.  */
    4249                 :          0 :       total = 0;
    4250                 :          0 :       break;
    4251                 : 7683810000 :     default:
    4252                 : 7683810000 :       total = factor * COSTS_N_INSNS (1);
    4253                 :            :     }
    4254                 :            : 
    4255                 : 9000500000 :   switch (code)
    4256                 :            :     {
    4257                 :            :     case REG:
    4258                 :            :       return 0;
    4259                 :            : 
    4260                 :    6027570 :     case SUBREG:
    4261                 :    6027570 :       total = 0;
    4262                 :            :       /* If we can't tie these modes, make this expensive.  The larger
    4263                 :            :          the mode, the more expensive it is.  */
    4264                 :    6027570 :       if (!targetm.modes_tieable_p (mode, GET_MODE (SUBREG_REG (x))))
    4265                 :    2190740 :         return COSTS_N_INSNS (2 + factor);
    4266                 :            :       break;
    4267                 :            : 
    4268                 :   12355200 :     case TRUNCATE:
    4269                 :   12355200 :       if (targetm.modes_tieable_p (mode, GET_MODE (XEXP (x, 0))))
    4270                 :            :         {
    4271                 :    2698800 :           total = 0;
    4272                 :    2698800 :           break;
    4273                 :            :         }
    4274                 :            :       /* FALLTHRU */
    4275                 : 5535500000 :     default:
    4276                 : 5535500000 :       if (targetm.rtx_costs (x, mode, outer_code, opno, &total, speed))
    4277                 : 2656920000 :         return total;
    4278                 :            :       break;
    4279                 :            :     }
    4280                 :            : 
    4281                 :            :   /* Sum the costs of the sub-rtx's, plus cost of this operation,
    4282                 :            :      which is already in total.  */
    4283                 :            : 
    4284                 : 2885110000 :   fmt = GET_RTX_FORMAT (code);
    4285                 : 8593020000 :   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
    4286                 : 5707910000 :     if (fmt[i] == 'e')
    4287                 : 5624100000 :       total += rtx_cost (XEXP (x, i), mode, code, i, speed);
    4288                 :   83813000 :     else if (fmt[i] == 'E')
    4289                 :   12295700 :       for (j = 0; j < XVECLEN (x, i); j++)
    4290                 :    6900840 :         total += rtx_cost (XVECEXP (x, i, j), mode, code, i, speed);
    4291                 :            : 
    4292                 : 2885110000 :   return total;
    4293                 :            : }
    4294                 :            : 
    4295                 :            : /* Fill in the structure C with information about both speed and size rtx
    4296                 :            :    costs for X, which is operand OPNO in an expression with code OUTER.  */
    4297                 :            : 
    4298                 :            : void
    4299                 :    1345760 : get_full_rtx_cost (rtx x, machine_mode mode, enum rtx_code outer, int opno,
    4300                 :            :                    struct full_rtx_costs *c)
    4301                 :            : {
    4302                 :    1345760 :   c->speed = rtx_cost (x, mode, outer, opno, true);
    4303                 :    1345760 :   c->size = rtx_cost (x, mode, outer, opno, false);
    4304                 :    1345760 : }
    4305                 :            : 
    4306                 :            : 
    4307                 :            : /* Return cost of address expression X.
    4308                 :            :    Expect that X is properly formed address reference.
    4309                 :            : 
    4310                 :            :    SPEED parameter specify whether costs optimized for speed or size should
    4311                 :            :    be returned.  */
    4312                 :            : 
    4313                 :            : int
    4314                 :    6678750 : address_cost (rtx x, machine_mode mode, addr_space_t as, bool speed)
    4315                 :            : {
    4316                 :            :   /* We may be asked for cost of various unusual addresses, such as operands
    4317                 :            :      of push instruction.  It is not worthwhile to complicate writing
    4318                 :            :      of the target hook by such cases.  */
    4319                 :            : 
    4320                 :    6678750 :   if (!memory_address_addr_space_p (mode, x, as))
    4321                 :            :     return 1000;
    4322                 :            : 
    4323                 :    6620770 :   return targetm.address_cost (x, mode, as, speed);
    4324                 :            : }
    4325                 :            : 
    4326                 :            : /* If the target doesn't override, compute the cost as with arithmetic.  */
    4327                 :            : 
    4328                 :            : int
    4329                 :          0 : default_address_cost (rtx x, machine_mode, addr_space_t, bool speed)
    4330                 :            : {
    4331                 :          0 :   return rtx_cost (x, Pmode, MEM, 0, speed);
    4332                 :            : }
    4333                 :            : 
    4334                 :            : 
    4335                 :            : unsigned HOST_WIDE_INT
    4336                 :  407249000 : nonzero_bits (const_rtx x, machine_mode mode)
    4337                 :            : {
    4338                 :  407249000 :   if (mode == VOIDmode)
    4339                 :          0 :     mode = GET_MODE (x);
    4340                 :  407249000 :   scalar_int_mode int_mode;
    4341                 :  407249000 :   if (!is_a <scalar_int_mode> (mode, &int_mode))
    4342                 :   11588900 :     return GET_MODE_MASK (mode);
    4343                 :  395660000 :   return cached_nonzero_bits (x, int_mode, NULL_RTX, VOIDmode, 0);
    4344                 :            : }
    4345                 :            : 
    4346                 :            : unsigned int
    4347                 :  148288000 : num_sign_bit_copies (const_rtx x, machine_mode mode)
    4348                 :            : {
    4349                 :  148288000 :   if (mode == VOIDmode)
    4350                 :          0 :     mode = GET_MODE (x);
    4351                 :  148288000 :   scalar_int_mode int_mode;
    4352                 :  148288000 :   if (!is_a <scalar_int_mode> (mode, &int_mode))
    4353                 :            :     return 1;
    4354                 :  136882000 :   return cached_num_sign_bit_copies (x, int_mode, NULL_RTX, VOIDmode, 0);
    4355                 :            : }
    4356                 :            : 
    4357                 :            : /* Return true if nonzero_bits1 might recurse into both operands
    4358                 :            :    of X.  */
    4359                 :            : 
    4360                 :            : static inline bool
    4361                 :  858753000 : nonzero_bits_binary_arith_p (const_rtx x)
    4362                 :            : {
    4363                 :  858753000 :   if (!ARITHMETIC_P (x))
    4364                 :            :     return false;
    4365                 :  154717000 :   switch (GET_CODE (x))
    4366                 :            :     {
    4367                 :            :     case AND:
    4368                 :            :     case XOR:
    4369                 :            :     case IOR:
    4370                 :            :     case UMIN:
    4371                 :            :     case UMAX:
    4372                 :            :     case SMIN:
    4373                 :            :     case SMAX:
    4374                 :            :     case PLUS:
    4375                 :            :     case MINUS:
    4376                 :            :     case MULT:
    4377                 :            :     case DIV:
    4378                 :            :     case UDIV:
    4379                 :            :     case MOD:
    4380                 :            :     case UMOD:
    4381                 :            :       return true;
    4382                 :            :     default:
    4383                 :            :       return false;
    4384                 :            :     }
    4385                 :            : }
    4386                 :            : 
    4387                 :            : /* The function cached_nonzero_bits is a wrapper around nonzero_bits1.
    4388                 :            :    It avoids exponential behavior in nonzero_bits1 when X has
    4389                 :            :    identical subexpressions on the first or the second level.  */
    4390                 :            : 
    4391                 :            : static unsigned HOST_WIDE_INT
    4392                 :  690297000 : cached_nonzero_bits (const_rtx x, scalar_int_mode mode, const_rtx known_x,
    4393                 :            :                      machine_mode known_mode,
    4394                 :            :                      unsigned HOST_WIDE_INT known_ret)
    4395                 :            : {
    4396                 :  690297000 :   if (x == known_x && mode == known_mode)
    4397                 :            :     return known_ret;
    4398                 :            : 
    4399                 :            :   /* Try to find identical subexpressions.  If found call
    4400                 :            :      nonzero_bits1 on X with the subexpressions as KNOWN_X and the
    4401                 :            :      precomputed value for the subexpression as KNOWN_RET.  */
    4402                 :            : 
    4403                 :  689424000 :   if (nonzero_bits_binary_arith_p (x))
    4404                 :            :     {
    4405                 :   84913700 :       rtx x0 = XEXP (x, 0);
    4406                 :   84913700 :       rtx x1 = XEXP (x, 1);
    4407                 :            : 
    4408                 :            :       /* Check the first level.  */
    4409                 :   84913700 :       if (x0 == x1)
    4410                 :      33859 :         return nonzero_bits1 (x, mode, x0, mode,
    4411                 :            :                               cached_nonzero_bits (x0, mode, known_x,
    4412                 :      33859 :                                                    known_mode, known_ret));
    4413                 :            : 
    4414                 :            :       /* Check the second level.  */
    4415                 :   84879800 :       if (nonzero_bits_binary_arith_p (x0)
    4416                 :   19278600 :           && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
    4417                 :     430922 :         return nonzero_bits1 (x, mode, x1, mode,
    4418                 :            :                               cached_nonzero_bits (x1, mode, known_x,
    4419                 :     430922 :                                                    known_mode, known_ret));
    4420                 :            : 
    4421                 :   84448900 :       if (nonzero_bits_binary_arith_p (x1)
    4422                 :     679365 :           && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
    4423                 :       2627 :         return nonzero_bits1 (x, mode, x0, mode,
    4424                 :            :                               cached_nonzero_bits (x0, mode, known_x,
    4425                 :       2627 :                                                    known_mode, known_ret));
    4426                 :            :     }
    4427                 :            : 
    4428                 :  688957000 :   return nonzero_bits1 (x, mode, known_x, known_mode, known_ret);
    4429                 :            : }
    4430                 :            : 
    4431                 :            : /* We let num_sign_bit_copies recur into nonzero_bits as that is useful.
    4432                 :            :    We don't let nonzero_bits recur into num_sign_bit_copies, because that
    4433                 :            :    is less useful.  We can't allow both, because that results in exponential
    4434                 :            :    run time recursion.  There is a nullstone testcase that triggered
    4435                 :            :    this.  This macro avoids accidental uses of num_sign_bit_copies.  */
    4436                 :            : #define cached_num_sign_bit_copies sorry_i_am_preventing_exponential_behavior
    4437                 :            : 
    4438                 :            : /* Given an expression, X, compute which bits in X can be nonzero.
    4439                 :            :    We don't care about bits outside of those defined in MODE.
    4440                 :            : 
    4441                 :            :    For most X this is simply GET_MODE_MASK (GET_MODE (X)), but if X is
    4442                 :            :    an arithmetic operation, we can do better.  */
    4443                 :            : 
    4444                 :            : static unsigned HOST_WIDE_INT
    4445                 :  689424000 : nonzero_bits1 (const_rtx x, scalar_int_mode mode, const_rtx known_x,
    4446                 :            :                machine_mode known_mode,
    4447                 :            :                unsigned HOST_WIDE_INT known_ret)
    4448                 :            : {
    4449                 :  689424000 :   unsigned HOST_WIDE_INT nonzero = GET_MODE_MASK (mode);
    4450                 :  689424000 :   unsigned HOST_WIDE_INT inner_nz;
    4451                 :  689424000 :   enum rtx_code code = GET_CODE (x);
    4452                 :  689424000 :   machine_mode inner_mode;
    4453                 :  689424000 :   unsigned int inner_width;
    4454                 :  689424000 :   scalar_int_mode xmode;
    4455                 :            : 
    4456                 :  689424000 :   unsigned int mode_width = GET_MODE_PRECISION (mode);
    4457                 :            : 
    4458                 :  689424000 :   if (CONST_INT_P (x))
    4459                 :            :     {
    4460                 :   70226200 :       if (SHORT_IMMEDIATES_SIGN_EXTEND
    4461                 :            :           && INTVAL (x) > 0
    4462                 :            :           && mode_width < BITS_PER_WORD
    4463                 :            :           && (UINTVAL (x) & (HOST_WIDE_INT_1U << (mode_width - 1))) != 0)
    4464                 :            :         return UINTVAL (x) | (HOST_WIDE_INT_M1U << mode_width);
    4465                 :            : 
    4466                 :   70226200 :       return UINTVAL (x);
    4467                 :            :     }
    4468                 :            : 
    4469                 :  619198000 :   if (!is_a <scalar_int_mode> (GET_MODE (x), &xmode))
    4470                 :            :     return nonzero;
    4471                 :  618899000 :   unsigned int xmode_width = GET_MODE_PRECISION (xmode);
    4472                 :            : 
    4473                 :            :   /* If X is wider than MODE, use its mode instead.  */
    4474                 :  618899000 :   if (xmode_width > mode_width)
    4475                 :            :     {
    4476                 :   15381700 :       mode = xmode;
    4477                 :   15381700 :       nonzero = GET_MODE_MASK (mode);
    4478                 :   15381700 :       mode_width = xmode_width;
    4479                 :            :     }
    4480                 :            : 
    4481                 :  618899000 :   if (mode_width > HOST_BITS_PER_WIDE_INT)
    4482                 :            :     /* Our only callers in this case look for single bit values.  So
    4483                 :            :        just return the mode mask.  Those tests will then be false.  */
    4484                 :            :     return nonzero;
    4485                 :            : 
    4486                 :            :   /* If MODE is wider than X, but both are a single word for both the host
    4487                 :            :      and target machines, we can compute this from which bits of the object
    4488                 :            :      might be nonzero in its own mode, taking into account the fact that, on
    4489                 :            :      CISC machines, accessing an object in a wider mode generally causes the
    4490                 :            :      high-order bits to become undefined, so they are not known to be zero.
    4491                 :            :      We extend this reasoning to RISC machines for operations that might not
    4492                 :            :      operate on the full registers.  */
    4493                 :  617580000 :   if (mode_width > xmode_width
    4494                 :   73701000 :       && xmode_width <= BITS_PER_WORD
    4495                 :            :       && xmode_width <= HOST_BITS_PER_WIDE_INT
    4496                 :            :       && !(WORD_REGISTER_OPERATIONS && word_register_operation_p (x)))
    4497                 :            :     {
    4498                 :   60697300 :       nonzero &= cached_nonzero_bits (x, xmode,
    4499                 :            :                                       known_x, known_mode, known_ret);
    4500                 :   60697300 :       nonzero |= GET_MODE_MASK (mode) & ~GET_MODE_MASK (xmode);
    4501                 :   60697300 :       return nonzero;
    4502                 :            :     }
    4503                 :            : 
    4504                 :            :   /* Please keep nonzero_bits_binary_arith_p above in sync with
    4505                 :            :      the code in the switch below.  */
    4506                 :  556883000 :   switch (code)
    4507                 :            :     {
    4508                 :  299503000 :     case REG:
    4509                 :            : #if defined(POINTERS_EXTEND_UNSIGNED)
    4510                 :            :       /* If pointers extend unsigned and this is a pointer in Pmode, say that
    4511                 :            :          all the bits above ptr_mode are known to be zero.  */
    4512                 :            :       /* As we do not know which address space the pointer is referring to,
    4513                 :            :          we can do this only if the target does not support different pointer
    4514                 :            :          or address modes depending on the address space.  */
    4515                 :  299503000 :       if (target_default_pointer_address_modes_p ()
    4516                 :            :           && POINTERS_EXTEND_UNSIGNED
    4517                 :  343344000 :           && xmode == Pmode
    4518                 :  190168000 :           && REG_POINTER (x)
    4519                 :  345247000 :           && !targetm.have_ptr_extend ())
    4520                 :   45744100 :         nonzero &= GET_MODE_MASK (ptr_mode);
    4521                 :            : #endif
    4522                 :            : 
    4523                 :            :       /* Include declared information about alignment of pointers.  */
    4524                 :            :       /* ??? We don't properly preserve REG_POINTER changes across
    4525                 :            :          pointer-to-integer casts, so we can't trust it except for
    4526                 :            :          things that we know must be pointers.  See execute/960116-1.c.  */
    4527                 :  299503000 :       if ((x == stack_pointer_rtx
    4528                 :  299090000 :            || x == frame_pointer_rtx
    4529                 :  289777000 :            || x == arg_pointer_rtx)
    4530                 :  309076000 :           && REGNO_POINTER_ALIGN (REGNO (x)))
    4531                 :            :         {
    4532                 :    9985840 :           unsigned HOST_WIDE_INT alignment
    4533                 :    9985840 :             = REGNO_POINTER_ALIGN (REGNO (x)) / BITS_PER_UNIT;
    4534                 :            : 
    4535                 :            : #ifdef PUSH_ROUNDING
    4536                 :            :           /* If PUSH_ROUNDING is defined, it is possible for the
    4537                 :            :              stack to be momentarily aligned only to that amount,
    4538                 :            :              so we pick the least alignment.  */
    4539                 :    9985840 :           if (x == stack_pointer_rtx && PUSH_ARGS)
    4540                 :            :             {
    4541                 :     213169 :               poly_uint64 rounded_1 = PUSH_ROUNDING (poly_int64 (1));
    4542                 :     213169 :               alignment = MIN (known_alignment (rounded_1), alignment);
    4543                 :            :             }
    4544                 :            : #endif
    4545                 :            : 
    4546                 :    9985840 :           nonzero &= ~(alignment - 1);
    4547                 :            :         }
    4548                 :            : 
    4549                 :  299503000 :       {
    4550                 :  299503000 :         unsigned HOST_WIDE_INT nonzero_for_hook = nonzero;
    4551                 :  299503000 :         rtx new_rtx = rtl_hooks.reg_nonzero_bits (x, xmode, mode,
    4552                 :            :                                                   &nonzero_for_hook);
    4553                 :            : 
    4554                 :  299503000 :         if (new_rtx)
    4555                 :          0 :           nonzero_for_hook &= cached_nonzero_bits (new_rtx, mode, known_x,
    4556                 :            :                                                    known_mode, known_ret);
    4557                 :            : 
    4558                 :  299503000 :         return nonzero_for_hook;
    4559                 :            :       }
    4560                 :            : 
    4561                 :            :     case MEM:
    4562                 :            :       /* In many, if not most, RISC machines, reading a byte from memory
    4563                 :            :          zeros the rest of the register.  Noticing that fact saves a lot
    4564                 :            :          of extra zero-extends.  */
    4565                 :  689424000 :       if (load_extend_op (xmode) == ZERO_EXTEND)
    4566                 :            :         nonzero &= GET_MODE_MASK (xmode);
    4567                 :            :       break;
    4568                 :            : 
    4569                 :    4422900 :     case EQ:  case NE:
    4570                 :    4422900 :     case UNEQ:  case LTGT:
    4571                 :    4422900 :     case GT:  case GTU:  case UNGT:
    4572                 :    4422900 :     case LT:  case LTU:  case UNLT:
    4573                 :    4422900 :     case GE:  case GEU:  case UNGE:
    4574                 :    4422900 :     case LE:  case LEU:  case UNLE:
    4575                 :    4422900 :     case UNORDERED: case ORDERED:
    4576                 :            :       /* If this produces an integer result, we know which bits are set.
    4577                 :            :          Code here used to clear bits outside the mode of X, but that is
    4578                 :            :          now done above.  */
    4579                 :            :       /* Mind that MODE is the mode the caller wants to look at this
    4580                 :            :          operation in, and not the actual operation mode.  We can wind
    4581                 :            :          up with (subreg:DI (gt:V4HI x y)), and we don't have anything
    4582                 :            :          that describes the results of a vector compare.  */
    4583                 :    4422900 :       if (GET_MODE_CLASS (xmode) == MODE_INT
    4584                 :    4422900 :           && mode_width <= HOST_BITS_PER_WIDE_INT)
    4585                 :            :         nonzero = STORE_FLAG_VALUE;
    4586                 :            :       break;
    4587                 :            : 
    4588                 :     655089 :     case NEG:
    4589                 :            : #if 0
    4590                 :            :       /* Disabled to avoid exponential mutual recursion between nonzero_bits
    4591                 :            :          and num_sign_bit_copies.  */
    4592                 :            :       if (num_sign_bit_copies (XEXP (x, 0), xmode) == xmode_width)
    4593                 :            :         nonzero = 1;
    4594                 :            : #endif
    4595                 :            : 
    4596                 :     655089 :       if (xmode_width < mode_width)
    4597                 :          0 :         nonzero |= (GET_MODE_MASK (mode) & ~GET_MODE_MASK (xmode));
    4598                 :            :       break;
    4599                 :            : 
    4600                 :            :     case ABS:
    4601                 :            : #if 0
    4602                 :            :       /* Disabled to avoid exponential mutual recursion between nonzero_bits
    4603                 :            :          and num_sign_bit_copies.  */
    4604                 :            :       if (num_sign_bit_copies (XEXP (x, 0), xmode) == xmode_width)
    4605                 :            :         nonzero = 1;
    4606                 :            : #endif
    4607                 :            :       break;
    4608                 :            : 
    4609                 :     797489 :     case TRUNCATE:
    4610                 :     797489 :       nonzero &= (cached_nonzero_bits (XEXP (x, 0), mode,
    4611                 :            :                                        known_x, known_mode, known_ret)
    4612                 :     797489 :                   & GET_MODE_MASK (mode));
    4613                 :     797489 :       break;
    4614                 :            : 
    4615                 :    3572540 :     case ZERO_EXTEND:
    4616                 :    3572540 :       nonzero &= cached_nonzero_bits (XEXP (x, 0), mode,
    4617                 :            :                                       known_x, known_mode, known_ret);
    4618                 :    3572540 :       if (GET_MODE (XEXP (x, 0)) != VOIDmode)
    4619                 :    3572540 :         nonzero &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
    4620                 :            :       break;
    4621                 :            : 
    4622                 :    1625680 :     case SIGN_EXTEND:
    4623                 :            :       /* If the sign bit is known clear, this is the same as ZERO_EXTEND.
    4624                 :            :          Otherwise, show all the bits in the outer mode but not the inner
    4625                 :            :          may be nonzero.  */
    4626                 :    1625680 :       inner_nz = cached_nonzero_bits (XEXP (x, 0), mode,
    4627                 :            :                                       known_x, known_mode, known_ret);
    4628                 :    1625680 :       if (GET_MODE (XEXP (x, 0)) != VOIDmode)
    4629                 :            :         {
    4630                 :    1625680 :           inner_nz &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
    4631                 :    1625680 :           if (val_signbit_known_set_p (GET_MODE (XEXP (x, 0)), inner_nz))
    4632                 :    1519380 :             inner_nz |= (GET_MODE_MASK (mode)
    4633                 :    1519380 :                          & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0))));
    4634                 :            :         }
    4635                 :            : 
    4636                 :    1625680 :       nonzero &= inner_nz;
    4637                 :    1625680 :       break;
    4638                 :            : 
    4639                 :    8143000 :     case AND:
    4640                 :    8143000 :       nonzero &= cached_nonzero_bits (XEXP (x, 0), mode,
    4641                 :            :                                        known_x, known_mode, known_ret)
    4642                 :    8143000 :                  & cached_nonzero_bits (XEXP (x, 1), mode,
    4643                 :            :                                         known_x, known_mode, known_ret);
    4644                 :    8143000 :       break;
    4645                 :            : 
    4646                 :    5351950 :     case XOR:   case IOR:
    4647                 :    5351950 :     case UMIN:  case UMAX:  case SMIN:  case SMAX:
    4648                 :    5351950 :       {
    4649                 :    5351950 :         unsigned HOST_WIDE_INT nonzero0
    4650                 :    5351950 :            = cached_nonzero_bits (XEXP (x, 0), mode,
    4651                 :            :                                   known_x, known_mode, known_ret);
    4652                 :            : 
    4653                 :            :         /* Don't call nonzero_bits for the second time if it cannot change
    4654                 :            :            anything.  */
    4655                 :    5351950 :         if ((nonzero & nonzero0) != nonzero)
    4656                 :    4328600 :           nonzero &= nonzero0
    4657                 :    2164300 :                      | cached_nonzero_bits (XEXP (x, 1), mode,
    4658                 :            :                                             known_x, known_mode, known_ret);
    4659                 :            :       }
    4660                 :            :       break;
    4661                 :            : 
    4662                 :   58342500 :     case PLUS:  case MINUS:
    4663                 :   58342500 :     case MULT:
    4664                 :   58342500 :     case DIV:   case UDIV:
    4665                 :   58342500 :     case MOD:   case UMOD:
    4666                 :            :       /* We can apply the rules of arithmetic to compute the number of
    4667                 :            :          high- and low-order zero bits of these operations.  We start by
    4668                 :            :          computing the width (position of the highest-order nonzero bit)
    4669                 :            :          and the number of low-order zero bits for each value.  */
    4670                 :   58342500 :       {
    4671                 :   58342500 :         unsigned HOST_WIDE_INT nz0
    4672                 :   58342500 :           = cached_nonzero_bits (XEXP (x, 0), mode,
    4673                 :            :                                  known_x, known_mode, known_ret);
    4674                 :   58342500 :         unsigned HOST_WIDE_INT nz1
    4675                 :   58342500 :           = cached_nonzero_bits (XEXP (x, 1), mode,
    4676                 :            :                                  known_x, known_mode, known_ret);
    4677                 :   58342500 :         int sign_index = xmode_width - 1;
    4678                 :   58342500 :         int width0 = floor_log2 (nz0) + 1;
    4679                 :   58342500 :         int width1 = floor_log2 (nz1) + 1;
    4680                 :   58342500 :         int low0 = ctz_or_zero (nz0);
    4681                 :   58342500 :         int low1 = ctz_or_zero (nz1);
    4682                 :   58342500 :         unsigned HOST_WIDE_INT op0_maybe_minusp
    4683                 :   58342500 :           = nz0 & (HOST_WIDE_INT_1U << sign_index);
    4684                 :   58342500 :         unsigned HOST_WIDE_INT op1_maybe_minusp
    4685                 :            :           = nz1 & (HOST_WIDE_INT_1U << sign_index);
    4686                 :   58342500 :         unsigned int result_width = mode_width;
    4687                 :   58342500 :         int result_low = 0;
    4688                 :            : 
    4689                 :   58342500 :         switch (code)
    4690                 :            :           {
    4691                 :   43962000 :           case PLUS:
    4692                 :   43962000 :             result_width = MAX (width0, width1) + 1;
    4693                 :   43962000 :             result_low = MIN (low0, low1);
    4694                 :            :             break;
    4695                 :    7839350 :           case MINUS:
    4696                 :    7839350 :             result_low = MIN (low0, low1);
    4697                 :            :             break;
    4698                 :    5188100 :           case MULT:
    4699                 :    5188100 :             result_width = width0 + width1;
    4700                 :    5188100 :             result_low = low0 + low1;
    4701                 :    5188100 :             break;
    4702                 :     521248 :           case DIV:
    4703                 :     521248 :             if (width1 == 0)
    4704                 :            :               break;
    4705                 :     518934 :             if (!op0_maybe_minusp && !op1_maybe_minusp)
    4706                 :      22127 :               result_width = width0;
    4707                 :            :             break;
    4708                 :     178756 :           case UDIV:
    4709                 :     178756 :             if (width1 == 0)
    4710                 :            :               break;
    4711                 :     178049 :             result_width = width0;
    4712                 :     178049 :             break;
    4713                 :     372574 :           case MOD:
    4714                 :     372574 :             if (width1 == 0)
    4715                 :            :               break;
    4716                 :     371623 :             if (!op0_maybe_minusp && !op1_maybe_minusp)
    4717                 :      25962 :               result_width = MIN (width0, width1);
    4718                 :     371623 :             result_low = MIN (low0, low1);
    4719                 :            :             break;
    4720                 :     280512 :           case UMOD:
    4721                 :     280512 :             if (width1 == 0)
    4722                 :            :               break;
    4723                 :     280341 :             result_width = MIN (width0, width1);
    4724                 :     280341 :             result_low = MIN (low0, low1);
    4725                 :            :             break;
    4726                 :          0 :           default:
    4727                 :          0 :             gcc_unreachable ();
    4728                 :            :           }
    4729                 :            : 
    4730                 :   58342500 :         if (result_width < mode_width)
    4731                 :    1862210 :           nonzero &= (HOST_WIDE_INT_1U << result_width) - 1;
    4732                 :            : 
    4733                 :   58342500 :         if (result_low > 0)
    4734                 :    4864330 :           nonzero &= ~((HOST_WIDE_INT_1U << result_low) - 1);
    4735                 :            :       }
    4736                 :            :       break;
    4737                 :            : 
    4738                 :     453605 :     case ZERO_EXTRACT:
    4739                 :     453605 :       if (CONST_INT_P (XEXP (x, 1))
    4740                 :     453279 :           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
    4741                 :     453173 :         nonzero &= (HOST_WIDE_INT_1U << INTVAL (XEXP (x, 1))) - 1;
    4742                 :            :       break;
    4743                 :            : 
    4744                 :   50478500 :     case SUBREG:
    4745                 :            :       /* If this is a SUBREG formed for a promoted variable that has
    4746                 :            :          been zero-extended, we know that at least the high-order bits
    4747                 :            :          are zero, though others might be too.  */
    4748                 :   50478500 :       if (SUBREG_PROMOTED_VAR_P (x) && SUBREG_PROMOTED_UNSIGNED_P (x))
    4749                 :        135 :         nonzero = GET_MODE_MASK (xmode)
    4750                 :        135 :                   & cached_nonzero_bits (SUBREG_REG (x), xmode,
    4751                 :            :                                          known_x, known_mode, known_ret);
    4752                 :            : 
    4753                 :            :       /* If the inner mode is a single word for both the host and target
    4754                 :            :          machines, we can compute this from which bits of the inner
    4755                 :            :          object might be nonzero.  */
    4756                 :   50478500 :       inner_mode = GET_MODE (SUBREG_REG (x));
    4757                 :   50478500 :       if (GET_MODE_PRECISION (inner_mode).is_constant (&inner_width)
    4758                 :   54194500 :           && inner_width <= BITS_PER_WORD
    4759                 :            :           && inner_width <= HOST_BITS_PER_WIDE_INT)
    4760                 :            :         {
    4761                 :   47106600 :           nonzero &= cached_nonzero_bits (SUBREG_REG (x), mode,
    4762                 :            :                                           known_x, known_mode, known_ret);
    4763                 :            : 
    4764                 :            :           /* On a typical CISC machine, accessing an object in a wider mode
    4765                 :            :              causes the high-order bits to become undefined.  So they are
    4766                 :            :              not known to be zero.
    4767                 :            : 
    4768                 :            :              On a typical RISC machine, we only have to worry about the way
    4769                 :            :              loads are extended.  Otherwise, if we get a reload for the inner
    4770                 :            :              part, it may be loaded from the stack, and then we may lose all
    4771                 :            :              the zero bits that existed before the store to the stack.  */
    4772                 :   47106600 :           rtx_code extend_op;
    4773                 :   47106600 :           if ((!WORD_REGISTER_OPERATIONS
    4774                 :            :                || ((extend_op = load_extend_op (inner_mode)) == SIGN_EXTEND
    4775                 :            :                    ? val_signbit_known_set_p (inner_mode, nonzero)
    4776                 :            :                    : extend_op != ZERO_EXTEND)
    4777                 :            :                || !MEM_P (SUBREG_REG (x)))
    4778                 :            :               && xmode_width > inner_width)
    4779                 :   33917500 :             nonzero
    4780                 :   33917500 :               |= (GET_MODE_MASK (GET_MODE (x)) & ~GET_MODE_MASK (inner_mode));
    4781                 :            :         }
    4782                 :            :       break;
    4783                 :            : 
    4784                 :   36854100 :     case ASHIFT:
    4785                 :   36854100 :     case ASHIFTRT:
    4786                 :   36854100 :     case LSHIFTRT:
    4787                 :   36854100 :     case ROTATE:
    4788                 :   36854100 :     case ROTATERT:
    4789                 :            :       /* The nonzero bits are in two classes: any bits within MODE
    4790                 :            :          that aren't in xmode are always significant.  The rest of the
    4791                 :            :          nonzero bits are those that are significant in the operand of
    4792                 :            :          the shift when shifted the appropriate number of bits.  This
    4793                 :            :          shows that high-order bits are cleared by the right shift and
    4794                 :            :          low-order bits by left shifts.  */
    4795                 :   36854100 :       if (CONST_INT_P (XEXP (x, 1))
    4796                 :   35784000 :           && INTVAL (XEXP (x, 1)) >= 0
    4797                 :   35780000 :           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
    4798                 :   35779600 :           && INTVAL (XEXP (x, 1)) < xmode_width)
    4799                 :            :         {
    4800                 :   35778900 :           int count = INTVAL (XEXP (x, 1));
    4801                 :   35778900 :           unsigned HOST_WIDE_INT mode_mask = GET_MODE_MASK (xmode);
    4802                 :   35778900 :           unsigned HOST_WIDE_INT op_nonzero
    4803                 :   35778900 :             = cached_nonzero_bits (XEXP (x, 0), mode,
    4804                 :            :                                    known_x, known_mode, known_ret);
    4805                 :   35778900 :           unsigned HOST_WIDE_INT inner = op_nonzero & mode_mask;
    4806                 :   35778900 :           unsigned HOST_WIDE_INT outer = 0;
    4807                 :            : 
    4808                 :   35778900 :           if (mode_width > xmode_width)
    4809                 :          0 :             outer = (op_nonzero & nonzero & ~mode_mask);
    4810                 :            : 
    4811                 :   35778900 :           switch (code)
    4812                 :            :             {
    4813                 :   21386200 :             case ASHIFT:
    4814                 :   21386200 :               inner <<= count;
    4815                 :   21386200 :               break;
    4816                 :            : 
    4817                 :    7946910 :             case LSHIFTRT:
    4818                 :    7946910 :               inner >>= count;
    4819                 :    7946910 :               break;
    4820                 :            : 
    4821                 :    6346530 :             case ASHIFTRT:
    4822                 :    6346530 :               inner >>= count;
    4823                 :            : 
    4824                 :            :               /* If the sign bit may have been nonzero before the shift, we
    4825                 :            :                  need to mark all the places it could have been copied to
    4826                 :            :                  by the shift as possibly nonzero.  */
    4827                 :    6346530 :               if (inner & (HOST_WIDE_INT_1U << (xmode_width - 1 - count)))
    4828                 :    6330950 :                 inner |= (((HOST_WIDE_INT_1U << count) - 1)
    4829                 :    6330950 :                           << (xmode_width - count));
    4830                 :            :               break;
    4831                 :            : 
    4832                 :      73098 :             case ROTATE:
    4833                 :      73098 :               inner = (inner << (count % xmode_width)
    4834                 :      73098 :                        | (inner >> (xmode_width - (count % xmode_width))))
    4835                 :            :                       & mode_mask;
    4836                 :      73098 :               break;
    4837                 :            : 
    4838                 :      26122 :             case ROTATERT:
    4839                 :      26122 :               inner = (inner >> (count % xmode_width)
    4840                 :      26122 :                        | (inner << (xmode_width - (count % xmode_width))))
    4841                 :            :                       & mode_mask;
    4842                 :      26122 :               break;
    4843                 :            : 
    4844                 :          0 :             default:
    4845                 :          0 :               gcc_unreachable ();
    4846                 :            :             }
    4847                 :            : 
    4848                 :   35778900 :           nonzero &= (outer | inner);
    4849                 :            :         }
    4850                 :            :       break;
    4851                 :            : 
    4852                 :       1720 :     case FFS:
    4853                 :       1720 :     case POPCOUNT:
    4854                 :            :       /* This is at most the number of bits in the mode.  */
    4855                 :       1720 :       nonzero = ((unsigned HOST_WIDE_INT) 2 << (floor_log2 (mode_width))) - 1;
    4856                 :       1720 :       break;
    4857                 :            : 
    4858                 :     137261 :     case CLZ:
    4859                 :            :       /* If CLZ has a known value at zero, then the nonzero bits are
    4860                 :            :          that value, plus the number of bits in the mode minus one.  */
    4861                 :     274522 :       if (CLZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
    4862                 :        182 :         nonzero
    4863                 :        364 :           |= (HOST_WIDE_INT_1U << (floor_log2 (mode_width))) - 1;
    4864                 :            :       else
    4865                 :            :         nonzero = -1;
    4866                 :            :       break;
    4867                 :            : 
    4868                 :      18596 :     case CTZ:
    4869                 :            :       /* If CTZ has a known value at zero, then the nonzero bits are
    4870                 :            :          that value, plus the number of bits in the mode minus one.  */
    4871                 :      37192 :       if (CTZ_DEFINED_VALUE_AT_ZERO (mode, nonzero))
    4872                 :        168 :         nonzero
    4873                 :        336 :           |= (HOST_WIDE_INT_1U << (floor_log2 (mode_width))) - 1;
    4874                 :            :       else
    4875                 :            :         nonzero = -1;
    4876                 :            :       break;
    4877                 :            : 
    4878                 :          0 :     case CLRSB:
    4879                 :            :       /* This is at most the number of bits in the mode minus 1.  */
    4880                 :          0 :       nonzero = (HOST_WIDE_INT_1U << (floor_log2 (mode_width))) - 1;
    4881                 :          0 :       break;
    4882                 :            : 
    4883                 :          0 :     case PARITY:
    4884                 :          0 :       nonzero = 1;
    4885                 :          0 :       break;
    4886                 :            : 
    4887                 :    2839300 :     case IF_THEN_ELSE:
    4888                 :    2839300 :       {
    4889                 :    2839300 :         unsigned HOST_WIDE_INT nonzero_true
    4890                 :    2839300 :           = cached_nonzero_bits (XEXP (x, 1), mode,
    4891                 :            :                                  known_x, known_mode, known_ret);
    4892                 :            : 
    4893                 :            :         /* Don't call nonzero_bits for the second time if it cannot change
    4894                 :            :            anything.  */
    4895                 :    2839300 :         if ((nonzero & nonzero_true) != nonzero)
    4896                 :    2528250 :           nonzero &= nonzero_true
    4897                 :    1264120 :                      | cached_nonzero_bits (XEXP (x, 2), mode,
    4898                 :            :                                             known_x, known_mode, known_ret);
    4899                 :            :       }
    4900                 :            :       break;
    4901                 :            : 
    4902                 :            :     default:
    4903                 :            :       break;
    4904                 :            :     }
    4905                 :            : 
    4906                 :            :   return nonzero;
    4907                 :            : }
    4908                 :            : 
    4909                 :            : /* See the macro definition above.  */
    4910                 :            : #undef cached_num_sign_bit_copies
    4911                 :            : 
    4912                 :            : 
    4913                 :            : /* Return true if num_sign_bit_copies1 might recurse into both operands
    4914                 :            :    of X.  */
    4915                 :            : 
    4916                 :            : static inline bool
    4917                 :  284250000 : num_sign_bit_copies_binary_arith_p (const_rtx x)
    4918                 :            : {
    4919                 :  284250000 :   if (!ARITHMETIC_P (x))
    4920                 :            :     return false;
    4921                 :   55825600 :   switch (GET_CODE (x))
    4922                 :            :     {
    4923                 :            :     case IOR:
    4924                 :            :     case AND:
    4925                 :            :     case XOR:
    4926                 :            :     case SMIN:
    4927                 :            :     case SMAX:
    4928                 :            :     case UMIN:
    4929                 :            :     case UMAX:
    4930                 :            :     case PLUS:
    4931                 :            :     case MINUS:
    4932                 :            :     case MULT:
    4933                 :            :       return true;
    4934                 :            :     default:
    4935                 :            :       return false;
    4936                 :            :     }
    4937                 :            : }
    4938                 :            : 
    4939                 :            : /* The function cached_num_sign_bit_copies is a wrapper around
    4940                 :            :    num_sign_bit_copies1.  It avoids exponential behavior in
    4941                 :            :    num_sign_bit_copies1 when X has identical subexpressions on the
    4942                 :            :    first or the second level.  */
    4943                 :            : 
    4944                 :            : static unsigned int
    4945                 :  220402000 : cached_num_sign_bit_copies (const_rtx x, scalar_int_mode mode,
    4946                 :            :                             const_rtx known_x, machine_mode known_mode,
    4947                 :            :                             unsigned int known_ret)
    4948                 :            : {
    4949                 :  220402000 :   if (x == known_x && mode == known_mode)
    4950                 :            :     return known_ret;
    4951                 :            : 
    4952                 :            :   /* Try to find identical subexpressions.  If found call
    4953                 :            :      num_sign_bit_copies1 on X with the subexpressions as KNOWN_X and
    4954                 :            :      the precomputed value for the subexpression as KNOWN_RET.  */
    4955                 :            : 
    4956                 :  219743000 :   if (num_sign_bit_copies_binary_arith_p (x))
    4957                 :            :     {
    4958                 :   32417800 :       rtx x0 = XEXP (x, 0);
    4959                 :   32417800 :       rtx x1 = XEXP (x, 1);
    4960                 :            : 
    4961                 :            :       /* Check the first level.  */
    4962                 :   32417800 :       if (x0 == x1)
    4963                 :       8222 :         return
    4964                 :       8222 :           num_sign_bit_copies1 (x, mode, x0, mode,
    4965                 :            :                                 cached_num_sign_bit_copies (x0, mode, known_x,
    4966                 :            :                                                             known_mode,
    4967                 :       8222 :                                                             known_ret));
    4968                 :            : 
    4969                 :            :       /* Check the second level.  */
    4970                 :   32409600 :       if (num_sign_bit_copies_binary_arith_p (x0)
    4971                 :   12409600 :           && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
    4972                 :     311808 :         return
    4973                 :     311808 :           num_sign_bit_copies1 (x, mode, x1, mode,
    4974                 :            :                                 cached_num_sign_bit_copies (x1, mode, known_x,
    4975                 :            :                                                             known_mode,
    4976                 :     311808 :                                                             known_ret));
    4977                 :            : 
    4978                 :   32097800 :       if (num_sign_bit_copies_binary_arith_p (x1)
    4979                 :     250640 :           && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
    4980                 :         13 :         return
    4981                 :         13 :           num_sign_bit_copies1 (x, mode, x0, mode,
    4982                 :            :                                 cached_num_sign_bit_copies (x0, mode, known_x,
    4983                 :            :                                                             known_mode,
    4984                 :         13 :                                                             known_ret));
    4985                 :            :     }
    4986                 :            : 
    4987                 :  219423000 :   return num_sign_bit_copies1 (x, mode, known_x, known_mode, known_ret);
    4988                 :            : }
    4989                 :            : 
    4990                 :            : /* Return the number of bits at the high-order end of X that are known to
    4991                 :            :    be equal to the sign bit.  X will be used in mode MODE.  The returned
    4992                 :            :    value will always be between 1 and the number of bits in MODE.  */
    4993                 :            : 
    4994                 :            : static unsigned int
    4995                 :  219743000 : num_sign_bit_copies1 (const_rtx x, scalar_int_mode mode, const_rtx known_x,
    4996                 :            :                       machine_mode known_mode,
    4997                 :            :                       unsigned int known_ret)
    4998                 :            : {
    4999                 :  219743000 :   enum rtx_code code = GET_CODE (x);
    5000                 :  219743000 :   unsigned int bitwidth = GET_MODE_PRECISION (mode);
    5001                 :  219743000 :   int num0, num1, result;
    5002                 :  219743000 :   unsigned HOST_WIDE_INT nonzero;
    5003                 :            : 
    5004                 :  219743000 :   if (CONST_INT_P (x))
    5005                 :            :     {
    5006                 :            :       /* If the constant is negative, take its 1's complement and remask.
    5007                 :            :          Then see how many zero bits we have.  */
    5008                 :   29385200 :       nonzero = UINTVAL (x) & GET_MODE_MASK (mode);
    5009                 :   29385200 :       if (bitwidth <= HOST_BITS_PER_WIDE_INT
    5010                 :   29298200 :           && (nonzero & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0)
    5011                 :   13462200 :         nonzero = (~nonzero) & GET_MODE_MASK (mode);
    5012                 :            : 
    5013                 :   29385200 :       return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
    5014                 :            :     }
    5015                 :            : 
    5016                 :  190358000 :   scalar_int_mode xmode, inner_mode;
    5017                 :  190358000 :   if (!is_a <scalar_int_mode> (GET_MODE (x), &xmode))
    5018                 :            :     return 1;
    5019                 :            : 
    5020                 :  190308000 :   unsigned int xmode_width = GET_MODE_PRECISION (xmode);
    5021                 :            : 
    5022                 :            :   /* For a smaller mode, just ignore the high bits.  */
    5023                 :  190308000 :   if (bitwidth < xmode_width)
    5024                 :            :     {
    5025                 :     123127 :       num0 = cached_num_sign_bit_copies (x, xmode,
    5026                 :            :                                          known_x, known_mode, known_ret);
    5027                 :     123127 :       return MAX (1, num0 - (int) (xmode_width - bitwidth));
    5028                 :            :     }
    5029                 :            : 
    5030                 :  190184000 :   if (bitwidth > xmode_width)
    5031                 :            :     {
    5032                 :            :       /* If this machine does not do all register operations on the entire
    5033                 :            :          register and MODE is wider than the mode of X, we can say nothing
    5034                 :            :          at all about the high-order bits.  We extend this reasoning to RISC
    5035                 :            :          machines for operations that might not operate on full registers.  */
    5036                 :            :       if (!(WORD_REGISTER_OPERATIONS && word_register_operation_p (x)))
    5037                 :            :         return 1;
    5038                 :            : 
    5039                 :            :       /* Likewise on machines that do, if the mode of the object is smaller
    5040                 :            :          than a word and loads of that size don't sign extend, we can say
    5041                 :            :          nothing about the high order bits.  */
    5042                 :            :       if (xmode_width < BITS_PER_WORD
    5043                 :            :           && load_extend_op (xmode) != SIGN_EXTEND)
    5044                 :            :         return 1;
    5045                 :            :     }
    5046                 :            : 
    5047                 :            :   /* Please keep num_sign_bit_copies_binary_arith_p above in sync with
    5048                 :            :      the code in the switch below.  */
    5049                 :  190184000 :   switch (code)
    5050                 :            :     {
    5051                 :   94220600 :     case REG:
    5052                 :            : 
    5053                 :            : #if defined(POINTERS_EXTEND_UNSIGNED)
    5054                 :            :       /* If pointers extend signed and this is a pointer in Pmode, say that
    5055                 :            :          all the bits above ptr_mode are known to be sign bit copies.  */
    5056                 :            :       /* As we do not know which address space the pointer is referring to,
    5057                 :            :          we can do this only if the target does not support different pointer
    5058                 :            :          or address modes depending on the address space.  */
    5059                 :   94220600 :       if (target_default_pointer_address_modes_p ()
    5060                 :            :           && ! POINTERS_EXTEND_UNSIGNED && xmode == Pmode
    5061                 :            :           && mode == Pmode && REG_POINTER (x)
    5062                 :            :           && !targetm.have_ptr_extend ())
    5063                 :            :         return GET_MODE_PRECISION (Pmode) - GET_MODE_PRECISION (ptr_mode) + 1;
    5064                 :            : #endif
    5065                 :            : 
    5066                 :   94220600 :       {
    5067                 :   94220600 :         unsigned int copies_for_hook = 1, copies = 1;
    5068                 :   94220600 :         rtx new_rtx = rtl_hooks.reg_num_sign_bit_copies (x, xmode, mode,
    5069                 :            :                                                          &copies_for_hook);
    5070                 :            : 
    5071                 :   94220600 :         if (new_rtx)
    5072                 :          2 :           copies = cached_num_sign_bit_copies (new_rtx, mode, known_x,
    5073                 :            :                                                known_mode, known_ret);
    5074                 :            : 
    5075                 :   94220600 :         if (copies > 1 || copies_for_hook > 1)
    5076                 :   14243600 :           return MAX (copies, copies_for_hook);
    5077                 :            : 
    5078                 :            :         /* Else, use nonzero_bits to guess num_sign_bit_copies (see below).  */
    5079                 :            :       }
    5080                 :   79977100 :       break;
    5081                 :            : 
    5082                 :            :     case MEM:
    5083                 :            :       /* Some RISC machines sign-extend all loads of smaller than a word.  */
    5084                 :  124354000 :       if (load_extend_op (xmode) == SIGN_EXTEND)
    5085                 :            :         return MAX (1, ((int) bitwidth - (int) xmode_width + 1));
    5086                 :            :       break;
    5087                 :            : 
    5088                 :   15593200 :     case SUBREG:
    5089                 :            :       /* If this is a SUBREG for a promoted object that is sign-extended
    5090                 :            :          and we are looking at it in a wider mode, we know that at least the
    5091                 :            :          high-order bits are known to be sign bit copies.  */
    5092                 :            : 
    5093                 :   15593200 :       if (SUBREG_PROMOTED_VAR_P (x) && SUBREG_PROMOTED_SIGNED_P (x))
    5094                 :            :         {
    5095                 :          0 :           num0 = cached_num_sign_bit_copies (SUBREG_REG (x), mode,
    5096                 :            :                                              known_x, known_mode, known_ret);
    5097                 :          0 :           return MAX ((int) bitwidth - (int) xmode_width + 1, num0);
    5098                 :            :         }
    5099                 :            : 
    5100                 :   15593200 :       if (is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (x)), &inner_mode))
    5101                 :            :         {
    5102                 :            :           /* For a smaller object, just ignore the high bits.  */
    5103                 :   15417500 :           if (bitwidth <= GET_MODE_PRECISION (inner_mode))
    5104                 :            :             {
    5105                 :    5098580 :               num0 = cached_num_sign_bit_copies (SUBREG_REG (x), inner_mode,
    5106                 :            :                                                  known_x, known_mode,
    5107                 :            :                                                  known_ret);
    5108                 :    5098580 :               return MAX (1, num0 - (int) (GET_MODE_PRECISION (inner_mode)
    5109                 :            :                                            - bitwidth));
    5110                 :            :             }
    5111                 :            : 
    5112                 :            :           /* For paradoxical SUBREGs on machines where all register operations
    5113                 :            :              affect the entire register, just look inside.  Note that we are
    5114                 :            :              passing MODE to the recursive call, so the number of sign bit
    5115                 :            :              copies will remain relative to that mode, not the inner mode.
    5116                 :            : 
    5117                 :            :              This works only if loads sign extend.  Otherwise, if we get a
    5118                 :            :              reload for the inner part, it may be loaded from the stack, and
    5119                 :            :              then we lose all sign bit copies that existed before the store
    5120                 :            :              to the stack.  */
    5121                 :            :           if (WORD_REGISTER_OPERATIONS
    5122                 :            :               && load_extend_op (inner_mode) == SIGN_EXTEND
    5123                 :            :               && paradoxical_subreg_p (x)
    5124                 :            :               && MEM_P (SUBREG_REG (x)))
    5125                 :            :             return cached_num_sign_bit_copies (SUBREG_REG (x), mode,
    5126                 :            :                                                known_x, known_mode, known_ret);
    5127                 :            :         }
    5128                 :            :       break;
    5129                 :            : 
    5130                 :        789 :     case SIGN_EXTRACT:
    5131                 :        789 :       if (CONST_INT_P (XEXP (x, 1)))
    5132                 :        789 :         return MAX (1, (int) bitwidth - INTVAL (XEXP (x, 1)));
    5133                 :            :       break;
    5134                 :            : 
    5135                 :    2372900 :     case SIGN_EXTEND:
    5136                 :  126727000 :       if (is_a <scalar_int_mode> (GET_MODE (XEXP (x, 0)), &inner_mode))
    5137                 :    2372900 :         return (bitwidth - GET_MODE_PRECISION (inner_mode)
    5138                 :    2372900 :                 + cached_num_sign_bit_copies (XEXP (x, 0), inner_mode,
    5139                 :    2372900 :                                               known_x, known_mode, known_ret));
    5140                 :            :       break;
    5141                 :            : 
    5142                 :     569700 :     case TRUNCATE:
    5143                 :            :       /* For a smaller object, just ignore the high bits.  */
    5144                 :     569700 :       inner_mode = as_a <scalar_int_mode> (GET_MODE (XEXP (x, 0)));
    5145                 :     569700 :       num0 = cached_num_sign_bit_copies (XEXP (x, 0), inner_mode,
    5146                 :            :                                          known_x, known_mode, known_ret);
    5147                 :     569700 :       return MAX (1, (num0 - (int) (GET_MODE_PRECISION (inner_mode)
    5148                 :            :                                     - bitwidth)));
    5149                 :            : 
    5150                 :     522208 :     case NOT:
    5151                 :     522208 :       return cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5152                 :     522208 :                                          known_x, known_mode, known_ret);
    5153                 :            : 
    5154                 :      23406 :     case ROTATE:       case ROTATERT:
    5155                 :            :       /* If we are rotating left by a number of bits less than the number
    5156                 :            :          of sign bit copies, we can just subtract that amount from the
    5157                 :            :          number.  */
    5158                 :      23406 :       if (CONST_INT_P (XEXP (x, 1))
    5159                 :      14281 :           && INTVAL (XEXP (x, 1)) >= 0
    5160                 :      14278 :           && INTVAL (XEXP (x, 1)) < (int) bitwidth)
    5161                 :            :         {
    5162                 :      14278 :           num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5163                 :            :                                              known_x, known_mode, known_ret);
    5164                 :      14278 :           return MAX (1, num0 - (code == ROTATE ? INTVAL (XEXP (x, 1))
    5165                 :            :                                  : (int) bitwidth - INTVAL (XEXP (x, 1))));
    5166                 :            :         }
    5167                 :            :       break;
    5168                 :            : 
    5169                 :     346564 :     case NEG:
    5170                 :            :       /* In general, this subtracts one sign bit copy.  But if the value
    5171                 :            :          is known to be positive, the number of sign bit copies is the
    5172                 :            :          same as that of the input.  Finally, if the input has just one bit
    5173                 :            :          that might be nonzero, all the bits are copies of the sign bit.  */
    5174                 :     346564 :       num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5175                 :            :                                          known_x, known_mode, known_ret);
    5176                 :     346564 :       if (bitwidth > HOST_BITS_PER_WIDE_INT)
    5177                 :      11142 :         return num0 > 1 ? num0 - 1 : 1;
    5178                 :            : 
    5179                 :     335422 :       nonzero = nonzero_bits (XEXP (x, 0), mode);
    5180                 :     335422 :       if (nonzero == 1)
    5181                 :            :         return bitwidth;
    5182                 :            : 
    5183                 :     275446 :       if (num0 > 1
    5184                 :      66475 :           && ((HOST_WIDE_INT_1U << (bitwidth - 1)) & nonzero))
    5185                 :      40791 :         num0--;
    5186                 :            : 
    5187                 :     275446 :       return num0;
    5188                 :            : 
    5189                 :    3565440 :     case IOR:   case AND:   case XOR:
    5190                 :    3565440 :     case SMIN:  case SMAX:  case UMIN:  case UMAX:
    5191                 :            :       /* Logical operations will preserve the number of sign-bit copies.
    5192                 :            :          MIN and MAX operations always return one of the operands.  */
    5193                 :    3565440 :       num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5194                 :            :                                          known_x, known_mode, known_ret);
    5195                 :    3565440 :       num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
    5196                 :            :                                          known_x, known_mode, known_ret);
    5197                 :            : 
    5198                 :            :       /* If num1 is clearing some of the top bits then regardless of
    5199                 :            :          the other term, we are guaranteed to have at least that many
    5200                 :            :          high-order zero bits.  */
    5201                 :    3565440 :       if (code == AND
    5202                 :    3565440 :           && num1 > 1
    5203                 :    1413020 :           && bitwidth <= HOST_BITS_PER_WIDE_INT
    5204                 :    1409320 :           && CONST_INT_P (XEXP (x, 1))
    5205                 :    1327580 :           && (UINTVAL (XEXP (x, 1))
    5206                 :    1327580 :               & (HOST_WIDE_INT_1U << (bitwidth - 1))) == 0)
    5207                 :            :         return num1;
    5208                 :            : 
    5209                 :            :       /* Similarly for IOR when setting high-order bits.  */
    5210                 :    2661220 :       if (code == IOR
    5211                 :    2661220 :           && num1 > 1
    5212                 :     255589 :           && bitwidth <= HOST_BITS_PER_WIDE_INT
    5213                 :     255589 :           && CONST_INT_P (XEXP (x, 1))
    5214                 :      65621 :           && (UINTVAL (XEXP (x, 1))
    5215                 :      65621 :               & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0)
    5216                 :            :         return num1;
    5217                 :            : 
    5218                 :    2659490 :       return MIN (num0, num1);
    5219                 :            : 
    5220                 :   27635800 :     case PLUS:  case MINUS:
    5221                 :            :       /* For addition and subtraction, we can have a 1-bit carry.  However,
    5222                 :            :          if we are subtracting 1 from a positive number, there will not
    5223                 :            :          be such a carry.  Furthermore, if the positive number is known to
    5224                 :            :          be 0 or 1, we know the result is either -1 or 0.  */
    5225                 :            : 
    5226                 :   27635800 :       if (code == PLUS && XEXP (x, 1) == constm1_rtx
    5227                 :     703107 :           && bitwidth <= HOST_BITS_PER_WIDE_INT)
    5228                 :            :         {
    5229                 :     701153 :           nonzero = nonzero_bits (XEXP (x, 0), mode);
    5230                 :     701153 :           if (((HOST_WIDE_INT_1U << (bitwidth - 1)) & nonzero) == 0)
    5231                 :      30847 :             return (nonzero == 1 || nonzero == 0 ? bitwidth
    5232                 :      24416 :                     : bitwidth - floor_log2 (nonzero) - 1);
    5233                 :            :         }
    5234                 :            : 
    5235                 :   27604900 :       num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5236                 :            :                                          known_x, known_mode, known_ret);
    5237                 :   27604900 :       num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
    5238                 :            :                                          known_x, known_mode, known_ret);
    5239                 :   27604900 :       result = MAX (1, MIN (num0, num1) - 1);
    5240                 :            : 
    5241                 :   27604900 :       return result;
    5242                 :            : 
    5243                 :    1216400 :     case MULT:
    5244                 :            :       /* The number of bits of the product is the sum of the number of
    5245                 :            :          bits of both terms.  However, unless one of the terms if known
    5246                 :            :          to be positive, we must allow for an additional bit since negating
    5247                 :            :          a negative number can remove one sign bit copy.  */
    5248                 :            : 
    5249                 :    1216400 :       num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5250                 :            :                                          known_x, known_mode, known_ret);
    5251                 :    1216400 :       num1 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
    5252                 :            :                                          known_x, known_mode, known_ret);
    5253                 :            : 
    5254                 :    1216400 :       result = bitwidth - (bitwidth - num0) - (bitwidth - num1);
    5255                 :    1216400 :       if (result > 0
    5256                 :    1216400 :           && (bitwidth > HOST_BITS_PER_WIDE_INT
    5257                 :     264543 :               || (((nonzero_bits (XEXP (x, 0), mode)
    5258                 :     264543 :                     & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0)
    5259                 :     157361 :                   && ((nonzero_bits (XEXP (x, 1), mode)
    5260                 :            :                        & (HOST_WIDE_INT_1U << (bitwidth - 1)))
    5261                 :     157361 :                       != 0))))
    5262                 :     143508 :         result--;
    5263                 :            : 
    5264                 :    1216400 :       return MAX (1, result);
    5265                 :            : 
    5266                 :      79911 :     case UDIV:
    5267                 :            :       /* The result must be <= the first operand.  If the first operand
    5268                 :            :          has the high bit set, we know nothing about the number of sign
    5269                 :            :          bit copies.  */
    5270                 :      79911 :       if (bitwidth > HOST_BITS_PER_WIDE_INT)
    5271                 :            :         return 1;
    5272                 :      79911 :       else if ((nonzero_bits (XEXP (x, 0), mode)
    5273                 :      79911 :                 & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0)
    5274                 :            :         return 1;
    5275                 :            :       else
    5276                 :      14644 :         return cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5277                 :      14644 :                                            known_x, known_mode, known_ret);
    5278                 :            : 
    5279                 :      80106 :     case UMOD:
    5280                 :            :       /* The result must be <= the second operand.  If the second operand
    5281                 :            :          has (or just might have) the high bit set, we know nothing about
    5282                 :            :          the number of sign bit copies.  */
    5283                 :      80106 :       if (bitwidth > HOST_BITS_PER_WIDE_INT)
    5284                 :            :         return 1;
    5285                 :      80106 :       else if ((nonzero_bits (XEXP (x, 1), mode)
    5286                 :      80106 :                 & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0)
    5287                 :            :         return 1;
    5288                 :            :       else
    5289                 :      18199 :         return cached_num_sign_bit_copies (XEXP (x, 1), mode,
    5290                 :      18199 :                                            known_x, known_mode, known_ret);
    5291                 :            : 
    5292                 :     146524 :     case DIV:
    5293                 :            :       /* Similar to unsigned division, except that we have to worry about
    5294                 :            :          the case where the divisor is negative, in which case we have
    5295                 :            :          to add 1.  */
    5296                 :     146524 :       result = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5297                 :            :                                            known_x, known_mode, known_ret);
    5298                 :     146524 :       if (result > 1
    5299                 :     146524 :           && (bitwidth > HOST_BITS_PER_WIDE_INT
    5300                 :      20063 :               || (nonzero_bits (XEXP (x, 1), mode)
    5301                 :      20063 :                   & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0))
    5302                 :      17999 :         result--;
    5303                 :            : 
    5304                 :     146524 :       return result;
    5305                 :            : 
    5306                 :     100818 :     case MOD:
    5307                 :     100818 :       result = cached_num_sign_bit_copies (XEXP (x, 1), mode,
    5308                 :            :                                            known_x, known_mode, known_ret);
    5309                 :     100818 :       if (result > 1
    5310                 :     100818 :           && (bitwidth > HOST_BITS_PER_WIDE_INT
    5311                 :      22423 :               || (nonzero_bits (XEXP (x, 1), mode)
    5312                 :      22423 :                   & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0))
    5313                 :      15803 :         result--;
    5314                 :            : 
    5315                 :     100818 :       return result;
    5316                 :            : 
    5317                 :     725721 :     case ASHIFTRT:
    5318                 :            :       /* Shifts by a constant add to the number of bits equal to the
    5319                 :            :          sign bit.  */
    5320                 :     725721 :       num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5321                 :            :                                          known_x, known_mode, known_ret);
    5322                 :     725721 :       if (CONST_INT_P (XEXP (x, 1))
    5323                 :     692393 :           && INTVAL (XEXP (x, 1)) > 0
    5324                 :     692155 :           && INTVAL (XEXP (x, 1)) < xmode_width)
    5325                 :     692083 :         num0 = MIN ((int) bitwidth, num0 + INTVAL (XEXP (x, 1)));
    5326                 :            : 
    5327                 :     725721 :       return num0;
    5328                 :            : 
    5329                 :    7219730 :     case ASHIFT:
    5330                 :            :       /* Left shifts destroy copies.  */
    5331                 :    7219730 :       if (!CONST_INT_P (XEXP (x, 1))
    5332                 :    7104340 :           || INTVAL (XEXP (x, 1)) < 0
    5333                 :    7104290 :           || INTVAL (XEXP (x, 1)) >= (int) bitwidth
    5334                 :    7104220 :           || INTVAL (XEXP (x, 1)) >= xmode_width)
    5335                 :            :         return 1;
    5336                 :            : 
    5337                 :    7104220 :       num0 = cached_num_sign_bit_copies (XEXP (x, 0), mode,
    5338                 :            :                                          known_x, known_mode, known_ret);
    5339                 :    7104220 :       return MAX (1, num0 - INTVAL (XEXP (x, 1)));
    5340                 :            : 
    5341                 :     634477 :     case IF_THEN_ELSE:
    5342                 :     634477 :       num0 = cached_num_sign_bit_copies (XEXP (x, 1), mode,
    5343                 :            :                                          known_x, known_mode, known_ret);
    5344                 :     634477 :       num1 = cached_num_sign_bit_copies (XEXP (x, 2), mode,
    5345                 :            :                                          known_x, known_mode, known_ret);
    5346                 :     634477 :       return MIN (num0, num1);
    5347                 :            : 
    5348                 :    1256700 :     case EQ:  case NE:  case GE:  case GT:  case LE:  case LT:
    5349                 :    1256700 :     case UNEQ:  case LTGT:  case UNGE:  case UNGT:  case UNLE:  case UNLT:
    5350                 :    1256700 :     case GEU: case GTU: case LEU: case LTU:
    5351                 :    1256700 :     case UNORDERED: case ORDERED:
    5352                 :            :       /* If the constant is negative, take its 1's complement and remask.
    5353                 :            :          Then see how many zero bits we have.  */
    5354                 :    1256700 :       nonzero = STORE_FLAG_VALUE;
    5355                 :    1256700 :       if (bitwidth <= HOST_BITS_PER_WIDE_INT
    5356                 :    1256700 :           && (nonzero & (HOST_WIDE_INT_1U << (bitwidth - 1))) != 0)
    5357                 :          0 :         nonzero = (~nonzero) & GET_MODE_MASK (mode);
    5358                 :            : 
    5359                 :    1256700 :       return (nonzero == 0 ? bitwidth : bitwidth - floor_log2 (nonzero) - 1);
    5360                 :            : 
    5361                 :            :     default:
    5362                 :            :       break;
    5363                 :            :     }
    5364                 :            : 
    5365                 :            :   /* If we haven't been able to figure it out by one of the above rules,
    5366                 :            :      see if some of the high-order bits are known to be zero.  If so,
    5367                 :            :      count those bits and return one less than that amount.  If we can't
    5368                 :            :      safely compute the mask for this mode, always return BITWIDTH.  */
    5369                 :            : 
    5370                 :  124354000 :   bitwidth = GET_MODE_PRECISION (mode);
    5371                 :  124354000 :   if (bitwidth > HOST_BITS_PER_WIDE_INT)
    5372                 :            :     return 1;
    5373                 :            : 
    5374                 :  121428000 :   nonzero = nonzero_bits (x, mode);
    5375                 :  121428000 :   return nonzero & (HOST_WIDE_INT_1U << (bitwidth - 1))
    5376                 :  124560000 :          ? 1 : bitwidth - floor_log2 (nonzero) - 1;
    5377                 :            : }
    5378                 :            : 
    5379                 :            : /* Calculate the rtx_cost of a single instruction pattern.  A return value of
    5380                 :            :    zero indicates an instruction pattern without a known cost.  */
    5381                 :            : 
    5382                 :            : int
    5383                 :   75789600 : pattern_cost (rtx pat, bool speed)
    5384                 :            : {
    5385                 :   75789600 :   int i, cost;
    5386                 :   75789600 :   rtx set;
    5387                 :            : 
    5388                 :            :   /* Extract the single set rtx from the instruction pattern.  We
    5389                 :            :      can't use single_set since we only have the pattern.  We also
    5390                 :            :      consider PARALLELs of a normal set and a single comparison.  In
    5391                 :            :      that case we use the cost of the non-comparison SET operation,
    5392                 :            :      which is most-likely to be the real cost of this operation.  */
    5393                 :   75789600 :   if (GET_CODE (pat) == SET)
    5394                 :            :     set = pat;
    5395                 :   37159800 :   else if (GET_CODE (pat) == PARALLEL)
    5396                 :            :     {
    5397                 :            :       set = NULL_RTX;
    5398                 :            :       rtx comparison = NULL_RTX;
    5399                 :            : 
    5400                 :   20793900 :       for (i = 0; i < XVECLEN (pat, 0); i++)
    5401                 :            :         {
    5402                 :   14071700 :           rtx x = XVECEXP (pat, 0, i);
    5403                 :   14071700 :           if (GET_CODE (x) == SET)
    5404                 :            :             {
    5405                 :    7136010 :               if (GET_CODE (SET_SRC (x)) == COMPARE)
    5406                 :            :                 {
    5407                 :     126810 :                   if (comparison)
    5408                 :            :                     return 0;
    5409                 :            :                   comparison = x;
    5410                 :            :                 }
    5411                 :            :               else
    5412                 :            :                 {
    5413                 :    7009200 :                   if (set)
    5414                 :            :                     return 0;
    5415                 :            :                   set = x;
    5416                 :            :                 }
    5417                 :            :             }
    5418                 :            :         }
    5419                 :            : 
    5420                 :    6722200 :       if (!set && comparison)
    5421                 :      52996 :         set = comparison;
    5422                 :            : 
    5423                 :    6722200 :       if (!set)
    5424                 :            :         return 0;
    5425                 :            :     }
    5426                 :            :   else
    5427                 :            :     return 0;
    5428                 :            : 
    5429                 :   45292400 :   cost = set_src_cost (SET_SRC (set), GET_MODE (SET_DEST (set)), speed);
    5430                 :   45292400 :   return cost > 0 ? cost : COSTS_N_INSNS (1);
    5431                 :            : }
    5432                 :            : 
    5433                 :            : /* Calculate the cost of a single instruction.  A return value of zero
    5434                 :            :    indicates an instruction pattern without a known cost.  */
    5435                 :            : 
    5436                 :            : int
    5437                 :   74255800 : insn_cost (rtx_insn *insn, bool speed)
    5438                 :            : {
    5439                 :   74255800 :   if (targetm.insn_cost)
    5440                 :          0 :     return targetm.insn_cost (insn, speed);
    5441                 :            : 
    5442                 :   74255800 :   return pattern_cost (PATTERN (insn), speed);
    5443                 :            : }
    5444                 :            : 
    5445                 :            : /* Returns estimate on cost of computing SEQ.  */
    5446                 :            : 
    5447                 :            : unsigned
    5448                 :     934965 : seq_cost (const rtx_insn *seq, bool speed)
    5449                 :            : {
    5450                 :     934965 :   unsigned cost = 0;
    5451                 :    2488420 :   rtx set;
    5452                 :            : 
    5453                 :    4041880 :   for (; seq; seq = NEXT_INSN (seq))
    5454                 :            :     {
    5455                 :    1553460 :       set = single_set (seq);
    5456                 :    1553460 :       if (set)
    5457                 :    1549940 :         cost += set_rtx_cost (set, speed);
    5458                 :       3518 :       else if (NONDEBUG_INSN_P (seq))
    5459                 :            :         {
    5460                 :       3514 :           int this_cost = insn_cost (CONST_CAST_RTX_INSN (seq), speed);
    5461                 :       3514 :           if (this_cost > 0)
    5462                 :          0 :             cost += this_cost;
    5463                 :            :           else
    5464                 :       3514 :             cost++;
    5465                 :            :         }
    5466                 :            :     }
    5467                 :            : 
    5468                 :     934965 :   return cost;
    5469                 :            : }
    5470                 :            : 
    5471                 :            : /* Given an insn INSN and condition COND, return the condition in a
    5472                 :            :    canonical form to simplify testing by callers.  Specifically:
    5473                 :            : 
    5474                 :            :    (1) The code will always be a comparison operation (EQ, NE, GT, etc.).
    5475                 :            :    (2) Both operands will be machine operands; (cc0) will have been replaced.
    5476                 :            :    (3) If an operand is a constant, it will be the second operand.
    5477                 :            :    (4) (LE x const) will be replaced with (LT x <const+1>) and similarly
    5478                 :            :        for GE, GEU, and LEU.
    5479                 :            : 
    5480                 :            :    If the condition cannot be understood, or is an inequality floating-point
    5481                 :            :    comparison which needs to be reversed, 0 will be returned.
    5482                 :            : 
    5483                 :            :    If REVERSE is nonzero, then reverse the condition prior to canonizing it.
    5484                 :            : 
    5485                 :            :    If EARLIEST is nonzero, it is a pointer to a place where the earliest
    5486                 :            :    insn used in locating the condition was found.  If a replacement test
    5487                 :            :    of the condition is desired, it should be placed in front of that
    5488                 :            :    insn and we will be sure that the inputs are still valid.
    5489                 :            : 
    5490                 :            :    If WANT_REG is nonzero, we wish the condition to be relative to that
    5491                 :            :    register, if possible.  Therefore, do not canonicalize the condition
    5492                 :            :    further.  If ALLOW_CC_MODE is nonzero, allow the condition returned
    5493                 :            :    to be a compare to a CC mode register.
    5494                 :            : 
    5495                 :            :    If VALID_AT_INSN_P, the condition must be valid at both *EARLIEST
    5496                 :            :    and at INSN.  */
    5497                 :            : 
    5498                 :            : rtx
    5499                 :   22301000 : canonicalize_condition (rtx_insn *insn, rtx cond, int reverse,
    5500                 :            :                         rtx_insn **earliest,
    5501                 :            :                         rtx want_reg, int allow_cc_mode, int valid_at_insn_p)
    5502                 :            : {
    5503                 :   22301000 :   enum rtx_code code;
    5504                 :   22301000 :   rtx_insn *prev = insn;
    5505                 :   22301000 :   const_rtx set;
    5506                 :   22301000 :   rtx tem;
    5507                 :   22301000 :   rtx op0, op1;
    5508                 :   22301000 :   int reverse_code = 0;
    5509                 :   22301000 :   machine_mode mode;
    5510                 :   22301000 :   basic_block bb = BLOCK_FOR_INSN (insn);
    5511                 :            : 
    5512                 :   22301000 :   code = GET_CODE (cond);
    5513                 :   22301000 :   mode = GET_MODE (cond);
    5514                 :   22301000 :   op0 = XEXP (cond, 0);
    5515                 :   22301000 :   op1 = XEXP (cond, 1);
    5516                 :            : 
    5517                 :   22301000 :   if (reverse)
    5518                 :    1429870 :     code = reversed_comparison_code (cond, insn);
    5519                 :   22301000 :   if (code == UNKNOWN)
    5520                 :            :     return 0;
    5521                 :            : 
    5522                 :   22301000 :   if (earliest)
    5523                 :   10474600 :     *earliest = insn;
    5524                 :            : 
    5525                 :            :   /* If we are comparing a register with zero, see if the register is set
    5526                 :            :      in the previous insn to a COMPARE or a comparison operation.  Perform
    5527                 :            :      the same tests as a function of STORE_FLAG_VALUE as find_comparison_args
    5528                 :            :      in cse.c  */
    5529                 :            : 
    5530                 :   48028500 :   while ((GET_RTX_CLASS (code) == RTX_COMPARE
    5531                 :            :           || GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
    5532                 :   48028500 :          && op1 == CONST0_RTX (GET_MODE (op0))
    5533                 :   85313500 :          && op0 != want_reg)
    5534                 :            :     {
    5535                 :            :       /* Set nonzero when we find something of interest.  */
    5536                 :   37285000 :       rtx x = 0;
    5537                 :            : 
    5538                 :            :       /* If comparison with cc0, import actual comparison from compare
    5539                 :            :          insn.  */
    5540                 :   37285000 :       if (op0 == cc0_rtx)
    5541                 :            :         {
    5542                 :          0 :           if ((prev = prev_nonnote_insn (prev)) == 0
    5543                 :          0 :               || !NONJUMP_INSN_P (prev)
    5544                 :          0 :               || (set = single_set (prev)) == 0
    5545                 :          0 :               || SET_DEST (set) != cc0_rtx)
    5546                 :          0 :             return 0;
    5547                 :            : 
    5548                 :          0 :           op0 = SET_SRC (set);
    5549                 :          0 :           op1 = CONST0_RTX (GET_MODE (op0));
    5550                 :          0 :           if (earliest)
    5551                 :          0 :             *earliest = prev;
    5552                 :            :         }
    5553                 :            : 
    5554                 :            :       /* If this is a COMPARE, pick up the two things being compared.  */
    5555                 :   37285000 :       if (GET_CODE (op0) == COMPARE)
    5556                 :            :         {
    5557                 :          0 :           op1 = XEXP (op0, 1);
    5558                 :          0 :           op0 = XEXP (op0, 0);
    5559                 :          0 :           continue;
    5560                 :            :         }
    5561                 :   37285000 :       else if (!REG_P (op0))
    5562                 :            :         break;
    5563                 :            : 
    5564                 :            :       /* Go back to the previous insn.  Stop if it is not an INSN.  We also
    5565                 :            :          stop if it isn't a single set or if it has a REG_INC note because
    5566                 :            :          we don't want to bother dealing with it.  */
    5567                 :            : 
    5568                 :   33856300 :       prev = prev_nonnote_nondebug_insn (prev);
    5569                 :            : 
    5570                 :   33856300 :       if (prev == 0
    5571                 :   33784900 :           || !NONJUMP_INSN_P (prev)
    5572                 :            :           || FIND_REG_INC_NOTE (prev, NULL_RTX)
    5573                 :            :           /* In cfglayout mode, there do not have to be labels at the
    5574                 :            :              beginning of a block, or jumps at the end, so the previous
    5575                 :            :              conditions would not stop us when we reach bb boundary.  */
    5576                 :   64975000 :           || BLOCK_FOR_INSN (prev) != bb)
    5577                 :            :         break;
    5578                 :            : 
    5579                 :   31055900 :       set = set_of (op0, prev);
    5580                 :            : 
    5581                 :   31055900 :       if (set
    5582                 :   31055900 :           && (GET_CODE (set) != SET
    5583                 :   26615000 :               || !rtx_equal_p (SET_DEST (set), op0)))
    5584                 :            :         break;
    5585                 :            : 
    5586                 :            :       /* If this is setting OP0, get what it sets it to if it looks
    5587                 :            :          relevant.  */
    5588                 :   30962800 :       if (set)
    5589                 :            :         {
    5590                 :   26521900 :           machine_mode inner_mode = GET_MODE (SET_DEST (set));
    5591                 :            : #ifdef FLOAT_STORE_FLAG_VALUE
    5592                 :            :           REAL_VALUE_TYPE fsfv;
    5593                 :            : #endif
    5594                 :            : 
    5595                 :            :           /* ??? We may not combine comparisons done in a CCmode with
    5596                 :            :              comparisons not done in a CCmode.  This is to aid targets
    5597                 :            :              like Alpha that have an IEEE compliant EQ instruction, and
    5598                 :            :              a non-IEEE compliant BEQ instruction.  The use of CCmode is
    5599                 :            :              actually artificial, simply to prevent the combination, but
    5600                 :            :              should not affect other platforms.
    5601                 :            : 
    5602                 :            :              However, we must allow VOIDmode comparisons to match either
    5603                 :            :              CCmode or non-CCmode comparison, because some ports have
    5604                 :            :              modeless comparisons inside branch patterns.
    5605                 :            : 
    5606                 :            :              ??? This mode check should perhaps look more like the mode check
    5607                 :            :              in simplify_comparison in combine.  */
    5608                 :   26521900 :           if (((GET_MODE_CLASS (mode) == MODE_CC)
    5609                 :   26521900 :                != (GET_MODE_CLASS (inner_mode) == MODE_CC))
    5610                 :   22131800 :               && mode != VOIDmode
    5611                 :          0 :               && inner_mode != VOIDmode)
    5612                 :            :             break;
    5613                 :   26521900 :           if (GET_CODE (SET_SRC (set)) == COMPARE
    5614                 :   26521900 :               || (((code == NE
    5615                 :    3300090 :                     || (code == LT
    5616                 :     127464 :                         && val_signbit_known_set_p (inner_mode,
    5617                 :            :                                                     STORE_FLAG_VALUE))
    5618                 :            : #ifdef FLOAT_STORE_FLAG_VALUE
    5619                 :            :                     || (code == LT
    5620                 :            :                         && SCALAR_FLOAT_MODE_P (inner_mode)
    5621                 :            :                         && (fsfv = FLOAT_STORE_FLAG_VALUE (inner_mode),
    5622                 :            :                             REAL_VALUE_NEGATIVE (fsfv)))
    5623                 :            : #endif
    5624                 :            :                     ))
    5625                 :    1944240 :                   && COMPARISON_P (SET_SRC (set))))
    5626                 :   21501600 :             x = SET_SRC (set);
    5627                 :    5020330 :           else if (((code == EQ
    5628                 :    2916150 :                      || (code == GE
    5629                 :     131966 :                          && val_signbit_known_set_p (inner_mode,
    5630                 :            :                                                      STORE_FLAG_VALUE))
    5631                 :            : #ifdef FLOAT_STORE_FLAG_VALUE
    5632                 :            :                      || (code == GE
    5633                 :            :                          && SCALAR_FLOAT_MODE_P (inner_mode)
    5634                 :            :                          && (fsfv = FLOAT_STORE_FLAG_VALUE (inner_mode),
    5635                 :            :                              REAL_VALUE_NEGATIVE (fsfv)))
    5636                 :            : #endif
    5637                 :            :                      ))
    5638                 :    5020330 :                    && COMPARISON_P (SET_SRC (set)))
    5639                 :            :             {
    5640                 :            :               reverse_code = 1;
    5641                 :            :               x = SET_SRC (set);
    5642                 :            :             }
    5643                 :    4779680 :           else if ((code == EQ || code == NE)
    5644                 :    3583770 :                    && GET_CODE (SET_SRC (set)) == XOR)
    5645                 :            :             /* Handle sequences like:
    5646                 :            : 
    5647                 :            :                (set op0 (xor X Y))
    5648                 :            :                ...(eq|ne op0 (const_int 0))...
    5649                 :            : 
    5650                 :            :                in which case:
    5651                 :            : 
    5652                 :            :                (eq op0 (const_int 0)) reduces to (eq X Y)
    5653                 :            :                (ne op0 (const_int 0)) reduces to (ne X Y)
    5654                 :            : 
    5655                 :            :                This is the form used by MIPS16, for example.  */
    5656                 :            :             x = SET_SRC (set);
    5657                 :            :           else
    5658                 :            :             break;
    5659                 :            :         }
    5660                 :            : 
    5661                 :    4440900 :       else if (reg_set_p (op0, prev))
    5662                 :            :         /* If this sets OP0, but not directly, we have to give up.  */
    5663                 :            :         break;
    5664                 :            : 
    5665                 :   21745000 :       if (x)
    5666                 :            :         {
    5667                 :            :           /* If the caller is expecting the condition to be valid at INSN,
    5668                 :            :              make sure X doesn't change before INSN.  */
    5669                 :   21745000 :           if (valid_at_insn_p)
    5670                 :   14753400 :             if (modified_in_p (x, prev) || modified_between_p (x, prev, insn))
    5671                 :            :               break;
    5672                 :   21286600 :           if (COMPARISON_P (x))
    5673                 :     129820 :             code = GET_CODE (x);
    5674                 :   21286600 :           if (reverse_code)
    5675                 :            :             {
    5676                 :      82735 :               code = reversed_comparison_code (x, prev);
    5677                 :      82735 :               if (code == UNKNOWN)
    5678                 :            :                 return 0;
    5679                 :            :               reverse_code = 0;
    5680                 :            :             }
    5681                 :            : 
    5682                 :   21286600 :           op0 = XEXP (x, 0), op1 = XEXP (x, 1);
    5683                 :   21286600 :           if (earliest)
    5684                 :   10132500 :             *earliest = prev;
    5685                 :            :         }
    5686                 :            :     }
    5687                 :            : 
    5688                 :            :   /* If constant is first, put it last.  */
    5689                 :   22301000 :   if (CONSTANT_P (op0))
    5690                 :          0 :     code = swap_condition (code), tem = op0, op0 = op1, op1 = tem;
    5691                 :            : 
    5692                 :            :   /* If OP0 is the result of a comparison, we weren't able to find what
    5693                 :            :      was really being compared, so fail.  */
    5694                 :   22301000 :   if (!allow_cc_mode
    5695                 :   11853500 :       && GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
    5696                 :            :     return 0;
    5697                 :            : 
    5698                 :            :   /* Canonicalize any ordered comparison with integers involving equality
    5699                 :            :      if we can do computations in the relevant mode and we do not
    5700                 :            :      overflow.  */
    5701                 :            : 
    5702                 :   21618000 :   scalar_int_mode op0_mode;
    5703                 :   21618000 :   if (CONST_INT_P (op1)
    5704                 :   14795700 :       && is_a <scalar_int_mode> (GET_MODE (op0), &op0_mode)
    5705                 :   36072000 :       && GET_MODE_PRECISION (op0_mode) <= HOST_BITS_PER_WIDE_INT)
    5706                 :            :     {
    5707                 :   14454000 :       HOST_WIDE_INT const_val = INTVAL (op1);
    5708                 :   14454000 :       unsigned HOST_WIDE_INT uconst_val = const_val;
    5709                 :   14454000 :       unsigned HOST_WIDE_INT max_val
    5710                 :   14454000 :         = (unsigned HOST_WIDE_INT) GET_MODE_MASK (op0_mode);
    5711                 :            : 
    5712                 :   14454000 :       switch (code)
    5713                 :            :         {
    5714                 :     528608 :         case LE:
    5715                 :     528608 :           if ((unsigned HOST_WIDE_INT) const_val != max_val >> 1)
    5716                 :     528608 :             code = LT, op1 = gen_int_mode (const_val + 1, op0_mode);
    5717                 :            :           break;
    5718                 :            : 
    5719                 :            :         /* When cross-compiling, const_val might be sign-extended from
    5720                 :            :            BITS_PER_WORD to HOST_BITS_PER_WIDE_INT */
    5721                 :     267905 :         case GE:
    5722                 :     267905 :           if ((const_val & max_val)
    5723                 :     267905 :               != (HOST_WIDE_INT_1U << (GET_MODE_PRECISION (op0_mode) - 1)))
    5724                 :     267905 :             code = GT, op1 = gen_int_mode (const_val - 1, op0_mode);
    5725                 :            :           break;
    5726                 :            : 
    5727                 :     289757 :         case LEU:
    5728                 :     289757 :           if (uconst_val < max_val)
    5729                 :     283869 :             code = LTU, op1 = gen_int_mode (uconst_val + 1, op0_mode);
    5730                 :            :           break;
    5731                 :            : 
    5732                 :      14814 :         case GEU:
    5733                 :      14814 :           if (uconst_val != 0)
    5734                 :      14814 :             code = GTU, op1 = gen_int_mode (uconst_val - 1, op0_mode);
    5735                 :            :           break;
    5736                 :            : 
    5737                 :            :         default:
    5738                 :            :           break;
    5739                 :            :         }
    5740                 :            :     }
    5741                 :            : 
    5742                 :            :   /* Never return CC0; return zero instead.  */
    5743                 :   21618000 :   if (CC0_P (op0))
    5744                 :            :     return 0;
    5745                 :            : 
    5746                 :            :   /* We promised to return a comparison.  */
    5747                 :   21618000 :   rtx ret = gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
    5748                 :   21618000 :   if (COMPARISON_P (ret))
    5749                 :   21618000 :     return ret;
    5750                 :            :   return 0;
    5751                 :            : }
    5752                 :            : 
    5753                 :            : /* Given a jump insn JUMP, return the condition that will cause it to branch
    5754                 :            :    to its JUMP_LABEL.  If the condition cannot be understood, or is an
    5755                 :            :    inequality floating-point comparison which needs to be reversed, 0 will
    5756                 :            :    be returned.
    5757                 :            : 
    5758                 :            :    If EARLIEST is nonzero, it is a pointer to a place where the earliest
    5759                 :            :    insn used in locating the condition was found.  If a replacement test
    5760                 :            :    of the condition is desired, it should be placed in front of that
    5761                 :            :    insn and we will be sure that the inputs are still valid.  If EARLIEST
    5762                 :            :    is null, the returned condition will be valid at INSN.
    5763                 :            : 
    5764                 :            :    If ALLOW_CC_MODE is nonzero, allow the condition returned to be a
    5765                 :            :    compare CC mode register.
    5766                 :            : 
    5767                 :            :    VALID_AT_INSN_P is the same as for canonicalize_condition.  */
    5768                 :            : 
    5769                 :            : rtx
    5770                 :   21676700 : get_condition (rtx_insn *jump, rtx_insn **earliest, int allow_cc_mode,
    5771                 :            :                int valid_at_insn_p)
    5772                 :            : {
    5773                 :   21676700 :   rtx cond;
    5774                 :   21676700 :   int reverse;
    5775                 :   21676700 :   rtx set;
    5776                 :            : 
    5777                 :            :   /* If this is not a standard conditional jump, we can't parse it.  */
    5778                 :   21676700 :   if (!JUMP_P (jump)
    5779                 :   21676700 :       || ! any_condjump_p (jump))
    5780                 :    2639340 :     return 0;
    5781                 :   19037300 :   set = pc_set (jump);
    5782                 :            : 
    5783                 :   19037300 :   cond = XEXP (SET_SRC (set), 0);
    5784                 :            : 
    5785                 :            :   /* If this branches to JUMP_LABEL when the condition is false, reverse
    5786                 :            :      the condition.  */
    5787                 :   19037300 :   reverse
    5788                 :   38074600 :     = GET_CODE (XEXP (SET_SRC (set), 2)) == LABEL_REF
    5789                 :   19037300 :       && label_ref_label (XEXP (SET_SRC (set), 2)) == JUMP_LABEL (jump);
    5790                 :            : 
    5791                 :   19037300 :   return canonicalize_condition (jump, cond, reverse, earliest, NULL_RTX,
    5792                 :   19037300 :                                  allow_cc_mode, valid_at_insn_p);
    5793                 :            : }
    5794                 :            : 
    5795                 :            : /* Initialize the table NUM_SIGN_BIT_COPIES_IN_REP based on
    5796                 :            :    TARGET_MODE_REP_EXTENDED.
    5797                 :            : 
    5798                 :            :    Note that we assume that the property of
    5799                 :            :    TARGET_MODE_REP_EXTENDED(B, C) is sticky to the integral modes
    5800                 :            :    narrower than mode B.  I.e., if A is a mode narrower than B then in
    5801                 :            :    order to be able to operate on it in mode B, mode A needs to
    5802                 :            :    satisfy the requirements set by the representation of mode B.  */
    5803                 :            : 
    5804                 :            : static void
    5805                 :     198583 : init_num_sign_bit_copies_in_rep (void)
    5806                 :            : {
    5807                 :     198583 :   opt_scalar_int_mode in_mode_iter;
    5808                 :     198583 :   scalar_int_mode mode;
    5809                 :            : 
    5810                 :    1588660 :   FOR_EACH_MODE_IN_CLASS (in_mode_iter, MODE_INT)
    5811                 :    9730570 :     FOR_EACH_MODE_UNTIL (mode, in_mode_iter.require ())
    5812                 :            :       {
    5813                 :    4170240 :         scalar_int_mode in_mode = in_mode_iter.require ();
    5814                 :    4170240 :         scalar_int_mode i;
    5815                 :            : 
    5816                 :            :         /* Currently, it is assumed that TARGET_MODE_REP_EXTENDED
    5817                 :            :            extends to the next widest mode.  */
    5818                 :    4170240 :         gcc_assert (targetm.mode_rep_extended (mode, in_mode) == UNKNOWN
    5819                 :            :                     || GET_MODE_WIDER_MODE (mode).require () == in_mode);
    5820                 :            : 
    5821                 :            :         /* We are in in_mode.  Count how many bits outside of mode
    5822                 :            :            have to be copies of the sign-bit.  */
    5823                 :   26411500 :         FOR_EACH_MODE (i, mode, in_mode)
    5824                 :            :           {
    5825                 :            :             /* This must always exist (for the last iteration it will be
    5826                 :            :                IN_MODE).  */
    5827                 :   11120600 :             scalar_int_mode wider = GET_MODE_WIDER_MODE (i).require ();
    5828                 :            : 
    5829                 :   11120600 :             if (targetm.mode_rep_extended (i, wider) == SIGN_EXTEND
    5830                 :            :                 /* We can only check sign-bit copies starting from the
    5831                 :            :                    top-bit.  In order to be able to check the bits we
    5832                 :            :                    have already seen we pretend that subsequent bits
    5833                 :            :                    have to be sign-bit copies too.  */
    5834                 :   11120600 :                 || num_sign_bit_copies_in_rep [in_mode][mode])
    5835                 :          0 :               num_sign_bit_copies_in_rep [in_mode][mode]
    5836                 :          0 :                 += GET_MODE_PRECISION (wider) - GET_MODE_PRECISION (i);
    5837                 :            :           }
    5838                 :            :       }
    5839                 :     198583 : }
    5840                 :            : 
    5841                 :            : /* Suppose that truncation from the machine mode of X to MODE is not a
    5842                 :            :    no-op.  See if there is anything special about X so that we can
    5843                 :            :    assume it already contains a truncated value of MODE.  */
    5844                 :            : 
    5845                 :            : bool
    5846                 :          0 : truncated_to_mode (machine_mode mode, const_rtx x)
    5847                 :            : {
    5848                 :            :   /* This register has already been used in MODE without explicit
    5849                 :            :      truncation.  */
    5850                 :          0 :   if (REG_P (x) && rtl_hooks.reg_truncated_to_mode (mode, x))
    5851                 :            :     return true;
    5852                 :            : 
    5853                 :            :   /* See if we already satisfy the requirements of MODE.  If yes we
    5854                 :            :      can just switch to MODE.  */
    5855                 :          0 :   if (num_sign_bit_copies_in_rep[GET_MODE (x)][mode]
    5856                 :          0 :       && (num_sign_bit_copies (x, GET_MODE (x))
    5857                 :          0 :           >= num_sign_bit_copies_in_rep[GET_MODE (x)][mode] + 1))
    5858                 :          0 :     return true;
    5859                 :            : 
    5860                 :            :   return false;
    5861                 :            : }
    5862                 :            : 
    5863                 :            : /* Return true if RTX code CODE has a single sequence of zero or more
    5864                 :            :    "e" operands and no rtvec operands.  Initialize its rtx_all_subrtx_bounds
    5865                 :            :    entry in that case.  */
    5866                 :            : 
    5867                 :            : static bool
    5868                 :   29986000 : setup_reg_subrtx_bounds (unsigned int code)
    5869                 :            : {
    5870                 :   29986000 :   const char *format = GET_RTX_FORMAT ((enum rtx_code) code);
    5871                 :   29986000 :   unsigned int i = 0;
    5872                 :   42496800 :   for (; format[i] != 'e'; ++i)
    5873                 :            :     {
    5874                 :   19461100 :       if (!format[i])
    5875                 :            :         /* No subrtxes.  Leave start and count as 0.  */
    5876                 :            :         return true;
    5877                 :   14099400 :       if (format[i] == 'E' || format[i] == 'V')
    5878                 :            :         return false;
    5879                 :            :     }
    5880                 :            : 
    5881                 :            :   /* Record the sequence of 'e's.  */
    5882                 :   23035600 :   rtx_all_subrtx_bounds[code].start = i;
    5883                 :   37333600 :   do
    5884                 :   37333600 :     ++i;
    5885                 :   37333600 :   while (format[i] == 'e');
    5886                 :   23035600 :   rtx_all_subrtx_bounds[code].count = i - rtx_all_subrtx_bounds[code].start;
    5887                 :            :   /* rtl-iter.h relies on this.  */
    5888                 :   23035600 :   gcc_checking_assert (rtx_all_subrtx_bounds[code].count <= 3);
    5889                 :            : 
    5890                 :   25815800 :   for (; format[i]; ++i)
    5891                 :    3773080 :     if (format[i] == 'E' || format[i] == 'V' || format[i] == 'e')
    5892                 :            :       return false;
    5893                 :            : 
    5894                 :            :   return true;
    5895                 :            : }
    5896                 :            : 
    5897                 :            : /* Initialize rtx_all_subrtx_bounds.  */
    5898                 :            : void
    5899                 :     198583 : init_rtlanal (void)
    5900                 :            : {
    5901                 :     198583 :   int i;
    5902                 :   30184600 :   for (i = 0; i < NUM_RTX_CODE; i++)
    5903                 :            :     {
    5904                 :   29986000 :       if (!setup_reg_subrtx_bounds (i))
    5905                 :    2581580 :         rtx_all_subrtx_bounds[i].count = UCHAR_MAX;
    5906                 :   29986000 :       if (GET_RTX_CLASS (i) != RTX_CONST_OBJ)
    5907                 :   28000200 :         rtx_nonconst_subrtx_bounds[i] = rtx_all_subrtx_bounds[i];
    5908                 :            :     }
    5909                 :            : 
    5910                 :     198583 :   init_num_sign_bit_copies_in_rep ();
    5911                 :     198583 : }
    5912                 :            : 
    5913                 :            : /* Check whether this is a constant pool constant.  */
    5914                 :            : bool
    5915                 :      10156 : constant_pool_constant_p (rtx x)
    5916                 :            : {
    5917                 :      10156 :   x = avoid_constant_pool_reference (x);
    5918                 :      10156 :   return CONST_DOUBLE_P (x);
    5919                 :            : }
    5920                 :            : 
    5921                 :            : /* If M is a bitmask that selects a field of low-order bits within an item but
    5922                 :            :    not the entire word, return the length of the field.  Return -1 otherwise.
    5923                 :            :    M is used in machine mode MODE.  */
    5924                 :            : 
    5925                 :            : int
    5926                 :      14868 : low_bitmask_len (machine_mode mode, unsigned HOST_WIDE_INT m)
    5927                 :            : {
    5928                 :      14868 :   if (mode != VOIDmode)
    5929                 :            :     {
    5930                 :      14868 :       if (!HWI_COMPUTABLE_MODE_P (mode))
    5931                 :          0 :         return -1;
    5932                 :      14868 :       m &= GET_MODE_MASK (mode);
    5933                 :            :     }
    5934                 :            : 
    5935                 :      14868 :   return exact_log2 (m + 1);
    5936                 :            : }
    5937                 :            : 
    5938                 :            : /* Return the mode of MEM's address.  */
    5939                 :            : 
    5940                 :            : scalar_int_mode
    5941                 :  126859000 : get_address_mode (rtx mem)
    5942                 :            : {
    5943                 :  126859000 :   machine_mode mode;
    5944                 :            : 
    5945                 :  126859000 :   gcc_assert (MEM_P (mem));
    5946                 :  126859000 :   mode = GET_MODE (XEXP (mem, 0));
    5947                 :  126859000 :   if (mode != VOIDmode)
    5948                 :  126513000 :     return as_a <scalar_int_mode> (mode);
    5949                 :     346235 :   return targetm.addr_space.address_mode (MEM_ADDR_SPACE (mem));
    5950                 :            : }
    5951                 :            : 
    5952                 :            : /* Split up a CONST_DOUBLE or integer constant rtx
    5953                 :            :    into two rtx's for single words,
    5954                 :            :    storing in *FIRST the word that comes first in memory in the target
    5955                 :            :    and in *SECOND the other.
    5956                 :            : 
    5957                 :            :    TODO: This function needs to be rewritten to work on any size
    5958                 :            :    integer.  */
    5959                 :            : 
    5960                 :            : void
    5961                 :          0 : split_double (rtx value, rtx *first, rtx *second)
    5962                 :            : {
    5963                 :          0 :   if (CONST_INT_P (value))
    5964                 :            :     {
    5965                 :          0 :       if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD))
    5966                 :            :         {
    5967                 :            :           /* In this case the CONST_INT holds both target words.
    5968                 :            :              Extract the bits from it into two word-sized pieces.
    5969                 :            :              Sign extend each half to HOST_WIDE_INT.  */
    5970                 :          0 :           unsigned HOST_WIDE_INT low, high;
    5971                 :          0 :           unsigned HOST_WIDE_INT mask, sign_bit, sign_extend;
    5972                 :          0 :           unsigned bits_per_word = BITS_PER_WORD;
    5973                 :            : 
    5974                 :            :           /* Set sign_bit to the most significant bit of a word.  */
    5975                 :          0 :           sign_bit = 1;
    5976                 :          0 :           sign_bit <<= bits_per_word - 1;
    5977                 :            : 
    5978                 :            :           /* Set mask so that all bits of the word are set.  We could
    5979                 :            :              have used 1 << BITS_PER_WORD instead of basing the
    5980                 :            :              calculation on sign_bit.  However, on machines where
    5981                 :            :              HOST_BITS_PER_WIDE_INT == BITS_PER_WORD, it could cause a
    5982                 :            :              compiler warning, even though the code would never be
    5983                 :            :              executed.  */
    5984                 :          0 :           mask = sign_bit << 1;
    5985                 :          0 :           mask--;
    5986                 :            : 
    5987                 :            :           /* Set sign_extend as any remaining bits.  */
    5988                 :          0 :           sign_extend = ~mask;
    5989                 :            : 
    5990                 :            :           /* Pick the lower word and sign-extend it.  */
    5991                 :          0 :           low = INTVAL (value);
    5992                 :          0 :           low &= mask;
    5993                 :          0 :           if (low & sign_bit)
    5994                 :          0 :             low |= sign_extend;
    5995                 :            : 
    5996                 :            :           /* Pick the higher word, shifted to the least significant
    5997                 :            :              bits, and sign-extend it.  */
    5998                 :          0 :           high = INTVAL (value);
    5999                 :          0 :           high >>= bits_per_word - 1;
    6000                 :          0 :           high >>= 1;
    6001                 :          0 :           high &= mask;
    6002                 :          0 :           if (high & sign_bit)
    6003                 :          0 :             high |= sign_extend;
    6004                 :            : 
    6005                 :            :           /* Store the words in the target machine order.  */
    6006                 :          0 :           if (WORDS_BIG_ENDIAN)
    6007                 :            :             {
    6008                 :            :               *first = GEN_INT (high);
    6009                 :            :               *second = GEN_INT (low);
    6010                 :            :             }
    6011                 :            :           else
    6012                 :            :             {
    6013                 :          0 :               *first = GEN_INT (low);
    6014                 :          0 :               *second = GEN_INT (high);
    6015                 :            :             }
    6016                 :            :         }
    6017                 :            :       else
    6018                 :            :         {
    6019                 :            :           /* The rule for using CONST_INT for a wider mode
    6020                 :            :              is that we regard the value as signed.
    6021                 :            :              So sign-extend it.  */
    6022                 :          0 :           rtx high = (INTVAL (value) < 0 ? constm1_rtx : const0_rtx);
    6023                 :          0 :           if (WORDS_BIG_ENDIAN)
    6024                 :            :             {
    6025                 :            :               *first = high;
    6026                 :            :               *second = value;
    6027                 :            :             }
    6028                 :            :           else
    6029                 :            :             {
    6030                 :          0 :               *first = value;
    6031                 :          0 :               *second = high;
    6032                 :            :             }
    6033                 :            :         }
    6034                 :            :     }
    6035                 :          0 :   else if (GET_CODE (value) == CONST_WIDE_INT)
    6036                 :            :     {
    6037                 :            :       /* All of this is scary code and needs to be converted to
    6038                 :            :          properly work with any size integer.  */
    6039                 :          0 :       gcc_assert (CONST_WIDE_INT_NUNITS (value) == 2);
    6040                 :          0 :       if (WORDS_BIG_ENDIAN)
    6041                 :            :         {
    6042                 :            :           *first = GEN_INT (CONST_WIDE_INT_ELT (value, 1));
    6043                 :            :           *second = GEN_INT (CONST_WIDE_INT_ELT (value, 0));
    6044                 :            :         }
    6045                 :            :       else
    6046                 :            :         {
    6047                 :          0 :           *first = GEN_INT (CONST_WIDE_INT_ELT (value, 0));
    6048                 :          0 :           *second = GEN_INT (CONST_WIDE_INT_ELT (value, 1));
    6049                 :            :         }
    6050                 :            :     }
    6051                 :          0 :   else if (!CONST_DOUBLE_P (value))
    6052                 :            :     {
    6053                 :          0 :       if (WORDS_BIG_ENDIAN)
    6054                 :            :         {
    6055                 :            :           *first = const0_rtx;
    6056                 :            :           *second = value;
    6057                 :            :         }
    6058                 :            :       else
    6059                 :            :         {
    6060                 :          0 :           *first = value;
    6061                 :          0 :           *second = const0_rtx;
    6062                 :            :         }
    6063                 :            :     }
    6064                 :          0 :   else if (GET_MODE (value) == VOIDmode
    6065                 :            :            /* This is the old way we did CONST_DOUBLE integers.  */
    6066                 :          0 :            || GET_MODE_CLASS (GET_MODE (value)) == MODE_INT)
    6067                 :            :     {
    6068                 :            :       /* In an integer, the words are defined as most and least significant.
    6069                 :            :          So order them by the target's convention.  */
    6070                 :          0 :       if (WORDS_BIG_ENDIAN)
    6071                 :            :         {
    6072                 :            :           *first = GEN_INT (CONST_DOUBLE_HIGH (value));
    6073                 :            :           *second = GEN_INT (CONST_DOUBLE_LOW (value));
    6074                 :            :         }
    6075                 :            :       else
    6076                 :            :         {
    6077                 :          0 :           *first = GEN_INT (CONST_DOUBLE_LOW (value));
    6078                 :          0 :           *second = GEN_INT (CONST_DOUBLE_HIGH (value));
    6079                 :            :         }
    6080                 :            :     }
    6081                 :            :   else
    6082                 :            :     {
    6083                 :          0 :       long l[2];
    6084                 :            : 
    6085                 :            :       /* Note, this converts the REAL_VALUE_TYPE to the target's
    6086                 :            :          format, splits up the floating point double and outputs
    6087                 :            :          exactly 32 bits of it into each of l[0] and l[1] --
    6088                 :            :          not necessarily BITS_PER_WORD bits.  */
    6089                 :          0 :       REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (value), l);
    6090                 :            : 
    6091                 :            :       /* If 32 bits is an entire word for the target, but not for the host,
    6092                 :            :          then sign-extend on the host so that the number will look the same
    6093                 :            :          way on the host that it would on the target.  See for instance
    6094                 :            :          simplify_unary_operation.  The #if is needed to avoid compiler
    6095                 :            :          warnings.  */
    6096                 :            : 
    6097                 :            : #if HOST_BITS_PER_LONG > 32
    6098                 :          0 :       if (BITS_PER_WORD < HOST_BITS_PER_LONG && BITS_PER_WORD == 32)
    6099                 :            :         {
    6100                 :          0 :           if (l[0] & ((long) 1 << 31))
    6101                 :          0 :             l[0] |= ((unsigned long) (-1) << 32);
    6102                 :          0 :           if (l[1] & ((long) 1 << 31))
    6103                 :          0 :             l[1] |= ((unsigned long) (-1) << 32);
    6104                 :            :         }
    6105                 :            : #endif
    6106                 :            : 
    6107                 :          0 :       *first = GEN_INT (l[0]);
    6108                 :          0 :       *second = GEN_INT (l[1]);
    6109                 :            :     }
    6110                 :          0 : }
    6111                 :            : 
    6112                 :            : /* Return true if X is a sign_extract or zero_extract from the least
    6113                 :            :    significant bit.  */
    6114                 :            : 
    6115                 :            : static bool
    6116                 :  132616000 : lsb_bitfield_op_p (rtx x)
    6117                 :            : {
    6118                 :          0 :   if (GET_RTX_CLASS (GET_CODE (x)) == RTX_BITFIELD_OPS)
    6119                 :            :     {
    6120                 :          0 :       machine_mode mode = GET_MODE (XEXP (x, 0));
    6121                 :          0 :       HOST_WIDE_INT len = INTVAL (XEXP (x, 1));
    6122                 :          0 :       HOST_WIDE_INT pos = INTVAL (XEXP (x, 2));
    6123                 :          0 :       poly_int64 remaining_bits = GET_MODE_PRECISION (mode) - len;
    6124                 :            : 
    6125                 :          0 :       return known_eq (pos, BITS_BIG_ENDIAN ? remaining_bits : 0);
    6126                 :            :     }
    6127                 :            :   return false;
    6128                 :            : }
    6129                 :            : 
    6130                 :            : /* Strip outer address "mutations" from LOC and return a pointer to the
    6131                 :            :    inner value.  If OUTER_CODE is nonnull, store the code of the innermost
    6132                 :            :    stripped expression there.
    6133                 :            : 
    6134                 :            :    "Mutations" either convert between modes or apply some kind of
    6135                 :            :    extension, truncation or alignment.  */
    6136                 :            : 
    6137                 :            : rtx *
    6138                 :  132616000 : strip_address_mutations (rtx *loc, enum rtx_code *outer_code)
    6139                 :            : {
    6140                 :  132644000 :   for (;;)
    6141                 :            :     {
    6142                 :  132644000 :       enum rtx_code code = GET_CODE (*loc);
    6143                 :  132644000 :       if (GET_RTX_CLASS (code) == RTX_UNARY)
    6144                 :            :         /* Things like SIGN_EXTEND, ZERO_EXTEND and TRUNCATE can be
    6145                 :            :            used to convert between pointer sizes.  */
    6146                 :      27869 :         loc = &XEXP (*loc, 0);
    6147                 :  132616000 :       else if (lsb_bitfield_op_p (*loc))
    6148                 :            :         /* A [SIGN|ZERO]_EXTRACT from the least significant bit effectively
    6149                 :            :            acts as a combined truncation and extension.  */
    6150                 :          0 :         loc = &XEXP (*loc, 0);
    6151                 :  132616000 :       else if (code == AND && CONST_INT_P (XEXP (*loc, 1)))
    6152                 :            :         /* (and ... (const_int -X)) is used to align to X bytes.  */
    6153                 :          2 :         loc = &XEXP (*loc, 0);
    6154                 :  132616000 :       else if (code == SUBREG
    6155                 :       8874 :                && !OBJECT_P (SUBREG_REG (*loc))
    6156                 :  132616000 :                && subreg_lowpart_p (*loc))
    6157                 :            :         /* (subreg (operator ...) ...) inside and is used for mode
    6158                 :            :            conversion too.  */
    6159                 :          2 :         loc = &SUBREG_REG (*loc);
    6160                 :            :       else
    6161                 :  132616000 :         return loc;
    6162                 :      27873 :       if (outer_code)
    6163                 :      27873 :         *outer_code = code;
    6164                 :            :     }
    6165                 :            : }
    6166                 :            : 
    6167                 :            : /* Return true if CODE applies some kind of scale.  The scaled value is
    6168                 :            :    is the first operand and the scale is the second.  */
    6169                 :            : 
    6170                 :            : static bool
    6171                 :   40718300 : binary_scale_code_p (enum rtx_code code)
    6172                 :            : {
    6173                 :   40718300 :   return (code == MULT
    6174                 :   40718300 :           || code == ASHIFT
    6175                 :            :           /* Needed by ARM targets.  */
    6176                 :            :           || code == ASHIFTRT
    6177                 :   39276400 :           || code == LSHIFTRT
    6178                 :   39276400 :           || code == ROTATE
    6179                 :   39276400 :           || code == ROTATERT);
    6180                 :            : }
    6181                 :            : 
    6182                 :            : /* If *INNER can be interpreted as a base, return a pointer to the inner term
    6183                 :            :    (see address_info).  Return null otherwise.  */
    6184                 :            : 
    6185                 :            : static rtx *
    6186                 :   40718300 : get_base_term (rtx *inner)
    6187                 :            : {
    6188                 :   40718300 :   if (GET_CODE (*inner) == LO_SUM)
    6189                 :          0 :     inner = strip_address_mutations (&XEXP (*inner, 0));
    6190                 :   40718300 :   if (REG_P (*inner)
    6191                 :   40718300 :       || MEM_P (*inner)
    6192                 :    1448680 :       || GET_CODE (*inner) == SUBREG
    6193                 :    1441900 :       || GET_CODE (*inner) == SCRATCH)
    6194                 :   39276400 :     return inner;
    6195                 :            :   return 0;
    6196                 :            : }
    6197                 :            : 
    6198                 :            : /* If *INNER can be interpreted as an index, return a pointer to the inner term
    6199                 :            :    (see address_info).  Return null otherwise.  */
    6200                 :            : 
    6201                 :            : static rtx *
    6202                 :   40718300 : get_index_term (rtx *inner)
    6203                 :            : {
    6204                 :            :   /* At present, only constant scales are allowed.  */
    6205                 :   40718300 :   if (binary_scale_code_p (GET_CODE (*inner)) && CONSTANT_P (XEXP (*inner, 1)))
    6206                 :    1441900 :     inner = strip_address_mutations (&XEXP (*inner, 0));
    6207                 :   40718300 :   if (REG_P (*inner)
    6208                 :   40718300 :       || MEM_P (*inner)
    6209                 :       8037 :       || GET_CODE (*inner) == SUBREG
    6210                 :          0 :       || GET_CODE (*inner) == SCRATCH)
    6211                 :   40718300 :     return inner;
    6212                 :            :   return 0;
    6213                 :            : }
    6214                 :            : 
    6215                 :            : /* Set the segment part of address INFO to LOC, given that INNER is the
    6216                 :            :    unmutated value.  */
    6217                 :            : 
    6218                 :            : static void
    6219                 :         28 : set_address_segment (struct address_info *info, rtx *loc, rtx *inner)
    6220                 :            : {
    6221                 :          0 :   gcc_assert (!info->segment);
    6222                 :         28 :   info->segment = loc;
    6223                 :         28 :   info->segment_term = inner;
    6224                 :         28 : }
    6225                 :            : 
    6226                 :            : /* Set the base part of address INFO to LOC, given that INNER is the
    6227                 :            :    unmutated value.  */
    6228                 :            : 
    6229                 :            : static void
    6230                 :   40856800 : set_address_base (struct address_info *info, rtx *loc, rtx *inner)
    6231                 :            : {
    6232                 :          0 :   gcc_assert (!info->base);
    6233                 :   40856800 :   info->base = loc;
    6234                 :   40856800 :   info->base_term = inner;
    6235                 :          0 : }
    6236                 :            : 
    6237                 :            : /* Set the index part of address INFO to LOC, given that INNER is the
    6238                 :            :    unmutated value.  */
    6239                 :            : 
    6240                 :            : static void
    6241                 :    2193000 : set_address_index (struct address_info *info, rtx *loc, rtx *inner)
    6242                 :            : {
    6243                 :          0 :   gcc_assert (!info->index);
    6244                 :    2193000 :   info->index = loc;
    6245                 :    2193000 :   info->index_term = inner;
    6246                 :    2193000 : }
    6247                 :            : 
    6248                 :            : /* Set the displacement part of address INFO to LOC, given that INNER
    6249                 :            :    is the constant term.  */
    6250                 :            : 
    6251                 :            : static void
    6252                 :   41522800 : set_address_disp (struct address_info *info, rtx *loc, rtx *inner)
    6253                 :            : {
    6254                 :          0 :   gcc_assert (!info->disp);
    6255                 :   41522800 :   info->disp = loc;
    6256                 :   41522800 :   info->disp_term = inner;
    6257                 :   41522800 : }
    6258                 :            : 
    6259                 :            : /* INFO->INNER describes a {PRE,POST}_{INC,DEC} address.  Set up the
    6260                 :            :    rest of INFO accordingly.  */
    6261                 :            : 
    6262                 :            : static void
    6263                 :    2258240 : decompose_incdec_address (struct address_info *info)
    6264                 :            : {
    6265                 :    2258240 :   info->autoinc_p = true;
    6266                 :            : 
    6267                 :    2258240 :   rtx *base = &XEXP (*info->inner, 0);
    6268                 :    2258240 :   set_address_base (info, base, base);
    6269                 :    2258240 :   gcc_checking_assert (info->base == info->base_term);
    6270                 :            : 
    6271                 :            :   /* These addresses are only valid when the size of the addressed
    6272                 :            :      value is known.  */
    6273                 :    2258240 :   gcc_checking_assert (info->mode != VOIDmode);
    6274                 :    2258240 : }
    6275                 :            : 
    6276                 :            : /* INFO->INNER describes a {PRE,POST}_MODIFY address.  Set up the rest
    6277                 :            :    of INFO accordingly.  */
    6278                 :            : 
    6279                 :            : static void
    6280                 :      73173 : decompose_automod_address (struct address_info *info)
    6281                 :            : {
    6282                 :      73173 :   info->autoinc_p = true;
    6283                 :            : 
    6284                 :      73173 :   rtx *base = &XEXP (*info->inner, 0);
    6285                 :      73173 :   set_address_base (info, base, base);
    6286                 :      73173 :   gcc_checking_assert (info->base == info->base_term);
    6287                 :            : 
    6288                 :      73173 :   rtx plus = XEXP (*info->inner, 1);
    6289                 :      73173 :   gcc_assert (GET_CODE (plus) == PLUS);
    6290                 :            : 
    6291                 :      73173 :   info->base_term2 = &XEXP (plus, 0);
    6292                 :      73173 :   gcc_checking_assert (rtx_equal_p (*info->base_term, *info->base_term2));
    6293                 :            : 
    6294                 :      73173 :   rtx *step = &XEXP (plus, 1);
    6295                 :      73173 :   rtx *inner_step = strip_address_mutations (step);
    6296                 :      73173 :   if (CONSTANT_P (*inner_step))
    6297                 :      73173 :     set_address_disp (info, step, inner_step);
    6298                 :            :   else
    6299                 :          0 :     set_address_index (info, step, inner_step);
    6300                 :      73173 : }
    6301                 :            : 
    6302                 :            : /* Treat *LOC as a tree of PLUS operands and store pointers to the summed
    6303                 :            :    values in [PTR, END).  Return a pointer to the end of the used array.  */
    6304                 :            : 
    6305                 :            : static rtx **
    6306                 :   82168000 : extract_plus_operands (rtx *loc, rtx **ptr, rtx **end)
    6307                 :            : {
    6308                 :  117734000 :   rtx x = *loc;
    6309                 :  117734000 :   if (GET_CODE (x) == PLUS)
    6310                 :            :     {
    6311                 :   35566100 :       ptr = extract_plus_operands (&XEXP (x, 0), ptr, end);
    6312                 :   35566100 :       ptr = extract_plus_operands (&XEXP (x, 1), ptr, end);
    6313                 :            :     }
    6314                 :            :   else
    6315                 :            :     {
    6316                 :   82168000 :       gcc_assert (ptr != end);
    6317                 :   82168000 :       *ptr++ = loc;
    6318                 :            :     }
    6319                 :   82168000 :   return ptr;
    6320                 :            : }
    6321                 :            : 
    6322                 :            : /* Evaluate the likelihood of X being a base or index value, returning
    6323                 :            :    positive if it is likely to be a base, negative if it is likely to be
    6324                 :            :    an index, and 0 if we can't tell.  Make the magnitude of the return
    6325                 :            :    value reflect the amount of confidence we have in the answer.
    6326                 :            : 
    6327                 :            :    MODE, AS, OUTER_CODE and INDEX_CODE are as for ok_for_base_p_1.  */
    6328                 :            : 
    6329                 :            : static int
    6330                 :    1502210 : baseness (rtx x, machine_mode mode, addr_space_t as,
    6331                 :            :           enum rtx_code outer_code, enum rtx_code index_code)
    6332                 :            : {
    6333                 :            :   /* Believe *_POINTER unless the address shape requires otherwise.  */
    6334                 :    1502210 :   if (REG_P (x) && REG_POINTER (x))
    6335                 :            :     return 2;
    6336                 :     896696 :   if (MEM_P (x) && MEM_POINTER (x))
    6337                 :            :     return 2;
    6338                 :            : 
    6339                 :     896696 :   if (REG_P (x) && HARD_REGISTER_P (x))
    6340                 :            :     {
    6341                 :            :       /* X is a hard register.  If it only fits one of the base
    6342                 :            :          or index classes, choose that interpretation.  */
    6343                 :         14 :       int regno = REGNO (x);
    6344                 :         14 :       bool base_p = ok_for_base_p_1 (regno, mode, as, outer_code, index_code);
    6345                 :         14 :       bool index_p = REGNO_OK_FOR_INDEX_P (regno);
    6346                 :         14 :       if (base_p != index_p)
    6347                 :          0 :         return base_p ? 1 : -1;
    6348                 :            :     }
    6349                 :            :   return 0;
    6350                 :            : }
    6351                 :            : 
    6352                 :            : /* INFO->INNER describes a normal, non-automodified address.
    6353                 :            :    Fill in the rest of INFO accordingly.  */
    6354                 :            : 
    6355                 :            : static void
    6356                 :   46601900 : decompose_normal_address (struct address_info *info)
    6357                 :            : {
    6358                 :            :   /* Treat the address as the sum of up to four values.  */
    6359                 :   46601900 :   rtx *ops[4];
    6360                 :   46601900 :   size_t n_ops = extract_plus_operands (info->inner, ops,
    6361                 :   46601900 :                                         ops + ARRAY_SIZE (ops)) - ops;
    6362                 :            : 
    6363                 :            :   /* If there is more than one component, any base component is in a PLUS.  */
    6364                 :   46601900 :   if (n_ops > 1)
    6365                 :   34825000 :     info->base_outer_code = PLUS;
    6366                 :            : 
    6367                 :            :   /* Try to classify each sum operand now.  Leave those that could be
    6368                 :            :      either a base or an index in OPS.  */
    6369                 :            :   rtx *inner_ops[4];
    6370                 :            :   size_t out = 0;
    6371                 :  128770000 :   for (size_t in = 0; in < n_ops; ++in)
    6372                 :            :     {
    6373                 :   82168000 :       rtx *loc = ops[in];
    6374                 :   82168000 :       rtx *inner = strip_address_mutations (loc);
    6375                 :   82168000 :       if (CONSTANT_P (*inner))
    6376                 :   41449700 :         set_address_disp (info, loc, inner);
    6377                 :   40718400 :       else if (GET_CODE (*inner) == UNSPEC)
    6378                 :         28 :         set_address_segment (info, loc, inner);
    6379                 :            :       else
    6380                 :            :         {
    6381                 :            :           /* The only other possibilities are a base or an index.  */
    6382                 :   40718300 :           rtx *base_term = get_base_term (inner);
    6383                 :   40718300 :           rtx *index_term = get_index_term (inner);
    6384                 :   40718300 :           gcc_assert (base_term || index_term);
    6385                 :   40718300 :           if (!base_term)
    6386                 :    1441900 :             set_address_index (info, loc, index_term);
    6387                 :   39276400 :           else if (!index_term)
    6388                 :   82168000 :             set_address_base (info, loc, base_term);
    6389                 :            :           else
    6390                 :            :             {
    6391                 :   39276400 :               gcc_assert (base_term == index_term);
    6392                 :   39276400 :               ops[out] = loc;
    6393                 :   39276400 :               inner_ops[out] = base_term;
    6394                 :   39276400 :               ++out;
    6395                 :            :             }
    6396                 :            :         }
    6397                 :            :     }
    6398                 :            : 
    6399                 :            :   /* Classify the remaining OPS members as bases and indexes.  */
    6400                 :   46601900 :   if (out == 1)
    6401                 :            :     {
    6402                 :            :       /* If we haven't seen a base or an index yet, assume that this is
    6403                 :            :          the base.  If we were confident that another term was the base
    6404                 :            :          or index, treat the remaining operand as the other kind.  */
    6405                 :   37774200 :       if (!info->base)
    6406                 :   37774200 :         set_address_base (info, ops[0], inner_ops[0]);
    6407                 :            :       else
    6408                 :          0 :         set_address_index (info, ops[0], inner_ops[0]);
    6409                 :            :     }
    6410                 :    8827640 :   else if (out == 2)
    6411                 :            :     {
    6412                 :            :       /* In the event of a tie, assume the base comes first.  */
    6413                 :     751106 :       if (baseness (*inner_ops[0], info->mode, info->as, PLUS,
    6414                 :     751106 :                     GET_CODE (*ops[1]))
    6415                 :     751106 :           >= baseness (*inner_ops[1], info->mode, info->as, PLUS,
    6416                 :     751106 :                        GET_CODE (*ops[0])))
    6417                 :            :         {
    6418                 :     741980 :           set_address_base (info, ops[0], inner_ops[0]);
    6419                 :     741980 :           set_address_index (info, ops[1], inner_ops[1]);
    6420                 :            :         }
    6421                 :            :       else
    6422                 :            :         {
    6423                 :       9126 :           set_address_base (info, ops[1], inner_ops[1]);
    6424                 :       9126 :           set_address_index (info, ops[0], inner_ops[0]);
    6425                 :            :         }
    6426                 :            :     }
    6427                 :            :   else
    6428                 :    8076540 :     gcc_assert (out == 0);
    6429                 :   46601900 : }
    6430                 :            : 
    6431                 :            : /* Describe address *LOC in *INFO.  MODE is the mode of the addressed value,
    6432                 :            :    or VOIDmode if not known.  AS is the address space associated with LOC.
    6433                 :            :    OUTER_CODE is MEM if *LOC is a MEM address and ADDRESS otherwise.  */
    6434                 :            : 
    6435                 :            : void
    6436                 :   48933300 : decompose_address (struct address_info *info, rtx *loc, machine_mode mode,
    6437                 :            :                    addr_space_t as, enum rtx_code outer_code)
    6438                 :            : {
    6439                 :   48933300 :   memset (info, 0, sizeof (*info));
    6440                 :   48933300 :   info->mode = mode;
    6441                 :   48933300 :   info->as = as;
    6442                 :   48933300 :   info->addr_outer_code = outer_code;
    6443                 :   48933300 :   info->outer = loc;
    6444                 :   48933300 :   info->inner = strip_address_mutations (loc, &outer_code);
    6445                 :   48933300 :   info->base_outer_code = outer_code;
    6446                 :   48933300 :   switch (GET_CODE (*info->inner))
    6447                 :            :     {
    6448                 :    2258240 :     case PRE_DEC:
    6449                 :    2258240 :     case PRE_INC:
    6450                 :    2258240 :     case POST_DEC:
    6451                 :    2258240 :     case POST_INC:
    6452                 :    2258240 :       decompose_incdec_address (info);
    6453                 :    2258240 :       break;
    6454                 :            : 
    6455                 :      73173 :     case PRE_MODIFY:
    6456                 :      73173 :     case POST_MODIFY:
    6457                 :      73173 :       decompose_automod_address (info);
    6458                 :      73173 :       break;
    6459                 :            : 
    6460                 :   46601900 :     default:
    6461                 :   46601900 :       decompose_normal_address (info);
    6462                 :   46601900 :       break;
    6463                 :            :     }
    6464                 :   48933300 : }
    6465                 :            : 
    6466                 :            : /* Describe address operand LOC in INFO.  */
    6467                 :            : 
    6468                 :            : void
    6469                 :    2513730 : decompose_lea_address (struct address_info *info, rtx *loc)
    6470                 :            : {
    6471                 :    2513730 :   decompose_address (info, loc, VOIDmode, ADDR_SPACE_GENERIC, ADDRESS);
    6472                 :    2513730 : }
    6473                 :            : 
    6474                 :            : /* Describe the address of MEM X in INFO.  */
    6475                 :            : 
    6476                 :            : void
    6477                 :   46389200 : decompose_mem_address (struct address_info *info, rtx x)
    6478                 :            : {
    6479                 :   46389200 :   gcc_assert (MEM_P (x));
    6480                 :   46389200 :   decompose_address (info, &XEXP (x, 0), GET_MODE (x),
    6481                 :   46389200 :                      MEM_ADDR_SPACE (x), MEM);
    6482                 :   46389200 : }
    6483                 :            : 
    6484                 :            : /* Update INFO after a change to the address it describes.  */
    6485                 :            : 
    6486                 :            : void
    6487                 :      30400 : update_address (struct address_info *info)
    6488                 :            : {
    6489                 :      30400 :   decompose_address (info, info->outer, info->mode, info->as,
    6490                 :            :                      info->addr_outer_code);
    6491                 :      30400 : }
    6492                 :            : 
    6493                 :            : /* Return the scale applied to *INFO->INDEX_TERM, or 0 if the index is
    6494                 :            :    more complicated than that.  */
    6495                 :            : 
    6496                 :            : HOST_WIDE_INT
    6497                 :          1 : get_index_scale (const struct address_info *info)
    6498                 :            : {
    6499                 :          1 :   rtx index = *info->index;
    6500                 :          1 :   if (GET_CODE (index) == MULT
    6501                 :          0 :       && CONST_INT_P (XEXP (index, 1))
    6502                 :          0 :       && info->index_term == &XEXP (index, 0))
    6503                 :          0 :     return INTVAL (XEXP (index, 1));
    6504                 :            : 
    6505                 :          1 :   if (GET_CODE (index) == ASHIFT
    6506                 :          0 :       && CONST_INT_P (XEXP (index, 1))
    6507                 :          0 :       && info->index_term == &XEXP (index, 0))
    6508                 :          0 :     return HOST_WIDE_INT_1 << INTVAL (XEXP (index, 1));
    6509                 :            : 
    6510                 :          1 :   if (info->index == info->index_term)
    6511                 :          1 :     return 1;
    6512                 :            : 
    6513                 :            :   return 0;
    6514                 :            : }
    6515                 :            : 
    6516                 :            : /* Return the "index code" of INFO, in the form required by
    6517                 :            :    ok_for_base_p_1.  */
    6518                 :            : 
    6519                 :            : enum rtx_code
    6520                 :   21868400 : get_index_code (const struct address_info *info)
    6521                 :            : {
    6522                 :   21868400 :   if (info->index)
    6523                 :     863966 :     return GET_CODE (*info->index);
    6524                 :            : 
    6525                 :   21004400 :   if (info->disp)
    6526                 :   16639500 :     return GET_CODE (*info->disp);
    6527                 :            : 
    6528                 :            :   return SCRATCH;
    6529                 :            : }
    6530                 :            : 
    6531                 :            : /* Return true if RTL X contains a SYMBOL_REF.  */
    6532                 :            : 
    6533                 :            : bool
    6534                 :     557117 : contains_symbol_ref_p (const_rtx x)
    6535                 :            : {
    6536                 :     557117 :   subrtx_iterator::array_type array;
    6537                 :    2386980 :   FOR_EACH_SUBRTX (iter, array, x, ALL)
    6538                 :    1903240 :     if (SYMBOL_REF_P (*iter))
    6539                 :      73378 :       return true;
    6540                 :            : 
    6541                 :     483739 :   return false;
    6542                 :            : }
    6543                 :            : 
    6544                 :            : /* Return true if RTL X contains a SYMBOL_REF or LABEL_REF.  */
    6545                 :            : 
    6546                 :            : bool
    6547                 :     110940 : contains_symbolic_reference_p (const_rtx x)
    6548                 :            : {
    6549                 :     110940 :   subrtx_iterator::array_type array;
    6550                 :     293936 :   FOR_EACH_SUBRTX (iter, array, x, ALL)
    6551                 :     184602 :     if (SYMBOL_REF_P (*iter) || GET_CODE (*iter) == LABEL_REF)
    6552                 :       1606 :       return true;
    6553                 :            : 
    6554                 :     109334 :   return false;
    6555                 :            : }
    6556                 :            : 
    6557                 :            : /* Return true if RTL X contains a constant pool address.  */
    6558                 :            : 
    6559                 :            : bool
    6560                 :          0 : contains_constant_pool_address_p (const_rtx x)
    6561                 :            : {
    6562                 :          0 :   subrtx_iterator::array_type array;
    6563                 :          0 :   FOR_EACH_SUBRTX (iter, array, x, ALL)
    6564                 :          0 :     if (SYMBOL_REF_P (*iter) && CONSTANT_POOL_ADDRESS_P (*iter))
    6565                 :          0 :       return true;
    6566                 :            : 
    6567                 :          0 :   return false;
    6568                 :            : }
    6569                 :            : 
    6570                 :            : 
    6571                 :            : /* Return true if X contains a thread-local symbol.  */
    6572                 :            : 
    6573                 :            : bool
    6574                 :          0 : tls_referenced_p (const_rtx x)
    6575                 :            : {
    6576                 :          0 :   if (!targetm.have_tls)
    6577                 :            :     return false;
    6578                 :            : 
    6579                 :          0 :   subrtx_iterator::array_type array;
    6580                 :          0 :   FOR_EACH_SUBRTX (iter, array, x, ALL)
    6581                 :          0 :     if (GET_CODE (*iter) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (*iter) != 0)
    6582                 :          0 :       return true;
    6583                 :          0 :   return false;
    6584                 :            : }

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.