LCOV - code coverage report
Current view: top level - gcc - simplify-rtx.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 3330 3743 89.0 %
Date: 2020-04-04 11:58:09 Functions: 58 60 96.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* RTL simplification functions 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 "memmodel.h"
      30                 :            : #include "optabs.h"
      31                 :            : #include "emit-rtl.h"
      32                 :            : #include "recog.h"
      33                 :            : #include "diagnostic-core.h"
      34                 :            : #include "varasm.h"
      35                 :            : #include "flags.h"
      36                 :            : #include "selftest.h"
      37                 :            : #include "selftest-rtl.h"
      38                 :            : #include "rtx-vector-builder.h"
      39                 :            : 
      40                 :            : /* Simplification and canonicalization of RTL.  */
      41                 :            : 
      42                 :            : /* Much code operates on (low, high) pairs; the low value is an
      43                 :            :    unsigned wide int, the high value a signed wide int.  We
      44                 :            :    occasionally need to sign extend from low to high as if low were a
      45                 :            :    signed wide int.  */
      46                 :            : #define HWI_SIGN_EXTEND(low) \
      47                 :            :   ((((HOST_WIDE_INT) low) < 0) ? HOST_WIDE_INT_M1 : HOST_WIDE_INT_0)
      48                 :            : 
      49                 :            : static bool plus_minus_operand_p (const_rtx);
      50                 :            : static rtx simplify_plus_minus (enum rtx_code, machine_mode, rtx, rtx);
      51                 :            : static rtx simplify_associative_operation (enum rtx_code, machine_mode,
      52                 :            :                                            rtx, rtx);
      53                 :            : static rtx simplify_relational_operation_1 (enum rtx_code, machine_mode,
      54                 :            :                                             machine_mode, rtx, rtx);
      55                 :            : static rtx simplify_unary_operation_1 (enum rtx_code, machine_mode, rtx);
      56                 :            : static rtx simplify_binary_operation_1 (enum rtx_code, machine_mode,
      57                 :            :                                         rtx, rtx, rtx, rtx);
      58                 :            : 
      59                 :            : /* Negate I, which satisfies poly_int_rtx_p.  MODE is the mode of I.  */
      60                 :            : 
      61                 :            : static rtx
      62                 :    4315920 : neg_poly_int_rtx (machine_mode mode, const_rtx i)
      63                 :            : {
      64                 :    4315920 :   return immed_wide_int_const (-wi::to_poly_wide (i, mode), mode);
      65                 :            : }
      66                 :            : 
      67                 :            : /* Test whether expression, X, is an immediate constant that represents
      68                 :            :    the most significant bit of machine mode MODE.  */
      69                 :            : 
      70                 :            : bool
      71                 :    3918840 : mode_signbit_p (machine_mode mode, const_rtx x)
      72                 :            : {
      73                 :    3918840 :   unsigned HOST_WIDE_INT val;
      74                 :    3918840 :   unsigned int width;
      75                 :    3918840 :   scalar_int_mode int_mode;
      76                 :            : 
      77                 :    3918840 :   if (!is_int_mode (mode, &int_mode))
      78                 :            :     return false;
      79                 :            : 
      80                 :    3918840 :   width = GET_MODE_PRECISION (int_mode);
      81                 :    3918840 :   if (width == 0)
      82                 :            :     return false;
      83                 :            : 
      84                 :    3918840 :   if (width <= HOST_BITS_PER_WIDE_INT
      85                 :    3918840 :       && CONST_INT_P (x))
      86                 :    3850650 :     val = INTVAL (x);
      87                 :            : #if TARGET_SUPPORTS_WIDE_INT
      88                 :      68190 :   else if (CONST_WIDE_INT_P (x))
      89                 :            :     {
      90                 :          0 :       unsigned int i;
      91                 :          0 :       unsigned int elts = CONST_WIDE_INT_NUNITS (x);
      92                 :          0 :       if (elts != (width + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT)
      93                 :            :         return false;
      94                 :          0 :       for (i = 0; i < elts - 1; i++)
      95                 :          0 :         if (CONST_WIDE_INT_ELT (x, i) != 0)
      96                 :            :           return false;
      97                 :          0 :       val = CONST_WIDE_INT_ELT (x, elts - 1);
      98                 :          0 :       width %= HOST_BITS_PER_WIDE_INT;
      99                 :          0 :       if (width == 0)
     100                 :            :         width = HOST_BITS_PER_WIDE_INT;
     101                 :            :     }
     102                 :            : #else
     103                 :            :   else if (width <= HOST_BITS_PER_DOUBLE_INT
     104                 :            :            && CONST_DOUBLE_AS_INT_P (x)
     105                 :            :            && CONST_DOUBLE_LOW (x) == 0)
     106                 :            :     {
     107                 :            :       val = CONST_DOUBLE_HIGH (x);
     108                 :            :       width -= HOST_BITS_PER_WIDE_INT;
     109                 :            :     }
     110                 :            : #endif
     111                 :            :   else
     112                 :            :     /* X is not an integer constant.  */
     113                 :            :     return false;
     114                 :            : 
     115                 :    3850650 :   if (width < HOST_BITS_PER_WIDE_INT)
     116                 :    3525230 :     val &= (HOST_WIDE_INT_1U << width) - 1;
     117                 :    3850650 :   return val == (HOST_WIDE_INT_1U << (width - 1));
     118                 :            : }
     119                 :            : 
     120                 :            : /* Test whether VAL is equal to the most significant bit of mode MODE
     121                 :            :    (after masking with the mode mask of MODE).  Returns false if the
     122                 :            :    precision of MODE is too large to handle.  */
     123                 :            : 
     124                 :            : bool
     125                 :    2950680 : val_signbit_p (machine_mode mode, unsigned HOST_WIDE_INT val)
     126                 :            : {
     127                 :    2950680 :   unsigned int width;
     128                 :    2950680 :   scalar_int_mode int_mode;
     129                 :            : 
     130                 :    2950680 :   if (!is_int_mode (mode, &int_mode))
     131                 :            :     return false;
     132                 :            : 
     133                 :    2950680 :   width = GET_MODE_PRECISION (int_mode);
     134                 :    2950680 :   if (width == 0 || width > HOST_BITS_PER_WIDE_INT)
     135                 :            :     return false;
     136                 :            : 
     137                 :    2950640 :   val &= GET_MODE_MASK (int_mode);
     138                 :    2950640 :   return val == (HOST_WIDE_INT_1U << (width - 1));
     139                 :            : }
     140                 :            : 
     141                 :            : /* Test whether the most significant bit of mode MODE is set in VAL.
     142                 :            :    Returns false if the precision of MODE is too large to handle.  */
     143                 :            : bool
     144                 :    2442190 : val_signbit_known_set_p (machine_mode mode, unsigned HOST_WIDE_INT val)
     145                 :            : {
     146                 :    2442190 :   unsigned int width;
     147                 :            : 
     148                 :    2442190 :   scalar_int_mode int_mode;
     149                 :    2442190 :   if (!is_int_mode (mode, &int_mode))
     150                 :            :     return false;
     151                 :            : 
     152                 :    2417320 :   width = GET_MODE_PRECISION (int_mode);
     153                 :    2417320 :   if (width == 0 || width > HOST_BITS_PER_WIDE_INT)
     154                 :            :     return false;
     155                 :            : 
     156                 :    2417320 :   val &= HOST_WIDE_INT_1U << (width - 1);
     157                 :    2417320 :   return val != 0;
     158                 :            : }
     159                 :            : 
     160                 :            : /* Test whether the most significant bit of mode MODE is clear in VAL.
     161                 :            :    Returns false if the precision of MODE is too large to handle.  */
     162                 :            : bool
     163                 :    3560760 : val_signbit_known_clear_p (machine_mode mode, unsigned HOST_WIDE_INT val)
     164                 :            : {
     165                 :    3560760 :   unsigned int width;
     166                 :            : 
     167                 :    3560760 :   scalar_int_mode int_mode;
     168                 :    3560760 :   if (!is_int_mode (mode, &int_mode))
     169                 :            :     return false;
     170                 :            : 
     171                 :    3377890 :   width = GET_MODE_PRECISION (int_mode);
     172                 :    3377890 :   if (width == 0 || width > HOST_BITS_PER_WIDE_INT)
     173                 :            :     return false;
     174                 :            : 
     175                 :    3377880 :   val &= HOST_WIDE_INT_1U << (width - 1);
     176                 :    3377880 :   return val == 0;
     177                 :            : }
     178                 :            : 
     179                 :            : /* Make a binary operation by properly ordering the operands and
     180                 :            :    seeing if the expression folds.  */
     181                 :            : 
     182                 :            : rtx
     183                 :   56315400 : simplify_gen_binary (enum rtx_code code, machine_mode mode, rtx op0,
     184                 :            :                      rtx op1)
     185                 :            : {
     186                 :   56315400 :   rtx tem;
     187                 :            : 
     188                 :            :   /* If this simplifies, do it.  */
     189                 :   56315400 :   tem = simplify_binary_operation (code, mode, op0, op1);
     190                 :   56315400 :   if (tem)
     191                 :            :     return tem;
     192                 :            : 
     193                 :            :   /* Put complex operands first and constants second if commutative.  */
     194                 :   34444300 :   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
     195                 :   34444300 :       && swap_commutative_operands_p (op0, op1))
     196                 :   34444300 :     std::swap (op0, op1);
     197                 :            : 
     198                 :   34444300 :   return gen_rtx_fmt_ee (code, mode, op0, op1);
     199                 :            : }
     200                 :            : 
     201                 :            : /* If X is a MEM referencing the constant pool, return the real value.
     202                 :            :    Otherwise return X.  */
     203                 :            : rtx
     204                 : 1607690000 : avoid_constant_pool_reference (rtx x)
     205                 :            : {
     206                 : 1607690000 :   rtx c, tmp, addr;
     207                 : 1607690000 :   machine_mode cmode;
     208                 : 1607690000 :   poly_int64 offset = 0;
     209                 :            : 
     210                 : 1607690000 :   switch (GET_CODE (x))
     211                 :            :     {
     212                 :  148990000 :     case MEM:
     213                 :  148990000 :       break;
     214                 :            : 
     215                 :    1143630 :     case FLOAT_EXTEND:
     216                 :            :       /* Handle float extensions of constant pool references.  */
     217                 :    1143630 :       tmp = XEXP (x, 0);
     218                 :    1143630 :       c = avoid_constant_pool_reference (tmp);
     219                 :    1143630 :       if (c != tmp && CONST_DOUBLE_AS_FLOAT_P (c))
     220                 :     180285 :         return const_double_from_real_value (*CONST_DOUBLE_REAL_VALUE (c),
     221                 :     180285 :                                              GET_MODE (x));
     222                 :            :       return x;
     223                 :            : 
     224                 :            :     default:
     225                 :            :       return x;
     226                 :            :     }
     227                 :            : 
     228                 :  148990000 :   if (GET_MODE (x) == BLKmode)
     229                 :            :     return x;
     230                 :            : 
     231                 :  147833000 :   addr = XEXP (x, 0);
     232                 :            : 
     233                 :            :   /* Call target hook to avoid the effects of -fpic etc....  */
     234                 :  147833000 :   addr = targetm.delegitimize_address (addr);
     235                 :            : 
     236                 :            :   /* Split the address into a base and integer offset.  */
     237                 :  147833000 :   addr = strip_offset (addr, &offset);
     238                 :            : 
     239                 :  147833000 :   if (GET_CODE (addr) == LO_SUM)
     240                 :          0 :     addr = XEXP (addr, 1);
     241                 :            : 
     242                 :            :   /* If this is a constant pool reference, we can turn it into its
     243                 :            :      constant and hope that simplifications happen.  */
     244                 :  147833000 :   if (GET_CODE (addr) == SYMBOL_REF
     245                 :  147833000 :       && CONSTANT_POOL_ADDRESS_P (addr))
     246                 :            :     {
     247                 :    3458280 :       c = get_pool_constant (addr);
     248                 :    3458280 :       cmode = get_pool_mode (addr);
     249                 :            : 
     250                 :            :       /* If we're accessing the constant in a different mode than it was
     251                 :            :          originally stored, attempt to fix that up via subreg simplifications.
     252                 :            :          If that fails we have no choice but to return the original memory.  */
     253                 :    3458280 :       if (known_eq (offset, 0) && cmode == GET_MODE (x))
     254                 :            :         return c;
     255                 :       8368 :       else if (known_in_range_p (offset, 0, GET_MODE_SIZE (cmode)))
     256                 :            :         {
     257                 :       4144 :           rtx tem = simplify_subreg (GET_MODE (x), c, cmode, offset);
     258                 :       4144 :           if (tem && CONSTANT_P (tem))
     259                 :       4077 :             return tem;
     260                 :            :         }
     261                 :            :     }
     262                 :            : 
     263                 :            :   return x;
     264                 :            : }
     265                 :            : 
     266                 :            : /* Simplify a MEM based on its attributes.  This is the default
     267                 :            :    delegitimize_address target hook, and it's recommended that every
     268                 :            :    overrider call it.  */
     269                 :            : 
     270                 :            : rtx
     271                 : 4835950000 : delegitimize_mem_from_attrs (rtx x)
     272                 :            : {
     273                 :            :   /* MEMs without MEM_OFFSETs may have been offset, so we can't just
     274                 :            :      use their base addresses as equivalent.  */
     275                 : 4835950000 :   if (MEM_P (x)
     276                 :   64209100 :       && MEM_EXPR (x)
     277                 : 4865030000 :       && MEM_OFFSET_KNOWN_P (x))
     278                 :            :     {
     279                 :   26890500 :       tree decl = MEM_EXPR (x);
     280                 :   26890500 :       machine_mode mode = GET_MODE (x);
     281                 :   26890500 :       poly_int64 offset = 0;
     282                 :            : 
     283                 :   26890500 :       switch (TREE_CODE (decl))
     284                 :            :         {
     285                 :            :         default:
     286                 :            :           decl = NULL;
     287                 :            :           break;
     288                 :            : 
     289                 :            :         case VAR_DECL:
     290                 :            :           break;
     291                 :            : 
     292                 :    7889810 :         case ARRAY_REF:
     293                 :    7889810 :         case ARRAY_RANGE_REF:
     294                 :    7889810 :         case COMPONENT_REF:
     295                 :    7889810 :         case BIT_FIELD_REF:
     296                 :    7889810 :         case REALPART_EXPR:
     297                 :    7889810 :         case IMAGPART_EXPR:
     298                 :    7889810 :         case VIEW_CONVERT_EXPR:
     299                 :    7889810 :           {
     300                 :    7889810 :             poly_int64 bitsize, bitpos, bytepos, toffset_val = 0;
     301                 :    7889810 :             tree toffset;
     302                 :    7889810 :             int unsignedp, reversep, volatilep = 0;
     303                 :            : 
     304                 :    7889810 :             decl
     305                 :    7889810 :               = get_inner_reference (decl, &bitsize, &bitpos, &toffset, &mode,
     306                 :            :                                      &unsignedp, &reversep, &volatilep);
     307                 :   15779600 :             if (maybe_ne (bitsize, GET_MODE_BITSIZE (mode))
     308                 :    7208820 :                 || !multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
     309                 :   15098600 :                 || (toffset && !poly_int_tree_p (toffset, &toffset_val)))
     310                 :            :               decl = NULL;
     311                 :            :             else
     312                 :    7125670 :               offset += bytepos + toffset_val;
     313                 :    7125670 :             break;
     314                 :            :           }
     315                 :            :         }
     316                 :            : 
     317                 :     764142 :       if (decl
     318                 :   16677500 :           && mode == GET_MODE (x)
     319                 :   16486000 :           && VAR_P (decl)
     320                 :   11246000 :           && (TREE_STATIC (decl)
     321                 :   21445600 :               || DECL_THREAD_LOCAL_P (decl))
     322                 :    1078390 :           && DECL_RTL_SET_P (decl)
     323                 :   17755500 :           && MEM_P (DECL_RTL (decl)))
     324                 :            :         {
     325                 :    1077980 :           rtx newx;
     326                 :            : 
     327                 :    1077980 :           offset += MEM_OFFSET (x);
     328                 :            : 
     329                 :    1077980 :           newx = DECL_RTL (decl);
     330                 :            : 
     331                 :    1077980 :           if (MEM_P (newx))
     332                 :            :             {
     333                 :    1077980 :               rtx n = XEXP (newx, 0), o = XEXP (x, 0);
     334                 :    1077980 :               poly_int64 n_offset, o_offset;
     335                 :            : 
     336                 :            :               /* Avoid creating a new MEM needlessly if we already had
     337                 :            :                  the same address.  We do if there's no OFFSET and the
     338                 :            :                  old address X is identical to NEWX, or if X is of the
     339                 :            :                  form (plus NEWX OFFSET), or the NEWX is of the form
     340                 :            :                  (plus Y (const_int Z)) and X is that with the offset
     341                 :            :                  added: (plus Y (const_int Z+OFFSET)).  */
     342                 :    1077980 :               n = strip_offset (n, &n_offset);
     343                 :    1077980 :               o = strip_offset (o, &o_offset);
     344                 :    2135610 :               if (!(known_eq (o_offset, n_offset + offset)
     345                 :    1057630 :                     && rtx_equal_p (o, n)))
     346                 :     191631 :                 x = adjust_address_nv (newx, mode, offset);
     347                 :            :             }
     348                 :            :           else if (GET_MODE (x) == GET_MODE (newx)
     349                 :            :                    && known_eq (offset, 0))
     350                 :            :             x = newx;
     351                 :            :         }
     352                 :            :     }
     353                 :            : 
     354                 : 4835950000 :   return x;
     355                 :            : }
     356                 :            : 
     357                 :            : /* Make a unary operation by first seeing if it folds and otherwise making
     358                 :            :    the specified operation.  */
     359                 :            : 
     360                 :            : rtx
     361                 :    2644210 : simplify_gen_unary (enum rtx_code code, machine_mode mode, rtx op,
     362                 :            :                     machine_mode op_mode)
     363                 :            : {
     364                 :    2644210 :   rtx tem;
     365                 :            : 
     366                 :            :   /* If this simplifies, use it.  */
     367                 :    2644210 :   if ((tem = simplify_unary_operation (code, mode, op, op_mode)) != 0)
     368                 :            :     return tem;
     369                 :            : 
     370                 :    1395230 :   return gen_rtx_fmt_e (code, mode, op);
     371                 :            : }
     372                 :            : 
     373                 :            : /* Likewise for ternary operations.  */
     374                 :            : 
     375                 :            : rtx
     376                 :    2371950 : simplify_gen_ternary (enum rtx_code code, machine_mode mode,
     377                 :            :                       machine_mode op0_mode, rtx op0, rtx op1, rtx op2)
     378                 :            : {
     379                 :    2371950 :   rtx tem;
     380                 :            : 
     381                 :            :   /* If this simplifies, use it.  */
     382                 :    2371950 :   if ((tem = simplify_ternary_operation (code, mode, op0_mode,
     383                 :            :                                          op0, op1, op2)) != 0)
     384                 :            :     return tem;
     385                 :            : 
     386                 :    2210090 :   return gen_rtx_fmt_eee (code, mode, op0, op1, op2);
     387                 :            : }
     388                 :            : 
     389                 :            : /* Likewise, for relational operations.
     390                 :            :    CMP_MODE specifies mode comparison is done in.  */
     391                 :            : 
     392                 :            : rtx
     393                 :    9320490 : simplify_gen_relational (enum rtx_code code, machine_mode mode,
     394                 :            :                          machine_mode cmp_mode, rtx op0, rtx op1)
     395                 :            : {
     396                 :    9320490 :   rtx tem;
     397                 :            : 
     398                 :    9320490 :   if ((tem = simplify_relational_operation (code, mode, cmp_mode,
     399                 :            :                                             op0, op1)) != 0)
     400                 :            :     return tem;
     401                 :            : 
     402                 :    8484660 :   return gen_rtx_fmt_ee (code, mode, op0, op1);
     403                 :            : }
     404                 :            : 
     405                 :            : /* If FN is NULL, replace all occurrences of OLD_RTX in X with copy_rtx (DATA)
     406                 :            :    and simplify the result.  If FN is non-NULL, call this callback on each
     407                 :            :    X, if it returns non-NULL, replace X with its return value and simplify the
     408                 :            :    result.  */
     409                 :            : 
     410                 :            : rtx
     411                 :  278902000 : simplify_replace_fn_rtx (rtx x, const_rtx old_rtx,
     412                 :            :                          rtx (*fn) (rtx, const_rtx, void *), void *data)
     413                 :            : {
     414                 :  278902000 :   enum rtx_code code = GET_CODE (x);
     415                 :  278902000 :   machine_mode mode = GET_MODE (x);
     416                 :  278902000 :   machine_mode op_mode;
     417                 :  278902000 :   const char *fmt;
     418                 :  278902000 :   rtx op0, op1, op2, newx, op;
     419                 :  278902000 :   rtvec vec, newvec;
     420                 :  278902000 :   int i, j;
     421                 :            : 
     422                 :  278902000 :   if (__builtin_expect (fn != NULL, 0))
     423                 :            :     {
     424                 :  252462000 :       newx = fn (x, old_rtx, data);
     425                 :  252462000 :       if (newx)
     426                 :            :         return newx;
     427                 :            :     }
     428                 :   26439800 :   else if (rtx_equal_p (x, old_rtx))
     429                 :    2607170 :     return copy_rtx ((rtx) data);
     430                 :            : 
     431                 :  211226000 :   switch (GET_RTX_CLASS (code))
     432                 :            :     {
     433                 :     758511 :     case RTX_UNARY:
     434                 :     758511 :       op0 = XEXP (x, 0);
     435                 :     758511 :       op_mode = GET_MODE (op0);
     436                 :     758511 :       op0 = simplify_replace_fn_rtx (op0, old_rtx, fn, data);
     437                 :     758511 :       if (op0 == XEXP (x, 0))
     438                 :            :         return x;
     439                 :     233314 :       return simplify_gen_unary (code, mode, op0, op_mode);
     440                 :            : 
     441                 :   41104800 :     case RTX_BIN_ARITH:
     442                 :   41104800 :     case RTX_COMM_ARITH:
     443                 :   41104800 :       op0 = simplify_replace_fn_rtx (XEXP (x, 0), old_rtx, fn, data);
     444                 :   41104800 :       op1 = simplify_replace_fn_rtx (XEXP (x, 1), old_rtx, fn, data);
     445                 :   41104800 :       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
     446                 :            :         return x;
     447                 :   13792500 :       return simplify_gen_binary (code, mode, op0, op1);
     448                 :            : 
     449                 :    4974600 :     case RTX_COMPARE:
     450                 :    4974600 :     case RTX_COMM_COMPARE:
     451                 :    4974600 :       op0 = XEXP (x, 0);
     452                 :    4974600 :       op1 = XEXP (x, 1);
     453                 :    4974600 :       op_mode = GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
     454                 :    4974600 :       op0 = simplify_replace_fn_rtx (op0, old_rtx, fn, data);
     455                 :    4974600 :       op1 = simplify_replace_fn_rtx (op1, old_rtx, fn, data);
     456                 :    4974600 :       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
     457                 :            :         return x;
     458                 :    1437420 :       return simplify_gen_relational (code, mode, op_mode, op0, op1);
     459                 :            : 
     460                 :    4095070 :     case RTX_TERNARY:
     461                 :    4095070 :     case RTX_BITFIELD_OPS:
     462                 :    4095070 :       op0 = XEXP (x, 0);
     463                 :    4095070 :       op_mode = GET_MODE (op0);
     464                 :    4095070 :       op0 = simplify_replace_fn_rtx (op0, old_rtx, fn, data);
     465                 :    4095070 :       op1 = simplify_replace_fn_rtx (XEXP (x, 1), old_rtx, fn, data);
     466                 :    4095070 :       op2 = simplify_replace_fn_rtx (XEXP (x, 2), old_rtx, fn, data);
     467                 :    4095070 :       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1) && op2 == XEXP (x, 2))
     468                 :            :         return x;
     469                 :    1589120 :       if (op_mode == VOIDmode)
     470                 :    1571320 :         op_mode = GET_MODE (op0);
     471                 :    1589120 :       return simplify_gen_ternary (code, mode, op_mode, op0, op1, op2);
     472                 :            : 
     473                 :   49349500 :     case RTX_EXTRA:
     474                 :   49349500 :       if (code == SUBREG)
     475                 :            :         {
     476                 :     251924 :           op0 = simplify_replace_fn_rtx (SUBREG_REG (x), old_rtx, fn, data);
     477                 :     251924 :           if (op0 == SUBREG_REG (x))
     478                 :            :             return x;
     479                 :      27564 :           op0 = simplify_gen_subreg (GET_MODE (x), op0,
     480                 :      13782 :                                      GET_MODE (SUBREG_REG (x)),
     481                 :      13782 :                                      SUBREG_BYTE (x));
     482                 :      13782 :           return op0 ? op0 : x;
     483                 :            :         }
     484                 :            :       break;
     485                 :            : 
     486                 :   32080100 :     case RTX_OBJ:
     487                 :   32080100 :       if (code == MEM)
     488                 :            :         {
     489                 :    5892700 :           op0 = simplify_replace_fn_rtx (XEXP (x, 0), old_rtx, fn, data);
     490                 :    5892700 :           if (op0 == XEXP (x, 0))
     491                 :            :             return x;
     492                 :     111678 :           return replace_equiv_address_nv (x, op0);
     493                 :            :         }
     494                 :   26187400 :       else if (code == LO_SUM)
     495                 :            :         {
     496                 :          0 :           op0 = simplify_replace_fn_rtx (XEXP (x, 0), old_rtx, fn, data);
     497                 :          0 :           op1 = simplify_replace_fn_rtx (XEXP (x, 1), old_rtx, fn, data);
     498                 :            : 
     499                 :            :           /* (lo_sum (high x) y) -> y where x and y have the same base.  */
     500                 :          0 :           if (GET_CODE (op0) == HIGH)
     501                 :            :             {
     502                 :          0 :               rtx base0, base1, offset0, offset1;
     503                 :          0 :               split_const (XEXP (op0, 0), &base0, &offset0);
     504                 :          0 :               split_const (op1, &base1, &offset1);
     505                 :          0 :               if (rtx_equal_p (base0, base1))
     506                 :          0 :                 return op1;
     507                 :            :             }
     508                 :            : 
     509                 :          0 :           if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
     510                 :            :             return x;
     511                 :          0 :           return gen_rtx_LO_SUM (mode, op0, op1);
     512                 :            :         }
     513                 :            :       break;
     514                 :            : 
     515                 :            :     default:
     516                 :            :       break;
     517                 :            :     }
     518                 :            : 
     519                 :  154149000 :   newx = x;
     520                 :  154149000 :   fmt = GET_RTX_FORMAT (code);
     521                 :  332091000 :   for (i = 0; fmt[i]; i++)
     522                 :  177943000 :     switch (fmt[i])
     523                 :            :       {
     524                 :    1703480 :       case 'E':
     525                 :    1703480 :         vec = XVEC (x, i);
     526                 :    1703480 :         newvec = XVEC (newx, i);
     527                 :    4600480 :         for (j = 0; j < GET_NUM_ELEM (vec); j++)
     528                 :            :           {
     529                 :    2896990 :             op = simplify_replace_fn_rtx (RTVEC_ELT (vec, j),
     530                 :            :                                           old_rtx, fn, data);
     531                 :    2896990 :             if (op != RTVEC_ELT (vec, j))
     532                 :            :               {
     533                 :     456237 :                 if (newvec == vec)
     534                 :            :                   {
     535                 :     451374 :                     newvec = shallow_copy_rtvec (vec);
     536                 :     451374 :                     if (x == newx)
     537                 :     451374 :                       newx = shallow_copy_rtx (x);
     538                 :     451374 :                     XVEC (newx, i) = newvec;
     539                 :            :                   }
     540                 :     456237 :                 RTVEC_ELT (newvec, j) = op;
     541                 :            :               }
     542                 :            :           }
     543                 :            :         break;
     544                 :            : 
     545                 :   44388000 :       case 'e':
     546                 :   44388000 :         if (XEXP (x, i))
     547                 :            :           {
     548                 :   44388000 :             op = simplify_replace_fn_rtx (XEXP (x, i), old_rtx, fn, data);
     549                 :   44388000 :             if (op != XEXP (x, i))
     550                 :            :               {
     551                 :    1654620 :                 if (x == newx)
     552                 :    1650850 :                   newx = shallow_copy_rtx (x);
     553                 :    1654620 :                 XEXP (newx, i) = op;
     554                 :            :               }
     555                 :            :           }
     556                 :            :         break;
     557                 :            :       }
     558                 :            :   return newx;
     559                 :            : }
     560                 :            : 
     561                 :            : /* Replace all occurrences of OLD_RTX in X with NEW_RTX and try to simplify the
     562                 :            :    resulting RTX.  Return a new RTX which is as simplified as possible.  */
     563                 :            : 
     564                 :            : rtx
     565                 :    5651710 : simplify_replace_rtx (rtx x, const_rtx old_rtx, rtx new_rtx)
     566                 :            : {
     567                 :    5651710 :   return simplify_replace_fn_rtx (x, old_rtx, 0, new_rtx);
     568                 :            : }
     569                 :            : 
     570                 :            : /* Try to simplify a MODE truncation of OP, which has OP_MODE.
     571                 :            :    Only handle cases where the truncated value is inherently an rvalue.
     572                 :            : 
     573                 :            :    RTL provides two ways of truncating a value:
     574                 :            : 
     575                 :            :    1. a lowpart subreg.  This form is only a truncation when both
     576                 :            :       the outer and inner modes (here MODE and OP_MODE respectively)
     577                 :            :       are scalar integers, and only then when the subreg is used as
     578                 :            :       an rvalue.
     579                 :            : 
     580                 :            :       It is only valid to form such truncating subregs if the
     581                 :            :       truncation requires no action by the target.  The onus for
     582                 :            :       proving this is on the creator of the subreg -- e.g. the
     583                 :            :       caller to simplify_subreg or simplify_gen_subreg -- and typically
     584                 :            :       involves either TRULY_NOOP_TRUNCATION_MODES_P or truncated_to_mode.
     585                 :            : 
     586                 :            :    2. a TRUNCATE.  This form handles both scalar and compound integers.
     587                 :            : 
     588                 :            :    The first form is preferred where valid.  However, the TRUNCATE
     589                 :            :    handling in simplify_unary_operation turns the second form into the
     590                 :            :    first form when TRULY_NOOP_TRUNCATION_MODES_P or truncated_to_mode allow,
     591                 :            :    so it is generally safe to form rvalue truncations using:
     592                 :            : 
     593                 :            :       simplify_gen_unary (TRUNCATE, ...)
     594                 :            : 
     595                 :            :    and leave simplify_unary_operation to work out which representation
     596                 :            :    should be used.
     597                 :            : 
     598                 :            :    Because of the proof requirements on (1), simplify_truncation must
     599                 :            :    also use simplify_gen_unary (TRUNCATE, ...) to truncate parts of OP,
     600                 :            :    regardless of whether the outer truncation came from a SUBREG or a
     601                 :            :    TRUNCATE.  For example, if the caller has proven that an SImode
     602                 :            :    truncation of:
     603                 :            : 
     604                 :            :       (and:DI X Y)
     605                 :            : 
     606                 :            :    is a no-op and can be represented as a subreg, it does not follow
     607                 :            :    that SImode truncations of X and Y are also no-ops.  On a target
     608                 :            :    like 64-bit MIPS that requires SImode values to be stored in
     609                 :            :    sign-extended form, an SImode truncation of:
     610                 :            : 
     611                 :            :       (and:DI (reg:DI X) (const_int 63))
     612                 :            : 
     613                 :            :    is trivially a no-op because only the lower 6 bits can be set.
     614                 :            :    However, X is still an arbitrary 64-bit number and so we cannot
     615                 :            :    assume that truncating it too is a no-op.  */
     616                 :            : 
     617                 :            : static rtx
     618                 :   11667600 : simplify_truncation (machine_mode mode, rtx op,
     619                 :            :                      machine_mode op_mode)
     620                 :            : {
     621                 :   11667600 :   unsigned int precision = GET_MODE_UNIT_PRECISION (mode);
     622                 :   11667600 :   unsigned int op_precision = GET_MODE_UNIT_PRECISION (op_mode);
     623                 :   11667600 :   scalar_int_mode int_mode, int_op_mode, subreg_mode;
     624                 :            : 
     625                 :   11667600 :   gcc_assert (precision <= op_precision);
     626                 :            : 
     627                 :            :   /* Optimize truncations of zero and sign extended values.  */
     628                 :   11667600 :   if (GET_CODE (op) == ZERO_EXTEND
     629                 :   11667600 :       || GET_CODE (op) == SIGN_EXTEND)
     630                 :            :     {
     631                 :            :       /* There are three possibilities.  If MODE is the same as the
     632                 :            :          origmode, we can omit both the extension and the subreg.
     633                 :            :          If MODE is not larger than the origmode, we can apply the
     634                 :            :          truncation without the extension.  Finally, if the outermode
     635                 :            :          is larger than the origmode, we can just extend to the appropriate
     636                 :            :          mode.  */
     637                 :     126393 :       machine_mode origmode = GET_MODE (XEXP (op, 0));
     638                 :     126393 :       if (mode == origmode)
     639                 :            :         return XEXP (op, 0);
     640                 :      36946 :       else if (precision <= GET_MODE_UNIT_PRECISION (origmode))
     641                 :       3639 :         return simplify_gen_unary (TRUNCATE, mode,
     642                 :       3639 :                                    XEXP (op, 0), origmode);
     643                 :            :       else
     644                 :      14834 :         return simplify_gen_unary (GET_CODE (op), mode,
     645                 :      14834 :                                    XEXP (op, 0), origmode);
     646                 :            :     }
     647                 :            : 
     648                 :            :   /* If the machine can perform operations in the truncated mode, distribute
     649                 :            :      the truncation, i.e. simplify (truncate:QI (op:SI (x:SI) (y:SI))) into
     650                 :            :      (op:QI (truncate:QI (x:SI)) (truncate:QI (y:SI))).  */
     651                 :   11541200 :   if (1
     652                 :            :       && (!WORD_REGISTER_OPERATIONS || precision >= BITS_PER_WORD)
     653                 :            :       && (GET_CODE (op) == PLUS
     654                 :   11541200 :           || GET_CODE (op) == MINUS
     655                 :   11227200 :           || GET_CODE (op) == MULT))
     656                 :            :     {
     657                 :     341514 :       rtx op0 = simplify_gen_unary (TRUNCATE, mode, XEXP (op, 0), op_mode);
     658                 :     341514 :       if (op0)
     659                 :            :         {
     660                 :     341514 :           rtx op1 = simplify_gen_unary (TRUNCATE, mode, XEXP (op, 1), op_mode);
     661                 :     341514 :           if (op1)
     662                 :     341514 :             return simplify_gen_binary (GET_CODE (op), mode, op0, op1);
     663                 :            :         }
     664                 :            :     }
     665                 :            : 
     666                 :            :   /* Simplify (truncate:QI (lshiftrt:SI (sign_extend:SI (x:QI)) C)) into
     667                 :            :      to (ashiftrt:QI (x:QI) C), where C is a suitable small constant and
     668                 :            :      the outer subreg is effectively a truncation to the original mode.  */
     669                 :   11199700 :   if ((GET_CODE (op) == LSHIFTRT
     670                 :   11199700 :        || GET_CODE (op) == ASHIFTRT)
     671                 :            :       /* Ensure that OP_MODE is at least twice as wide as MODE
     672                 :            :          to avoid the possibility that an outer LSHIFTRT shifts by more
     673                 :            :          than the sign extension's sign_bit_copies and introduces zeros
     674                 :            :          into the high bits of the result.  */
     675                 :    1149130 :       && 2 * precision <= op_precision
     676                 :    1149130 :       && CONST_INT_P (XEXP (op, 1))
     677                 :    1073350 :       && GET_CODE (XEXP (op, 0)) == SIGN_EXTEND
     678                 :         24 :       && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode
     679                 :         24 :       && UINTVAL (XEXP (op, 1)) < precision)
     680                 :          7 :     return simplify_gen_binary (ASHIFTRT, mode,
     681                 :          7 :                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
     682                 :            : 
     683                 :            :   /* Likewise (truncate:QI (lshiftrt:SI (zero_extend:SI (x:QI)) C)) into
     684                 :            :      to (lshiftrt:QI (x:QI) C), where C is a suitable small constant and
     685                 :            :      the outer subreg is effectively a truncation to the original mode.  */
     686                 :   11199700 :   if ((GET_CODE (op) == LSHIFTRT
     687                 :            :        || GET_CODE (op) == ASHIFTRT)
     688                 :    1149120 :       && CONST_INT_P (XEXP (op, 1))
     689                 :    1073340 :       && GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
     690                 :        273 :       && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode
     691                 :        265 :       && UINTVAL (XEXP (op, 1)) < precision)
     692                 :        265 :     return simplify_gen_binary (LSHIFTRT, mode,
     693                 :        265 :                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
     694                 :            : 
     695                 :            :   /* Likewise (truncate:QI (ashift:SI (zero_extend:SI (x:QI)) C)) into
     696                 :            :      to (ashift:QI (x:QI) C), where C is a suitable small constant and
     697                 :            :      the outer subreg is effectively a truncation to the original mode.  */
     698                 :   11199400 :   if (GET_CODE (op) == ASHIFT
     699                 :     381522 :       && CONST_INT_P (XEXP (op, 1))
     700                 :     337244 :       && (GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
     701                 :     337244 :           || GET_CODE (XEXP (op, 0)) == SIGN_EXTEND)
     702                 :        373 :       && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode
     703                 :        148 :       && UINTVAL (XEXP (op, 1)) < precision)
     704                 :        148 :     return simplify_gen_binary (ASHIFT, mode,
     705                 :        148 :                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
     706                 :            : 
     707                 :            :   /* Likewise (truncate:QI (and:SI (lshiftrt:SI (x:SI) C) C2)) into
     708                 :            :      (and:QI (lshiftrt:QI (truncate:QI (x:SI)) C) C2) for suitable C
     709                 :            :      and C2.  */
     710                 :   11199200 :   if (GET_CODE (op) == AND
     711                 :     430516 :       && (GET_CODE (XEXP (op, 0)) == LSHIFTRT
     712                 :     430516 :           || GET_CODE (XEXP (op, 0)) == ASHIFTRT)
     713                 :      39270 :       && CONST_INT_P (XEXP (XEXP (op, 0), 1))
     714                 :      38939 :       && CONST_INT_P (XEXP (op, 1)))
     715                 :            :     {
     716                 :      38843 :       rtx op0 = (XEXP (XEXP (op, 0), 0));
     717                 :      38843 :       rtx shift_op = XEXP (XEXP (op, 0), 1);
     718                 :      38843 :       rtx mask_op = XEXP (op, 1);
     719                 :      38843 :       unsigned HOST_WIDE_INT shift = UINTVAL (shift_op);
     720                 :      38843 :       unsigned HOST_WIDE_INT mask = UINTVAL (mask_op);
     721                 :            : 
     722                 :      38843 :       if (shift < precision
     723                 :            :           /* If doing this transform works for an X with all bits set,
     724                 :            :              it works for any X.  */
     725                 :       8392 :           && ((GET_MODE_MASK (mode) >> shift) & mask)
     726                 :       8392 :              == ((GET_MODE_MASK (op_mode) >> shift) & mask)
     727                 :       1451 :           && (op0 = simplify_gen_unary (TRUNCATE, mode, op0, op_mode))
     728                 :      40294 :           && (op0 = simplify_gen_binary (LSHIFTRT, mode, op0, shift_op)))
     729                 :            :         {
     730                 :       1451 :           mask_op = GEN_INT (trunc_int_for_mode (mask, mode));
     731                 :       1451 :           return simplify_gen_binary (AND, mode, op0, mask_op);
     732                 :            :         }
     733                 :            :     }
     734                 :            : 
     735                 :            :   /* Turn (truncate:M1 (*_extract:M2 (reg:M2) (len) (pos))) into
     736                 :            :      (*_extract:M1 (truncate:M1 (reg:M2)) (len) (pos')) if possible without
     737                 :            :      changing len.  */
     738                 :   11197800 :   if ((GET_CODE (op) == ZERO_EXTRACT || GET_CODE (op) == SIGN_EXTRACT)
     739                 :     225886 :       && REG_P (XEXP (op, 0))
     740                 :     167271 :       && GET_MODE (XEXP (op, 0)) == GET_MODE (op)
     741                 :     165585 :       && CONST_INT_P (XEXP (op, 1))
     742                 :     165585 :       && CONST_INT_P (XEXP (op, 2)))
     743                 :            :     {
     744                 :     163594 :       rtx op0 = XEXP (op, 0);
     745                 :     163594 :       unsigned HOST_WIDE_INT len = UINTVAL (XEXP (op, 1));
     746                 :     163594 :       unsigned HOST_WIDE_INT pos = UINTVAL (XEXP (op, 2));
     747                 :     163594 :       if (BITS_BIG_ENDIAN && pos >= op_precision - precision)
     748                 :            :         {
     749                 :            :           op0 = simplify_gen_unary (TRUNCATE, mode, op0, GET_MODE (op0));
     750                 :            :           if (op0)
     751                 :            :             {
     752                 :            :               pos -= op_precision - precision;
     753                 :            :               return simplify_gen_ternary (GET_CODE (op), mode, mode, op0,
     754                 :            :                                            XEXP (op, 1), GEN_INT (pos));
     755                 :            :             }
     756                 :            :         }
     757                 :     163594 :       else if (!BITS_BIG_ENDIAN && precision >= len + pos)
     758                 :            :         {
     759                 :       3566 :           op0 = simplify_gen_unary (TRUNCATE, mode, op0, GET_MODE (op0));
     760                 :       3566 :           if (op0)
     761                 :       3566 :             return simplify_gen_ternary (GET_CODE (op), mode, mode, op0,
     762                 :       3566 :                                          XEXP (op, 1), XEXP (op, 2));
     763                 :            :         }
     764                 :            :     }
     765                 :            : 
     766                 :            :   /* Recognize a word extraction from a multi-word subreg.  */
     767                 :   11194200 :   if ((GET_CODE (op) == LSHIFTRT
     768                 :   11194200 :        || GET_CODE (op) == ASHIFTRT)
     769                 :    1148860 :       && SCALAR_INT_MODE_P (mode)
     770                 :    1146400 :       && SCALAR_INT_MODE_P (op_mode)
     771                 :    1248770 :       && precision >= BITS_PER_WORD
     772                 :     130433 :       && 2 * precision <= op_precision
     773                 :     130433 :       && CONST_INT_P (XEXP (op, 1))
     774                 :     126793 :       && (INTVAL (XEXP (op, 1)) & (precision - 1)) == 0
     775                 :      39945 :       && UINTVAL (XEXP (op, 1)) < op_precision)
     776                 :            :     {
     777                 :      39945 :       poly_int64 byte = subreg_lowpart_offset (mode, op_mode);
     778                 :      39945 :       int shifted_bytes = INTVAL (XEXP (op, 1)) / BITS_PER_UNIT;
     779                 :      39945 :       return simplify_gen_subreg (mode, XEXP (op, 0), op_mode,
     780                 :            :                                   (WORDS_BIG_ENDIAN
     781                 :            :                                    ? byte - shifted_bytes
     782                 :      39945 :                                    : byte + shifted_bytes));
     783                 :            :     }
     784                 :            : 
     785                 :            :   /* If we have a TRUNCATE of a right shift of MEM, make a new MEM
     786                 :            :      and try replacing the TRUNCATE and shift with it.  Don't do this
     787                 :            :      if the MEM has a mode-dependent address.  */
     788                 :   11154300 :   if ((GET_CODE (op) == LSHIFTRT
     789                 :            :        || GET_CODE (op) == ASHIFTRT)
     790                 :    1106460 :       && is_a <scalar_int_mode> (mode, &int_mode)
     791                 :   12259900 :       && is_a <scalar_int_mode> (op_mode, &int_op_mode)
     792                 :    1106460 :       && MEM_P (XEXP (op, 0))
     793                 :       4829 :       && CONST_INT_P (XEXP (op, 1))
     794                 :       9078 :       && INTVAL (XEXP (op, 1)) % GET_MODE_BITSIZE (int_mode) == 0
     795                 :        907 :       && INTVAL (XEXP (op, 1)) > 0
     796                 :       1814 :       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (int_op_mode)
     797                 :        892 :       && ! mode_dependent_address_p (XEXP (XEXP (op, 0), 0),
     798                 :        892 :                                      MEM_ADDR_SPACE (XEXP (op, 0)))
     799                 :        892 :       && ! MEM_VOLATILE_P (XEXP (op, 0))
     800                 :   11154300 :       && (GET_MODE_SIZE (int_mode) >= UNITS_PER_WORD
     801                 :            :           || WORDS_BIG_ENDIAN == BYTES_BIG_ENDIAN))
     802                 :            :     {
     803                 :        850 :       poly_int64 byte = subreg_lowpart_offset (int_mode, int_op_mode);
     804                 :        850 :       int shifted_bytes = INTVAL (XEXP (op, 1)) / BITS_PER_UNIT;
     805                 :        850 :       return adjust_address_nv (XEXP (op, 0), int_mode,
     806                 :            :                                 (WORDS_BIG_ENDIAN
     807                 :            :                                  ? byte - shifted_bytes
     808                 :            :                                  : byte + shifted_bytes));
     809                 :            :     }
     810                 :            : 
     811                 :            :   /* (truncate:SI (OP:DI ({sign,zero}_extend:DI foo:SI))) is
     812                 :            :      (OP:SI foo:SI) if OP is NEG or ABS.  */
     813                 :   11153400 :   if ((GET_CODE (op) == ABS
     814                 :   11153400 :        || GET_CODE (op) == NEG)
     815                 :       9120 :       && (GET_CODE (XEXP (op, 0)) == SIGN_EXTEND
     816                 :       9120 :           || GET_CODE (XEXP (op, 0)) == ZERO_EXTEND)
     817                 :         88 :       && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode)
     818                 :         88 :     return simplify_gen_unary (GET_CODE (op), mode,
     819                 :         88 :                                XEXP (XEXP (op, 0), 0), mode);
     820                 :            : 
     821                 :            :   /* (truncate:A (subreg:B (truncate:C X) 0)) is
     822                 :            :      (truncate:A X).  */
     823                 :   11153300 :   if (GET_CODE (op) == SUBREG
     824                 :   11178900 :       && is_a <scalar_int_mode> (mode, &int_mode)
     825                 :      25506 :       && SCALAR_INT_MODE_P (op_mode)
     826                 :      25506 :       && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (op)), &subreg_mode)
     827                 :      25494 :       && GET_CODE (SUBREG_REG (op)) == TRUNCATE
     828                 :   11153300 :       && subreg_lowpart_p (op))
     829                 :            :     {
     830                 :          0 :       rtx inner = XEXP (SUBREG_REG (op), 0);
     831                 :          0 :       if (GET_MODE_PRECISION (int_mode) <= GET_MODE_PRECISION (subreg_mode))
     832                 :          0 :         return simplify_gen_unary (TRUNCATE, int_mode, inner,
     833                 :          0 :                                    GET_MODE (inner));
     834                 :            :       else
     835                 :            :         /* If subreg above is paradoxical and C is narrower
     836                 :            :            than A, return (subreg:A (truncate:C X) 0).  */
     837                 :          0 :         return simplify_gen_subreg (int_mode, SUBREG_REG (op), subreg_mode, 0);
     838                 :            :     }
     839                 :            : 
     840                 :            :   /* (truncate:A (truncate:B X)) is (truncate:A X).  */
     841                 :   11153300 :   if (GET_CODE (op) == TRUNCATE)
     842                 :        901 :     return simplify_gen_unary (TRUNCATE, mode, XEXP (op, 0),
     843                 :        901 :                                GET_MODE (XEXP (op, 0)));
     844                 :            : 
     845                 :            :   /* (truncate:A (ior X C)) is (const_int -1) if C is equal to that already,
     846                 :            :      in mode A.  */
     847                 :   11152400 :   if (GET_CODE (op) == IOR
     848                 :      28737 :       && SCALAR_INT_MODE_P (mode)
     849                 :      28737 :       && SCALAR_INT_MODE_P (op_mode)
     850                 :      28737 :       && CONST_INT_P (XEXP (op, 1))
     851                 :   11164000 :       && trunc_int_for_mode (INTVAL (XEXP (op, 1)), mode) == -1)
     852                 :         22 :     return constm1_rtx;
     853                 :            : 
     854                 :            :   return NULL_RTX;
     855                 :            : }
     856                 :            : 
     857                 :            : /* Try to simplify a unary operation CODE whose output mode is to be
     858                 :            :    MODE with input operand OP whose mode was originally OP_MODE.
     859                 :            :    Return zero if no simplification can be made.  */
     860                 :            : rtx
     861                 :   11858300 : simplify_unary_operation (enum rtx_code code, machine_mode mode,
     862                 :            :                           rtx op, machine_mode op_mode)
     863                 :            : {
     864                 :   11858300 :   rtx trueop, tem;
     865                 :            : 
     866                 :   11858300 :   trueop = avoid_constant_pool_reference (op);
     867                 :            : 
     868                 :   11858300 :   tem = simplify_const_unary_operation (code, mode, trueop, op_mode);
     869                 :   11858300 :   if (tem)
     870                 :            :     return tem;
     871                 :            : 
     872                 :    9942770 :   return simplify_unary_operation_1 (code, mode, op);
     873                 :            : }
     874                 :            : 
     875                 :            : /* Return true if FLOAT or UNSIGNED_FLOAT operation OP is known
     876                 :            :    to be exact.  */
     877                 :            : 
     878                 :            : static bool
     879                 :       2378 : exact_int_to_float_conversion_p (const_rtx op)
     880                 :            : {
     881                 :       4756 :   int out_bits = significand_size (GET_MODE_INNER (GET_MODE (op)));
     882                 :       2378 :   machine_mode op0_mode = GET_MODE (XEXP (op, 0));
     883                 :            :   /* Constants shouldn't reach here.  */
     884                 :       2378 :   gcc_assert (op0_mode != VOIDmode);
     885                 :       2378 :   int in_prec = GET_MODE_UNIT_PRECISION (op0_mode);
     886                 :       2378 :   int in_bits = in_prec;
     887                 :       2378 :   if (HWI_COMPUTABLE_MODE_P (op0_mode))
     888                 :            :     {
     889                 :       2351 :       unsigned HOST_WIDE_INT nonzero = nonzero_bits (XEXP (op, 0), op0_mode);
     890                 :       2351 :       if (GET_CODE (op) == FLOAT)
     891                 :       2299 :         in_bits -= num_sign_bit_copies (XEXP (op, 0), op0_mode);
     892                 :         52 :       else if (GET_CODE (op) == UNSIGNED_FLOAT)
     893                 :         98 :         in_bits = wi::min_precision (wi::uhwi (nonzero, in_prec), UNSIGNED);
     894                 :            :       else
     895                 :          0 :         gcc_unreachable ();
     896                 :       3034 :       in_bits -= wi::ctz (wi::uhwi (nonzero, in_prec));
     897                 :            :     }
     898                 :       2378 :   return in_bits <= out_bits;
     899                 :            : }
     900                 :            : 
     901                 :            : /* Perform some simplifications we can do even if the operands
     902                 :            :    aren't constant.  */
     903                 :            : static rtx
     904                 :    9942770 : simplify_unary_operation_1 (enum rtx_code code, machine_mode mode, rtx op)
     905                 :            : {
     906                 :    9942770 :   enum rtx_code reversed;
     907                 :    9942770 :   rtx temp, elt, base, step;
     908                 :    9942770 :   scalar_int_mode inner, int_mode, op_mode, op0_mode;
     909                 :            : 
     910                 :    9942770 :   switch (code)
     911                 :            :     {
     912                 :     691197 :     case NOT:
     913                 :            :       /* (not (not X)) == X.  */
     914                 :     691197 :       if (GET_CODE (op) == NOT)
     915                 :       1216 :         return XEXP (op, 0);
     916                 :            : 
     917                 :            :       /* (not (eq X Y)) == (ne X Y), etc. if BImode or the result of the
     918                 :            :          comparison is all ones.   */
     919                 :     689981 :       if (COMPARISON_P (op)
     920                 :       9015 :           && (mode == BImode || STORE_FLAG_VALUE == -1)
     921                 :     689981 :           && ((reversed = reversed_comparison_code (op, NULL)) != UNKNOWN))
     922                 :          0 :         return simplify_gen_relational (reversed, mode, VOIDmode,
     923                 :          0 :                                         XEXP (op, 0), XEXP (op, 1));
     924                 :            : 
     925                 :            :       /* (not (plus X -1)) can become (neg X).  */
     926                 :     689981 :       if (GET_CODE (op) == PLUS
     927                 :      22492 :           && XEXP (op, 1) == constm1_rtx)
     928                 :       3678 :         return simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
     929                 :            : 
     930                 :            :       /* Similarly, (not (neg X)) is (plus X -1).  Only do this for
     931                 :            :          modes that have CONSTM1_RTX, i.e. MODE_INT, MODE_PARTIAL_INT
     932                 :            :          and MODE_VECTOR_INT.  */
     933                 :     686303 :       if (GET_CODE (op) == NEG && CONSTM1_RTX (mode))
     934                 :       9591 :         return simplify_gen_binary (PLUS, mode, XEXP (op, 0),
     935                 :       9591 :                                     CONSTM1_RTX (mode));
     936                 :            : 
     937                 :            :       /* (not (xor X C)) for C constant is (xor X D) with D = ~C.  */
     938                 :     676712 :       if (GET_CODE (op) == XOR
     939                 :       3510 :           && CONST_INT_P (XEXP (op, 1))
     940                 :     677974 :           && (temp = simplify_unary_operation (NOT, mode,
     941                 :            :                                                XEXP (op, 1), mode)) != 0)
     942                 :       1262 :         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
     943                 :            : 
     944                 :            :       /* (not (plus X C)) for signbit C is (xor X D) with D = ~C.  */
     945                 :     675450 :       if (GET_CODE (op) == PLUS
     946                 :      18814 :           && CONST_INT_P (XEXP (op, 1))
     947                 :      12388 :           && mode_signbit_p (mode, XEXP (op, 1))
     948                 :     677445 :           && (temp = simplify_unary_operation (NOT, mode,
     949                 :            :                                                XEXP (op, 1), mode)) != 0)
     950                 :       1995 :         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
     951                 :            : 
     952                 :            : 
     953                 :            :       /* (not (ashift 1 X)) is (rotate ~1 X).  We used to do this for
     954                 :            :          operands other than 1, but that is not valid.  We could do a
     955                 :            :          similar simplification for (not (lshiftrt C X)) where C is
     956                 :            :          just the sign bit, but this doesn't seem common enough to
     957                 :            :          bother with.  */
     958                 :     673455 :       if (GET_CODE (op) == ASHIFT
     959                 :      16976 :           && XEXP (op, 0) == const1_rtx)
     960                 :            :         {
     961                 :        719 :           temp = simplify_gen_unary (NOT, mode, const1_rtx, mode);
     962                 :        719 :           return simplify_gen_binary (ROTATE, mode, temp, XEXP (op, 1));
     963                 :            :         }
     964                 :            : 
     965                 :            :       /* (not (ashiftrt foo C)) where C is the number of bits in FOO
     966                 :            :          minus 1 is (ge foo (const_int 0)) if STORE_FLAG_VALUE is -1,
     967                 :            :          so we can perform the above simplification.  */
     968                 :     672736 :       if (STORE_FLAG_VALUE == -1
     969                 :            :           && is_a <scalar_int_mode> (mode, &int_mode)
     970                 :            :           && GET_CODE (op) == ASHIFTRT
     971                 :            :           && CONST_INT_P (XEXP (op, 1))
     972                 :            :           && INTVAL (XEXP (op, 1)) == GET_MODE_PRECISION (int_mode) - 1)
     973                 :            :         return simplify_gen_relational (GE, int_mode, VOIDmode,
     974                 :            :                                         XEXP (op, 0), const0_rtx);
     975                 :            : 
     976                 :            : 
     977                 :     672736 :       if (partial_subreg_p (op)
     978                 :      62743 :           && subreg_lowpart_p (op)
     979                 :      55528 :           && GET_CODE (SUBREG_REG (op)) == ASHIFT
     980                 :      70128 :           && XEXP (SUBREG_REG (op), 0) == const1_rtx)
     981                 :            :         {
     982                 :         33 :           machine_mode inner_mode = GET_MODE (SUBREG_REG (op));
     983                 :         33 :           rtx x;
     984                 :            : 
     985                 :         33 :           x = gen_rtx_ROTATE (inner_mode,
     986                 :            :                               simplify_gen_unary (NOT, inner_mode, const1_rtx,
     987                 :            :                                                   inner_mode),
     988                 :            :                               XEXP (SUBREG_REG (op), 1));
     989                 :         33 :           temp = rtl_hooks.gen_lowpart_no_emit (mode, x);
     990                 :         33 :           if (temp)
     991                 :            :             return temp;
     992                 :            :         }
     993                 :            : 
     994                 :            :       /* Apply De Morgan's laws to reduce number of patterns for machines
     995                 :            :          with negating logical insns (and-not, nand, etc.).  If result has
     996                 :            :          only one NOT, put it first, since that is how the patterns are
     997                 :            :          coded.  */
     998                 :     672703 :       if (GET_CODE (op) == IOR || GET_CODE (op) == AND)
     999                 :            :         {
    1000                 :       6503 :           rtx in1 = XEXP (op, 0), in2 = XEXP (op, 1);
    1001                 :       6503 :           machine_mode op_mode;
    1002                 :            : 
    1003                 :       6503 :           op_mode = GET_MODE (in1);
    1004                 :       6503 :           in1 = simplify_gen_unary (NOT, op_mode, in1, op_mode);
    1005                 :            : 
    1006                 :       6503 :           op_mode = GET_MODE (in2);
    1007                 :       6503 :           if (op_mode == VOIDmode)
    1008                 :       2772 :             op_mode = mode;
    1009                 :       6503 :           in2 = simplify_gen_unary (NOT, op_mode, in2, op_mode);
    1010                 :            : 
    1011                 :       6503 :           if (GET_CODE (in2) == NOT && GET_CODE (in1) != NOT)
    1012                 :          3 :             std::swap (in1, in2);
    1013                 :            : 
    1014                 :      13006 :           return gen_rtx_fmt_ee (GET_CODE (op) == IOR ? AND : IOR,
    1015                 :            :                                  mode, in1, in2);
    1016                 :            :         }
    1017                 :            : 
    1018                 :            :       /* (not (bswap x)) -> (bswap (not x)).  */
    1019                 :     666200 :       if (GET_CODE (op) == BSWAP)
    1020                 :            :         {
    1021                 :          0 :           rtx x = simplify_gen_unary (NOT, mode, XEXP (op, 0), mode);
    1022                 :          0 :           return simplify_gen_unary (BSWAP, mode, x, mode);
    1023                 :            :         }
    1024                 :            :       break;
    1025                 :            : 
    1026                 :     919593 :     case NEG:
    1027                 :            :       /* (neg (neg X)) == X.  */
    1028                 :     919593 :       if (GET_CODE (op) == NEG)
    1029                 :        858 :         return XEXP (op, 0);
    1030                 :            : 
    1031                 :            :       /* (neg (x ? (neg y) : y)) == !x ? (neg y) : y.
    1032                 :            :          If comparison is not reversible use
    1033                 :            :          x ? y : (neg y).  */
    1034                 :     918735 :       if (GET_CODE (op) == IF_THEN_ELSE)
    1035                 :            :         {
    1036                 :       1504 :           rtx cond = XEXP (op, 0);
    1037                 :       1504 :           rtx true_rtx = XEXP (op, 1);
    1038                 :       1504 :           rtx false_rtx = XEXP (op, 2);
    1039                 :            : 
    1040                 :       1504 :           if ((GET_CODE (true_rtx) == NEG
    1041                 :          0 :                && rtx_equal_p (XEXP (true_rtx, 0), false_rtx))
    1042                 :       1504 :                || (GET_CODE (false_rtx) == NEG
    1043                 :          0 :                    && rtx_equal_p (XEXP (false_rtx, 0), true_rtx)))
    1044                 :            :             {
    1045                 :          0 :               if (reversed_comparison_code (cond, NULL) != UNKNOWN)
    1046                 :          0 :                 temp = reversed_comparison (cond, mode);
    1047                 :            :               else
    1048                 :            :                 {
    1049                 :            :                   temp = cond;
    1050                 :          0 :                   std::swap (true_rtx, false_rtx);
    1051                 :            :                 }
    1052                 :          0 :               return simplify_gen_ternary (IF_THEN_ELSE, mode,
    1053                 :          0 :                                             mode, temp, true_rtx, false_rtx);
    1054                 :            :             }
    1055                 :            :         }
    1056                 :            : 
    1057                 :            :       /* (neg (plus X 1)) can become (not X).  */
    1058                 :     918735 :       if (GET_CODE (op) == PLUS
    1059                 :      19877 :           && XEXP (op, 1) == const1_rtx)
    1060                 :      13219 :         return simplify_gen_unary (NOT, mode, XEXP (op, 0), mode);
    1061                 :            : 
    1062                 :            :       /* Similarly, (neg (not X)) is (plus X 1).  */
    1063                 :     905516 :       if (GET_CODE (op) == NOT)
    1064                 :        271 :         return simplify_gen_binary (PLUS, mode, XEXP (op, 0),
    1065                 :        271 :                                     CONST1_RTX (mode));
    1066                 :            : 
    1067                 :            :       /* (neg (minus X Y)) can become (minus Y X).  This transformation
    1068                 :            :          isn't safe for modes with signed zeros, since if X and Y are
    1069                 :            :          both +0, (minus Y X) is the same as (minus X Y).  If the
    1070                 :            :          rounding mode is towards +infinity (or -infinity) then the two
    1071                 :            :          expressions will be rounded differently.  */
    1072                 :     905245 :       if (GET_CODE (op) == MINUS
    1073                 :       5422 :           && !HONOR_SIGNED_ZEROS (mode)
    1074                 :     909253 :           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
    1075                 :       4008 :         return simplify_gen_binary (MINUS, mode, XEXP (op, 1), XEXP (op, 0));
    1076                 :            : 
    1077                 :     901237 :       if (GET_CODE (op) == PLUS
    1078                 :       6658 :           && !HONOR_SIGNED_ZEROS (mode)
    1079                 :     907380 :           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
    1080                 :            :         {
    1081                 :            :           /* (neg (plus A C)) is simplified to (minus -C A).  */
    1082                 :       6143 :           if (CONST_SCALAR_INT_P (XEXP (op, 1))
    1083                 :       2438 :               || CONST_DOUBLE_AS_FLOAT_P (XEXP (op, 1)))
    1084                 :            :             {
    1085                 :       3706 :               temp = simplify_unary_operation (NEG, mode, XEXP (op, 1), mode);
    1086                 :       3706 :               if (temp)
    1087                 :       3706 :                 return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 0));
    1088                 :            :             }
    1089                 :            : 
    1090                 :            :           /* (neg (plus A B)) is canonicalized to (minus (neg A) B).  */
    1091                 :       2437 :           temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
    1092                 :       2437 :           return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 1));
    1093                 :            :         }
    1094                 :            : 
    1095                 :            :       /* (neg (mult A B)) becomes (mult A (neg B)).
    1096                 :            :          This works even for floating-point values.  */
    1097                 :     895094 :       if (GET_CODE (op) == MULT
    1098                 :     895094 :           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
    1099                 :            :         {
    1100                 :      15433 :           temp = simplify_gen_unary (NEG, mode, XEXP (op, 1), mode);
    1101                 :      15433 :           return simplify_gen_binary (MULT, mode, XEXP (op, 0), temp);
    1102                 :            :         }
    1103                 :            : 
    1104                 :            :       /* NEG commutes with ASHIFT since it is multiplication.  Only do
    1105                 :            :          this if we can then eliminate the NEG (e.g., if the operand
    1106                 :            :          is a constant).  */
    1107                 :     879661 :       if (GET_CODE (op) == ASHIFT)
    1108                 :            :         {
    1109                 :      47120 :           temp = simplify_unary_operation (NEG, mode, XEXP (op, 0), mode);
    1110                 :      47120 :           if (temp)
    1111                 :       7838 :             return simplify_gen_binary (ASHIFT, mode, temp, XEXP (op, 1));
    1112                 :            :         }
    1113                 :            : 
    1114                 :            :       /* (neg (ashiftrt X C)) can be replaced by (lshiftrt X C) when
    1115                 :            :          C is equal to the width of MODE minus 1.  */
    1116                 :     871823 :       if (GET_CODE (op) == ASHIFTRT
    1117                 :      11453 :           && CONST_INT_P (XEXP (op, 1))
    1118                 :     894665 :           && INTVAL (XEXP (op, 1)) == GET_MODE_UNIT_PRECISION (mode) - 1)
    1119                 :         33 :         return simplify_gen_binary (LSHIFTRT, mode,
    1120                 :         33 :                                     XEXP (op, 0), XEXP (op, 1));
    1121                 :            : 
    1122                 :            :       /* (neg (lshiftrt X C)) can be replaced by (ashiftrt X C) when
    1123                 :            :          C is equal to the width of MODE minus 1.  */
    1124                 :     871790 :       if (GET_CODE (op) == LSHIFTRT
    1125                 :       3852 :           && CONST_INT_P (XEXP (op, 1))
    1126                 :     879382 :           && INTVAL (XEXP (op, 1)) == GET_MODE_UNIT_PRECISION (mode) - 1)
    1127                 :        393 :         return simplify_gen_binary (ASHIFTRT, mode,
    1128                 :        393 :                                     XEXP (op, 0), XEXP (op, 1));
    1129                 :            : 
    1130                 :            :       /* (neg (xor A 1)) is (plus A -1) if A is known to be either 0 or 1.  */
    1131                 :     871397 :       if (GET_CODE (op) == XOR
    1132                 :        735 :           && XEXP (op, 1) == const1_rtx
    1133                 :     871418 :           && nonzero_bits (XEXP (op, 0), mode) == 1)
    1134                 :         16 :         return plus_constant (mode, XEXP (op, 0), -1);
    1135                 :            : 
    1136                 :            :       /* (neg (lt x 0)) is (ashiftrt X C) if STORE_FLAG_VALUE is 1.  */
    1137                 :            :       /* (neg (lt x 0)) is (lshiftrt X C) if STORE_FLAG_VALUE is -1.  */
    1138                 :     871381 :       if (GET_CODE (op) == LT
    1139                 :       1336 :           && XEXP (op, 1) == const0_rtx
    1140                 :     872297 :           && is_a <scalar_int_mode> (GET_MODE (XEXP (op, 0)), &inner))
    1141                 :            :         {
    1142                 :        116 :           int_mode = as_a <scalar_int_mode> (mode);
    1143                 :        116 :           int isize = GET_MODE_PRECISION (inner);
    1144                 :        116 :           if (STORE_FLAG_VALUE == 1)
    1145                 :            :             {
    1146                 :        116 :               temp = simplify_gen_binary (ASHIFTRT, inner, XEXP (op, 0),
    1147                 :            :                                           gen_int_shift_amount (inner,
    1148                 :        116 :                                                                 isize - 1));
    1149                 :        116 :               if (int_mode == inner)
    1150                 :            :                 return temp;
    1151                 :        113 :               if (GET_MODE_PRECISION (int_mode) > isize)
    1152                 :         60 :                 return simplify_gen_unary (SIGN_EXTEND, int_mode, temp, inner);
    1153                 :         53 :               return simplify_gen_unary (TRUNCATE, int_mode, temp, inner);
    1154                 :            :             }
    1155                 :            :           else if (STORE_FLAG_VALUE == -1)
    1156                 :            :             {
    1157                 :            :               temp = simplify_gen_binary (LSHIFTRT, inner, XEXP (op, 0),
    1158                 :            :                                           gen_int_shift_amount (inner,
    1159                 :            :                                                                 isize - 1));
    1160                 :            :               if (int_mode == inner)
    1161                 :            :                 return temp;
    1162                 :            :               if (GET_MODE_PRECISION (int_mode) > isize)
    1163                 :            :                 return simplify_gen_unary (ZERO_EXTEND, int_mode, temp, inner);
    1164                 :            :               return simplify_gen_unary (TRUNCATE, int_mode, temp, inner);
    1165                 :            :             }
    1166                 :            :         }
    1167                 :            : 
    1168                 :    1742390 :       if (vec_series_p (op, &base, &step))
    1169                 :            :         {
    1170                 :            :           /* Only create a new series if we can simplify both parts.  In other
    1171                 :            :              cases this isn't really a simplification, and it's not necessarily
    1172                 :            :              a win to replace a vector operation with a scalar operation.  */
    1173                 :        144 :           scalar_mode inner_mode = GET_MODE_INNER (mode);
    1174                 :        144 :           base = simplify_unary_operation (NEG, inner_mode, base, inner_mode);
    1175                 :        144 :           if (base)
    1176                 :            :             {
    1177                 :        144 :               step = simplify_unary_operation (NEG, inner_mode,
    1178                 :            :                                                step, inner_mode);
    1179                 :        144 :               if (step)
    1180                 :        144 :                 return gen_vec_series (mode, base, step);
    1181                 :            :             }
    1182                 :            :         }
    1183                 :            :       break;
    1184                 :            : 
    1185                 :     858610 :     case TRUNCATE:
    1186                 :            :       /* Don't optimize (lshiftrt (mult ...)) as it would interfere
    1187                 :            :          with the umulXi3_highpart patterns.  */
    1188                 :     858610 :       if (GET_CODE (op) == LSHIFTRT
    1189                 :     267411 :           && GET_CODE (XEXP (op, 0)) == MULT)
    1190                 :            :         break;
    1191                 :            : 
    1192                 :     598791 :       if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
    1193                 :            :         {
    1194                 :          0 :           if (TRULY_NOOP_TRUNCATION_MODES_P (mode, GET_MODE (op)))
    1195                 :            :             {
    1196                 :          0 :               temp = rtl_hooks.gen_lowpart_no_emit (mode, op);
    1197                 :          0 :               if (temp)
    1198                 :            :                 return temp;
    1199                 :            :             }
    1200                 :            :           /* We can't handle truncation to a partial integer mode here
    1201                 :            :              because we don't know the real bitsize of the partial
    1202                 :            :              integer mode.  */
    1203                 :            :           break;
    1204                 :            :         }
    1205                 :            : 
    1206                 :     598791 :       if (GET_MODE (op) != VOIDmode)
    1207                 :            :         {
    1208                 :     598791 :           temp = simplify_truncation (mode, op, GET_MODE (op));
    1209                 :     598791 :           if (temp)
    1210                 :            :             return temp;
    1211                 :            :         }
    1212                 :            : 
    1213                 :            :       /* If we know that the value is already truncated, we can
    1214                 :            :          replace the TRUNCATE with a SUBREG.  */
    1215                 :    1165460 :       if (known_eq (GET_MODE_NUNITS (mode), 1)
    1216                 :     582728 :           && (TRULY_NOOP_TRUNCATION_MODES_P (mode, GET_MODE (op))
    1217                 :          0 :               || truncated_to_mode (mode, op)))
    1218                 :            :         {
    1219                 :     576445 :           temp = rtl_hooks.gen_lowpart_no_emit (mode, op);
    1220                 :     576445 :           if (temp)
    1221                 :            :             return temp;
    1222                 :            :         }
    1223                 :            : 
    1224                 :            :       /* A truncate of a comparison can be replaced with a subreg if
    1225                 :            :          STORE_FLAG_VALUE permits.  This is like the previous test,
    1226                 :            :          but it works even if the comparison is done in a mode larger
    1227                 :            :          than HOST_BITS_PER_WIDE_INT.  */
    1228                 :       6420 :       if (HWI_COMPUTABLE_MODE_P (mode)
    1229                 :        137 :           && COMPARISON_P (op)
    1230                 :          0 :           && (STORE_FLAG_VALUE & ~GET_MODE_MASK (mode)) == 0)
    1231                 :            :         {
    1232                 :          0 :           temp = rtl_hooks.gen_lowpart_no_emit (mode, op);
    1233                 :          0 :           if (temp)
    1234                 :            :             return temp;
    1235                 :            :         }
    1236                 :            : 
    1237                 :            :       /* A truncate of a memory is just loading the low part of the memory
    1238                 :            :          if we are not changing the meaning of the address. */
    1239                 :       6420 :       if (GET_CODE (op) == MEM
    1240                 :        363 :           && !VECTOR_MODE_P (mode)
    1241                 :        127 :           && !MEM_VOLATILE_P (op)
    1242                 :       6547 :           && !mode_dependent_address_p (XEXP (op, 0), MEM_ADDR_SPACE (op)))
    1243                 :            :         {
    1244                 :        127 :           temp = rtl_hooks.gen_lowpart_no_emit (mode, op);
    1245                 :        127 :           if (temp)
    1246                 :            :             return temp;
    1247                 :            :         }
    1248                 :            : 
    1249                 :            :       break;
    1250                 :            : 
    1251                 :     178572 :     case FLOAT_TRUNCATE:
    1252                 :     178572 :       if (DECIMAL_FLOAT_MODE_P (mode))
    1253                 :            :         break;
    1254                 :            : 
    1255                 :            :       /* (float_truncate:SF (float_extend:DF foo:SF)) = foo:SF.  */
    1256                 :     178304 :       if (GET_CODE (op) == FLOAT_EXTEND
    1257                 :          3 :           && GET_MODE (XEXP (op, 0)) == mode)
    1258                 :            :         return XEXP (op, 0);
    1259                 :            : 
    1260                 :            :       /* (float_truncate:SF (float_truncate:DF foo:XF))
    1261                 :            :          = (float_truncate:SF foo:XF).
    1262                 :            :          This may eliminate double rounding, so it is unsafe.
    1263                 :            : 
    1264                 :            :          (float_truncate:SF (float_extend:XF foo:DF))
    1265                 :            :          = (float_truncate:SF foo:DF).
    1266                 :            : 
    1267                 :            :          (float_truncate:DF (float_extend:XF foo:SF))
    1268                 :            :          = (float_extend:DF foo:SF).  */
    1269                 :     178304 :       if ((GET_CODE (op) == FLOAT_TRUNCATE
    1270                 :         74 :            && flag_unsafe_math_optimizations)
    1271                 :     178304 :           || GET_CODE (op) == FLOAT_EXTEND)
    1272                 :          9 :         return simplify_gen_unary (GET_MODE_UNIT_SIZE (GET_MODE (XEXP (op, 0)))
    1273                 :          3 :                                    > GET_MODE_UNIT_SIZE (mode)
    1274                 :            :                                    ? FLOAT_TRUNCATE : FLOAT_EXTEND,
    1275                 :            :                                    mode,
    1276                 :          3 :                                    XEXP (op, 0), mode);
    1277                 :            : 
    1278                 :            :       /*  (float_truncate (float x)) is (float x)  */
    1279                 :     177034 :       if ((GET_CODE (op) == FLOAT || GET_CODE (op) == UNSIGNED_FLOAT)
    1280                 :     178337 :           && (flag_unsafe_math_optimizations
    1281                 :       1303 :               || exact_int_to_float_conversion_p (op)))
    1282                 :       1302 :         return simplify_gen_unary (GET_CODE (op), mode,
    1283                 :            :                                    XEXP (op, 0),
    1284                 :       1302 :                                    GET_MODE (XEXP (op, 0)));
    1285                 :            : 
    1286                 :            :       /* (float_truncate:SF (OP:DF (float_extend:DF foo:sf))) is
    1287                 :            :          (OP:SF foo:SF) if OP is NEG or ABS.  */
    1288                 :     176999 :       if ((GET_CODE (op) == ABS
    1289                 :     176993 :            || GET_CODE (op) == NEG)
    1290                 :         15 :           && GET_CODE (XEXP (op, 0)) == FLOAT_EXTEND
    1291                 :          0 :           && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode)
    1292                 :          0 :         return simplify_gen_unary (GET_CODE (op), mode,
    1293                 :          0 :                                    XEXP (XEXP (op, 0), 0), mode);
    1294                 :            : 
    1295                 :            :       /* (float_truncate:SF (subreg:DF (float_truncate:SF X) 0))
    1296                 :            :          is (float_truncate:SF x).  */
    1297                 :     176999 :       if (GET_CODE (op) == SUBREG
    1298                 :        166 :           && subreg_lowpart_p (op)
    1299                 :     177159 :           && GET_CODE (SUBREG_REG (op)) == FLOAT_TRUNCATE)
    1300                 :            :         return SUBREG_REG (op);
    1301                 :            :       break;
    1302                 :            : 
    1303                 :     380842 :     case FLOAT_EXTEND:
    1304                 :     380842 :       if (DECIMAL_FLOAT_MODE_P (mode))
    1305                 :            :         break;
    1306                 :            : 
    1307                 :            :       /*  (float_extend (float_extend x)) is (float_extend x)
    1308                 :            : 
    1309                 :            :           (float_extend (float x)) is (float x) assuming that double
    1310                 :            :           rounding can't happen.
    1311                 :            :           */
    1312                 :     380686 :       if (GET_CODE (op) == FLOAT_EXTEND
    1313                 :     380686 :           || ((GET_CODE (op) == FLOAT || GET_CODE (op) == UNSIGNED_FLOAT)
    1314                 :       1075 :               && exact_int_to_float_conversion_p (op)))
    1315                 :        453 :         return simplify_gen_unary (GET_CODE (op), mode,
    1316                 :            :                                    XEXP (op, 0),
    1317                 :        453 :                                    GET_MODE (XEXP (op, 0)));
    1318                 :            : 
    1319                 :            :       break;
    1320                 :            : 
    1321                 :     183754 :     case ABS:
    1322                 :            :       /* (abs (neg <foo>)) -> (abs <foo>) */
    1323                 :     183754 :       if (GET_CODE (op) == NEG)
    1324                 :          2 :         return simplify_gen_unary (ABS, mode, XEXP (op, 0),
    1325                 :          2 :                                    GET_MODE (XEXP (op, 0)));
    1326                 :            : 
    1327                 :            :       /* If the mode of the operand is VOIDmode (i.e. if it is ASM_OPERANDS),
    1328                 :            :          do nothing.  */
    1329                 :     183752 :       if (GET_MODE (op) == VOIDmode)
    1330                 :            :         break;
    1331                 :            : 
    1332                 :            :       /* If operand is something known to be positive, ignore the ABS.  */
    1333                 :     183752 :       if (GET_CODE (op) == FFS || GET_CODE (op) == ABS
    1334                 :     367504 :           || val_signbit_known_clear_p (GET_MODE (op),
    1335                 :            :                                         nonzero_bits (op, GET_MODE (op))))
    1336                 :          0 :         return op;
    1337                 :            : 
    1338                 :            :       /* If operand is known to be only -1 or 0, convert ABS to NEG.  */
    1339                 :     183752 :       if (is_a <scalar_int_mode> (mode, &int_mode)
    1340                 :        877 :           && (num_sign_bit_copies (op, int_mode)
    1341                 :        877 :               == GET_MODE_PRECISION (int_mode)))
    1342                 :          0 :         return gen_rtx_NEG (int_mode, op);
    1343                 :            : 
    1344                 :            :       break;
    1345                 :            : 
    1346                 :          0 :     case FFS:
    1347                 :            :       /* (ffs (*_extend <X>)) = (ffs <X>) */
    1348                 :          0 :       if (GET_CODE (op) == SIGN_EXTEND
    1349                 :          0 :           || GET_CODE (op) == ZERO_EXTEND)
    1350                 :          0 :         return simplify_gen_unary (FFS, mode, XEXP (op, 0),
    1351                 :          0 :                                    GET_MODE (XEXP (op, 0)));
    1352                 :            :       break;
    1353                 :            : 
    1354                 :       1740 :     case POPCOUNT:
    1355                 :       1740 :       switch (GET_CODE (op))
    1356                 :            :         {
    1357                 :          7 :         case BSWAP:
    1358                 :          7 :         case ZERO_EXTEND:
    1359                 :            :           /* (popcount (zero_extend <X>)) = (popcount <X>) */
    1360                 :          7 :           return simplify_gen_unary (POPCOUNT, mode, XEXP (op, 0),
    1361                 :          7 :                                      GET_MODE (XEXP (op, 0)));
    1362                 :            : 
    1363                 :          0 :         case ROTATE:
    1364                 :          0 :         case ROTATERT:
    1365                 :            :           /* Rotations don't affect popcount.  */
    1366                 :          0 :           if (!side_effects_p (XEXP (op, 1)))
    1367                 :          0 :             return simplify_gen_unary (POPCOUNT, mode, XEXP (op, 0),
    1368                 :          0 :                                        GET_MODE (XEXP (op, 0)));
    1369                 :            :           break;
    1370                 :            : 
    1371                 :            :         default:
    1372                 :            :           break;
    1373                 :            :         }
    1374                 :            :       break;
    1375                 :            : 
    1376                 :          0 :     case PARITY:
    1377                 :          0 :       switch (GET_CODE (op))
    1378                 :            :         {
    1379                 :          0 :         case NOT:
    1380                 :          0 :         case BSWAP:
    1381                 :          0 :         case ZERO_EXTEND:
    1382                 :          0 :         case SIGN_EXTEND:
    1383                 :          0 :           return simplify_gen_unary (PARITY, mode, XEXP (op, 0),
    1384                 :          0 :                                      GET_MODE (XEXP (op, 0)));
    1385                 :            : 
    1386                 :          0 :         case ROTATE:
    1387                 :          0 :         case ROTATERT:
    1388                 :            :           /* Rotations don't affect parity.  */
    1389                 :          0 :           if (!side_effects_p (XEXP (op, 1)))
    1390                 :          0 :             return simplify_gen_unary (PARITY, mode, XEXP (op, 0),
    1391                 :          0 :                                        GET_MODE (XEXP (op, 0)));
    1392                 :            :           break;
    1393                 :            : 
    1394                 :            :         default:
    1395                 :            :           break;
    1396                 :            :         }
    1397                 :            :       break;
    1398                 :            : 
    1399                 :      17192 :     case BSWAP:
    1400                 :            :       /* (bswap (bswap x)) -> x.  */
    1401                 :      17192 :       if (GET_CODE (op) == BSWAP)
    1402                 :        104 :         return XEXP (op, 0);
    1403                 :            :       break;
    1404                 :            : 
    1405                 :     485106 :     case FLOAT:
    1406                 :            :       /* (float (sign_extend <X>)) = (float <X>).  */
    1407                 :     485106 :       if (GET_CODE (op) == SIGN_EXTEND)
    1408                 :       5058 :         return simplify_gen_unary (FLOAT, mode, XEXP (op, 0),
    1409                 :       5058 :                                    GET_MODE (XEXP (op, 0)));
    1410                 :            :       break;
    1411                 :            : 
    1412                 :    2653090 :     case SIGN_EXTEND:
    1413                 :            :       /* (sign_extend (truncate (minus (label_ref L1) (label_ref L2))))
    1414                 :            :          becomes just the MINUS if its mode is MODE.  This allows
    1415                 :            :          folding switch statements on machines using casesi (such as
    1416                 :            :          the VAX).  */
    1417                 :    2653090 :       if (GET_CODE (op) == TRUNCATE
    1418                 :         24 :           && GET_MODE (XEXP (op, 0)) == mode
    1419                 :         24 :           && GET_CODE (XEXP (op, 0)) == MINUS
    1420                 :          0 :           && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF
    1421                 :          0 :           && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF)
    1422                 :            :         return XEXP (op, 0);
    1423                 :            : 
    1424                 :            :       /* Extending a widening multiplication should be canonicalized to
    1425                 :            :          a wider widening multiplication.  */
    1426                 :    2653090 :       if (GET_CODE (op) == MULT)
    1427                 :            :         {
    1428                 :      83235 :           rtx lhs = XEXP (op, 0);
    1429                 :      83235 :           rtx rhs = XEXP (op, 1);
    1430                 :      83235 :           enum rtx_code lcode = GET_CODE (lhs);
    1431                 :      83235 :           enum rtx_code rcode = GET_CODE (rhs);
    1432                 :            : 
    1433                 :            :           /* Widening multiplies usually extend both operands, but sometimes
    1434                 :            :              they use a shift to extract a portion of a register.  */
    1435                 :      83235 :           if ((lcode == SIGN_EXTEND
    1436                 :      83029 :                || (lcode == ASHIFTRT && CONST_INT_P (XEXP (lhs, 1))))
    1437                 :        486 :               && (rcode == SIGN_EXTEND
    1438                 :        442 :                   || (rcode == ASHIFTRT && CONST_INT_P (XEXP (rhs, 1)))))
    1439                 :            :             {
    1440                 :        108 :               machine_mode lmode = GET_MODE (lhs);
    1441                 :        108 :               machine_mode rmode = GET_MODE (rhs);
    1442                 :        108 :               int bits;
    1443                 :            : 
    1444                 :        108 :               if (lcode == ASHIFTRT)
    1445                 :            :                 /* Number of bits not shifted off the end.  */
    1446                 :         68 :                 bits = (GET_MODE_UNIT_PRECISION (lmode)
    1447                 :         68 :                         - INTVAL (XEXP (lhs, 1)));
    1448                 :            :               else /* lcode == SIGN_EXTEND */
    1449                 :            :                 /* Size of inner mode.  */
    1450                 :         80 :                 bits = GET_MODE_UNIT_PRECISION (GET_MODE (XEXP (lhs, 0)));
    1451                 :            : 
    1452                 :        108 :               if (rcode == ASHIFTRT)
    1453                 :         64 :                 bits += (GET_MODE_UNIT_PRECISION (rmode)
    1454                 :         64 :                          - INTVAL (XEXP (rhs, 1)));
    1455                 :            :               else /* rcode == SIGN_EXTEND */
    1456                 :         88 :                 bits += GET_MODE_UNIT_PRECISION (GET_MODE (XEXP (rhs, 0)));
    1457                 :            : 
    1458                 :            :               /* We can only widen multiplies if the result is mathematiclly
    1459                 :            :                  equivalent.  I.e. if overflow was impossible.  */
    1460                 :        216 :               if (bits <= GET_MODE_UNIT_PRECISION (GET_MODE (op)))
    1461                 :        108 :                 return simplify_gen_binary
    1462                 :        108 :                          (MULT, mode,
    1463                 :            :                           simplify_gen_unary (SIGN_EXTEND, mode, lhs, lmode),
    1464                 :        108 :                           simplify_gen_unary (SIGN_EXTEND, mode, rhs, rmode));
    1465                 :            :             }
    1466                 :            :         }
    1467                 :            : 
    1468                 :            :       /* Check for a sign extension of a subreg of a promoted
    1469                 :            :          variable, where the promotion is sign-extended, and the
    1470                 :            :          target mode is the same as the variable's promotion.  */
    1471                 :    2652980 :       if (GET_CODE (op) == SUBREG
    1472                 :     217328 :           && SUBREG_PROMOTED_VAR_P (op)
    1473                 :          0 :           && SUBREG_PROMOTED_SIGNED_P (op)
    1474                 :    2652980 :           && !paradoxical_subreg_p (mode, GET_MODE (SUBREG_REG (op))))
    1475                 :            :         {
    1476                 :          0 :           temp = rtl_hooks.gen_lowpart_no_emit (mode, SUBREG_REG (op));
    1477                 :          0 :           if (temp)
    1478                 :            :             return temp;
    1479                 :            :         }
    1480                 :            : 
    1481                 :            :       /* (sign_extend:M (sign_extend:N <X>)) is (sign_extend:M <X>).
    1482                 :            :          (sign_extend:M (zero_extend:N <X>)) is (zero_extend:M <X>).  */
    1483                 :    2652980 :       if (GET_CODE (op) == SIGN_EXTEND || GET_CODE (op) == ZERO_EXTEND)
    1484                 :            :         {
    1485                 :      34593 :           gcc_assert (GET_MODE_UNIT_PRECISION (mode)
    1486                 :            :                       > GET_MODE_UNIT_PRECISION (GET_MODE (op)));
    1487                 :      11531 :           return simplify_gen_unary (GET_CODE (op), mode, XEXP (op, 0),
    1488                 :      11531 :                                      GET_MODE (XEXP (op, 0)));
    1489                 :            :         }
    1490                 :            : 
    1491                 :            :       /* (sign_extend:M (ashiftrt:N (ashift <X> (const_int I)) (const_int I)))
    1492                 :            :          is (sign_extend:M (subreg:O <X>)) if there is mode with
    1493                 :            :          GET_MODE_BITSIZE (N) - I bits.
    1494                 :            :          (sign_extend:M (lshiftrt:N (ashift <X> (const_int I)) (const_int I)))
    1495                 :            :          is similarly (zero_extend:M (subreg:O <X>)).  */
    1496                 :    2641450 :       if ((GET_CODE (op) == ASHIFTRT || GET_CODE (op) == LSHIFTRT)
    1497                 :      73611 :           && GET_CODE (XEXP (op, 0)) == ASHIFT
    1498                 :    2641870 :           && is_a <scalar_int_mode> (mode, &int_mode)
    1499                 :       7772 :           && CONST_INT_P (XEXP (op, 1))
    1500                 :       7772 :           && XEXP (XEXP (op, 0), 1) == XEXP (op, 1)
    1501                 :    2649200 :           && (op_mode = as_a <scalar_int_mode> (GET_MODE (op)),
    1502                 :       7743 :               GET_MODE_PRECISION (op_mode) > INTVAL (XEXP (op, 1))))
    1503                 :            :         {
    1504                 :       7743 :           scalar_int_mode tmode;
    1505                 :       7743 :           gcc_assert (GET_MODE_PRECISION (int_mode)
    1506                 :            :                       > GET_MODE_PRECISION (op_mode));
    1507                 :       7743 :           if (int_mode_for_size (GET_MODE_PRECISION (op_mode)
    1508                 :      15486 :                                  - INTVAL (XEXP (op, 1)), 1).exists (&tmode))
    1509                 :            :             {
    1510                 :       7359 :               rtx inner =
    1511                 :       7359 :                 rtl_hooks.gen_lowpart_no_emit (tmode, XEXP (XEXP (op, 0), 0));
    1512                 :       7359 :               if (inner)
    1513                 :       7359 :                 return simplify_gen_unary (GET_CODE (op) == ASHIFTRT
    1514                 :            :                                            ? SIGN_EXTEND : ZERO_EXTEND,
    1515                 :       7359 :                                            int_mode, inner, tmode);
    1516                 :            :             }
    1517                 :            :         }
    1518                 :            : 
    1519                 :            :       /* (sign_extend:M (lshiftrt:N <X> (const_int I))) is better as
    1520                 :            :          (zero_extend:M (lshiftrt:N <X> (const_int I))) if I is not 0.  */
    1521                 :    2634100 :       if (GET_CODE (op) == LSHIFTRT
    1522                 :        464 :           && CONST_INT_P (XEXP (op, 1))
    1523                 :        464 :           && XEXP (op, 1) != const0_rtx)
    1524                 :        464 :         return simplify_gen_unary (ZERO_EXTEND, mode, op, GET_MODE (op));
    1525                 :            : 
    1526                 :            : #if defined(POINTERS_EXTEND_UNSIGNED)
    1527                 :            :       /* As we do not know which address space the pointer is referring to,
    1528                 :            :          we can do this only if the target does not support different pointer
    1529                 :            :          or address modes depending on the address space.  */
    1530                 :    2633630 :       if (target_default_pointer_address_modes_p ()
    1531                 :            :           && ! POINTERS_EXTEND_UNSIGNED
    1532                 :            :           && mode == Pmode && GET_MODE (op) == ptr_mode
    1533                 :            :           && (CONSTANT_P (op)
    1534                 :            :               || (GET_CODE (op) == SUBREG
    1535                 :            :                   && REG_P (SUBREG_REG (op))
    1536                 :            :                   && REG_POINTER (SUBREG_REG (op))
    1537                 :            :                   && GET_MODE (SUBREG_REG (op)) == Pmode))
    1538                 :            :           && !targetm.have_ptr_extend ())
    1539                 :            :         {
    1540                 :            :           temp
    1541                 :            :             = convert_memory_address_addr_space_1 (Pmode, op,
    1542                 :            :                                                    ADDR_SPACE_GENERIC, false,
    1543                 :            :                                                    true);
    1544                 :            :           if (temp)
    1545                 :            :             return temp;
    1546                 :            :         }
    1547                 :            : #endif
    1548                 :            :       break;
    1549                 :            : 
    1550                 :    3029380 :     case ZERO_EXTEND:
    1551                 :            :       /* Check for a zero extension of a subreg of a promoted
    1552                 :            :          variable, where the promotion is zero-extended, and the
    1553                 :            :          target mode is the same as the variable's promotion.  */
    1554                 :    3029380 :       if (GET_CODE (op) == SUBREG
    1555                 :     603781 :           && SUBREG_PROMOTED_VAR_P (op)
    1556                 :          0 :           && SUBREG_PROMOTED_UNSIGNED_P (op)
    1557                 :    3029380 :           && !paradoxical_subreg_p (mode, GET_MODE (SUBREG_REG (op))))
    1558                 :            :         {
    1559                 :          0 :           temp = rtl_hooks.gen_lowpart_no_emit (mode, SUBREG_REG (op));
    1560                 :          0 :           if (temp)
    1561                 :            :             return temp;
    1562                 :            :         }
    1563                 :            : 
    1564                 :            :       /* Extending a widening multiplication should be canonicalized to
    1565                 :            :          a wider widening multiplication.  */
    1566                 :    3029380 :       if (GET_CODE (op) == MULT)
    1567                 :            :         {
    1568                 :     119365 :           rtx lhs = XEXP (op, 0);
    1569                 :     119365 :           rtx rhs = XEXP (op, 1);
    1570                 :     119365 :           enum rtx_code lcode = GET_CODE (lhs);
    1571                 :     119365 :           enum rtx_code rcode = GET_CODE (rhs);
    1572                 :            : 
    1573                 :            :           /* Widening multiplies usually extend both operands, but sometimes
    1574                 :            :              they use a shift to extract a portion of a register.  */
    1575                 :     119365 :           if ((lcode == ZERO_EXTEND
    1576                 :     118996 :                || (lcode == LSHIFTRT && CONST_INT_P (XEXP (lhs, 1))))
    1577                 :        369 :               && (rcode == ZERO_EXTEND
    1578                 :        327 :                   || (rcode == LSHIFTRT && CONST_INT_P (XEXP (rhs, 1)))))
    1579                 :            :             {
    1580                 :         42 :               machine_mode lmode = GET_MODE (lhs);
    1581                 :         42 :               machine_mode rmode = GET_MODE (rhs);
    1582                 :         42 :               int bits;
    1583                 :            : 
    1584                 :         42 :               if (lcode == LSHIFTRT)
    1585                 :            :                 /* Number of bits not shifted off the end.  */
    1586                 :          0 :                 bits = (GET_MODE_UNIT_PRECISION (lmode)
    1587                 :          0 :                         - INTVAL (XEXP (lhs, 1)));
    1588                 :            :               else /* lcode == ZERO_EXTEND */
    1589                 :            :                 /* Size of inner mode.  */
    1590                 :         84 :                 bits = GET_MODE_UNIT_PRECISION (GET_MODE (XEXP (lhs, 0)));
    1591                 :            : 
    1592                 :         42 :               if (rcode == LSHIFTRT)
    1593                 :          0 :                 bits += (GET_MODE_UNIT_PRECISION (rmode)
    1594                 :          0 :                          - INTVAL (XEXP (rhs, 1)));
    1595                 :            :               else /* rcode == ZERO_EXTEND */
    1596                 :         84 :                 bits += GET_MODE_UNIT_PRECISION (GET_MODE (XEXP (rhs, 0)));
    1597                 :            : 
    1598                 :            :               /* We can only widen multiplies if the result is mathematiclly
    1599                 :            :                  equivalent.  I.e. if overflow was impossible.  */
    1600                 :         84 :               if (bits <= GET_MODE_UNIT_PRECISION (GET_MODE (op)))
    1601                 :         42 :                 return simplify_gen_binary
    1602                 :         42 :                          (MULT, mode,
    1603                 :            :                           simplify_gen_unary (ZERO_EXTEND, mode, lhs, lmode),
    1604                 :         42 :                           simplify_gen_unary (ZERO_EXTEND, mode, rhs, rmode));
    1605                 :            :             }
    1606                 :            :         }
    1607                 :            : 
    1608                 :            :       /* (zero_extend:M (zero_extend:N <X>)) is (zero_extend:M <X>).  */
    1609                 :    3029340 :       if (GET_CODE (op) == ZERO_EXTEND)
    1610                 :       3858 :         return simplify_gen_unary (ZERO_EXTEND, mode, XEXP (op, 0),
    1611                 :       3858 :                                    GET_MODE (XEXP (op, 0)));
    1612                 :            : 
    1613                 :            :       /* (zero_extend:M (lshiftrt:N (ashift <X> (const_int I)) (const_int I)))
    1614                 :            :          is (zero_extend:M (subreg:O <X>)) if there is mode with
    1615                 :            :          GET_MODE_PRECISION (N) - I bits.  */
    1616                 :    3025480 :       if (GET_CODE (op) == LSHIFTRT
    1617                 :      36024 :           && GET_CODE (XEXP (op, 0)) == ASHIFT
    1618                 :    3025490 :           && is_a <scalar_int_mode> (mode, &int_mode)
    1619                 :          5 :           && CONST_INT_P (XEXP (op, 1))
    1620                 :          0 :           && XEXP (XEXP (op, 0), 1) == XEXP (op, 1)
    1621                 :    3025480 :           && (op_mode = as_a <scalar_int_mode> (GET_MODE (op)),
    1622                 :          0 :               GET_MODE_PRECISION (op_mode) > INTVAL (XEXP (op, 1))))
    1623                 :            :         {
    1624                 :          0 :           scalar_int_mode tmode;
    1625                 :          0 :           if (int_mode_for_size (GET_MODE_PRECISION (op_mode)
    1626                 :          0 :                                  - INTVAL (XEXP (op, 1)), 1).exists (&tmode))
    1627                 :            :             {
    1628                 :          0 :               rtx inner =
    1629                 :          0 :                 rtl_hooks.gen_lowpart_no_emit (tmode, XEXP (XEXP (op, 0), 0));
    1630                 :          0 :               if (inner)
    1631                 :          0 :                 return simplify_gen_unary (ZERO_EXTEND, int_mode,
    1632                 :          0 :                                            inner, tmode);
    1633                 :            :             }
    1634                 :            :         }
    1635                 :            : 
    1636                 :            :       /* (zero_extend:M (subreg:N <X:O>)) is <X:O> (for M == O) or
    1637                 :            :          (zero_extend:M <X:O>), if X doesn't have any non-zero bits outside
    1638                 :            :          of mode N.  E.g.
    1639                 :            :          (zero_extend:SI (subreg:QI (and:SI (reg:SI) (const_int 63)) 0)) is
    1640                 :            :          (and:SI (reg:SI) (const_int 63)).  */
    1641                 :    3025480 :       if (partial_subreg_p (op)
    1642                 :    3588230 :           && is_a <scalar_int_mode> (mode, &int_mode)
    1643                 :     598897 :           && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (op)), &op0_mode)
    1644                 :     598744 :           && GET_MODE_PRECISION (op0_mode) <= HOST_BITS_PER_WIDE_INT
    1645                 :     517441 :           && GET_MODE_PRECISION (int_mode) >= GET_MODE_PRECISION (op0_mode)
    1646                 :     486942 :           && subreg_lowpart_p (op)
    1647                 :     973386 :           && (nonzero_bits (SUBREG_REG (op), op0_mode)
    1648                 :     369605 :               & ~GET_MODE_MASK (GET_MODE (op))) == 0)
    1649                 :            :         {
    1650                 :      36152 :           if (GET_MODE_PRECISION (int_mode) == GET_MODE_PRECISION (op0_mode))
    1651                 :      34286 :             return SUBREG_REG (op);
    1652                 :       1866 :           return simplify_gen_unary (ZERO_EXTEND, int_mode, SUBREG_REG (op),
    1653                 :       1866 :                                      op0_mode);
    1654                 :            :         }
    1655                 :            : 
    1656                 :            : #if defined(POINTERS_EXTEND_UNSIGNED)
    1657                 :            :       /* As we do not know which address space the pointer is referring to,
    1658                 :            :          we can do this only if the target does not support different pointer
    1659                 :            :          or address modes depending on the address space.  */
    1660                 :    2989330 :       if (target_default_pointer_address_modes_p ()
    1661                 :            :           && POINTERS_EXTEND_UNSIGNED > 0
    1662                 :    3540600 :           && mode == Pmode && GET_MODE (op) == ptr_mode
    1663                 :        297 :           && (CONSTANT_P (op)
    1664                 :        282 :               || (GET_CODE (op) == SUBREG
    1665                 :          0 :                   && REG_P (SUBREG_REG (op))
    1666                 :          0 :                   && REG_POINTER (SUBREG_REG (op))
    1667                 :          0 :                   && GET_MODE (SUBREG_REG (op)) == Pmode))
    1668                 :    2989340 :           && !targetm.have_ptr_extend ())
    1669                 :            :         {
    1670                 :         15 :           temp
    1671                 :         30 :             = convert_memory_address_addr_space_1 (Pmode, op,
    1672                 :            :                                                    ADDR_SPACE_GENERIC, false,
    1673                 :            :                                                    true);
    1674                 :         15 :           if (temp)
    1675                 :            :             return temp;
    1676                 :            :         }
    1677                 :            : #endif
    1678                 :            :       break;
    1679                 :            : 
    1680                 :            :     default:
    1681                 :            :       break;
    1682                 :            :     }
    1683                 :            : 
    1684                 :    8553440 :   if (VECTOR_MODE_P (mode)
    1685                 :     657029 :       && vec_duplicate_p (op, &elt)
    1686                 :    9212060 :       && code != VEC_DUPLICATE)
    1687                 :            :     {
    1688                 :            :       /* Try applying the operator to ELT and see if that simplifies.
    1689                 :            :          We can duplicate the result if so.
    1690                 :            : 
    1691                 :            :          The reason we don't use simplify_gen_unary is that it isn't
    1692                 :            :          necessarily a win to convert things like:
    1693                 :            : 
    1694                 :            :            (neg:V (vec_duplicate:V (reg:S R)))
    1695                 :            : 
    1696                 :            :          to:
    1697                 :            : 
    1698                 :            :            (vec_duplicate:V (neg:S (reg:S R)))
    1699                 :            : 
    1700                 :            :          The first might be done entirely in vector registers while the
    1701                 :            :          second might need a move between register files.  */
    1702                 :       3174 :       temp = simplify_unary_operation (code, GET_MODE_INNER (mode),
    1703                 :       3174 :                                        elt, GET_MODE_INNER (GET_MODE (op)));
    1704                 :       1587 :       if (temp)
    1705                 :        128 :         return gen_vec_duplicate (mode, temp);
    1706                 :            :     }
    1707                 :            : 
    1708                 :            :   return 0;
    1709                 :            : }
    1710                 :            : 
    1711                 :            : /* Try to compute the value of a unary operation CODE whose output mode is to
    1712                 :            :    be MODE with input operand OP whose mode was originally OP_MODE.
    1713                 :            :    Return zero if the value cannot be computed.  */
    1714                 :            : rtx
    1715                 :   13643300 : simplify_const_unary_operation (enum rtx_code code, machine_mode mode,
    1716                 :            :                                 rtx op, machine_mode op_mode)
    1717                 :            : {
    1718                 :   13643300 :   scalar_int_mode result_mode;
    1719                 :            : 
    1720                 :   13643300 :   if (code == VEC_DUPLICATE)
    1721                 :            :     {
    1722                 :     131200 :       gcc_assert (VECTOR_MODE_P (mode));
    1723                 :     131200 :       if (GET_MODE (op) != VOIDmode)
    1724                 :            :       {
    1725                 :     123177 :         if (!VECTOR_MODE_P (GET_MODE (op)))
    1726                 :     237300 :           gcc_assert (GET_MODE_INNER (mode) == GET_MODE (op));
    1727                 :            :         else
    1728                 :      13581 :           gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER
    1729                 :            :                                                 (GET_MODE (op)));
    1730                 :            :       }
    1731                 :     131200 :       if (CONST_SCALAR_INT_P (op) || CONST_DOUBLE_AS_FLOAT_P (op))
    1732                 :       9696 :         return gen_const_vec_duplicate (mode, op);
    1733                 :     121504 :       if (GET_CODE (op) == CONST_VECTOR
    1734                 :     121504 :           && (CONST_VECTOR_DUPLICATE_P (op)
    1735                 :        728 :               || CONST_VECTOR_NUNITS (op).is_constant ()))
    1736                 :            :         {
    1737                 :        364 :           unsigned int npatterns = (CONST_VECTOR_DUPLICATE_P (op)
    1738                 :        728 :                                     ? CONST_VECTOR_NPATTERNS (op)
    1739                 :        728 :                                     : CONST_VECTOR_NUNITS (op).to_constant ());
    1740                 :        728 :           gcc_assert (multiple_p (GET_MODE_NUNITS (mode), npatterns));
    1741                 :        364 :           rtx_vector_builder builder (mode, npatterns, 1);
    1742                 :       1302 :           for (unsigned i = 0; i < npatterns; i++)
    1743                 :        938 :             builder.quick_push (CONST_VECTOR_ELT (op, i));
    1744                 :        364 :           return builder.build ();
    1745                 :            :         }
    1746                 :            :     }
    1747                 :            : 
    1748                 :   12994600 :   if (VECTOR_MODE_P (mode)
    1749                 :     796227 :       && GET_CODE (op) == CONST_VECTOR
    1750                 :   13675900 :       && known_eq (GET_MODE_NUNITS (mode), CONST_VECTOR_NUNITS (op)))
    1751                 :            :     {
    1752                 :      14217 :       gcc_assert (GET_MODE (op) == op_mode);
    1753                 :            : 
    1754                 :      28434 :       rtx_vector_builder builder;
    1755                 :      14217 :       if (!builder.new_unary_operation (mode, op, false))
    1756                 :            :         return 0;
    1757                 :            : 
    1758                 :      14217 :       unsigned int count = builder.encoded_nelts ();
    1759                 :      39063 :       for (unsigned int i = 0; i < count; i++)
    1760                 :            :         {
    1761                 :      53176 :           rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode),
    1762                 :            :                                             CONST_VECTOR_ELT (op, i),
    1763                 :      53176 :                                             GET_MODE_INNER (op_mode));
    1764                 :      26588 :           if (!x || !valid_for_const_vector_p (mode, x))
    1765                 :       1742 :             return 0;
    1766                 :      24846 :           builder.quick_push (x);
    1767                 :            :         }
    1768                 :      12475 :       return builder.build ();
    1769                 :            :     }
    1770                 :            : 
    1771                 :            :   /* The order of these tests is critical so that, for example, we don't
    1772                 :            :      check the wrong mode (input vs. output) for a conversion operation,
    1773                 :            :      such as FIX.  At some point, this should be simplified.  */
    1774                 :            : 
    1775                 :   13619000 :   if (code == FLOAT && CONST_SCALAR_INT_P (op))
    1776                 :            :     {
    1777                 :       4389 :       REAL_VALUE_TYPE d;
    1778                 :            : 
    1779                 :       4389 :       if (op_mode == VOIDmode)
    1780                 :            :         {
    1781                 :            :           /* CONST_INT have VOIDmode as the mode.  We assume that all
    1782                 :            :              the bits of the constant are significant, though, this is
    1783                 :            :              a dangerous assumption as many times CONST_INTs are
    1784                 :            :              created and used with garbage in the bits outside of the
    1785                 :            :              precision of the implied mode of the const_int.  */
    1786                 :          0 :           op_mode = MAX_MODE_INT;
    1787                 :            :         }
    1788                 :            : 
    1789                 :       4389 :       real_from_integer (&d, mode, rtx_mode_t (op, op_mode), SIGNED);
    1790                 :            : 
    1791                 :            :       /* Avoid the folding if flag_signaling_nans is on and
    1792                 :            :          operand is a signaling NaN.  */
    1793                 :       4389 :       if (HONOR_SNANS (mode) && REAL_VALUE_ISSIGNALING_NAN (d))
    1794                 :            :         return 0;
    1795                 :            : 
    1796                 :       4389 :       d = real_value_truncate (mode, d);
    1797                 :       4389 :       return const_double_from_real_value (d, mode);
    1798                 :            :     }
    1799                 :   13614600 :   else if (code == UNSIGNED_FLOAT && CONST_SCALAR_INT_P (op))
    1800                 :            :     {
    1801                 :        770 :       REAL_VALUE_TYPE d;
    1802                 :            : 
    1803                 :        770 :       if (op_mode == VOIDmode)
    1804                 :            :         {
    1805                 :            :           /* CONST_INT have VOIDmode as the mode.  We assume that all
    1806                 :            :              the bits of the constant are significant, though, this is
    1807                 :            :              a dangerous assumption as many times CONST_INTs are
    1808                 :            :              created and used with garbage in the bits outside of the
    1809                 :            :              precision of the implied mode of the const_int.  */
    1810                 :          0 :           op_mode = MAX_MODE_INT;
    1811                 :            :         }
    1812                 :            : 
    1813                 :        770 :       real_from_integer (&d, mode, rtx_mode_t (op, op_mode), UNSIGNED);
    1814                 :            : 
    1815                 :            :       /* Avoid the folding if flag_signaling_nans is on and
    1816                 :            :          operand is a signaling NaN.  */
    1817                 :        770 :       if (HONOR_SNANS (mode) && REAL_VALUE_ISSIGNALING_NAN (d))
    1818                 :            :         return 0;
    1819                 :            : 
    1820                 :        770 :       d = real_value_truncate (mode, d);
    1821                 :        770 :       return const_double_from_real_value (d, mode);
    1822                 :            :     }
    1823                 :            : 
    1824                 :   13613800 :   if (CONST_SCALAR_INT_P (op) && is_a <scalar_int_mode> (mode, &result_mode))
    1825                 :            :     {
    1826                 :    1589160 :       unsigned int width = GET_MODE_PRECISION (result_mode);
    1827                 :    1589160 :       if (width > MAX_BITSIZE_MODE_ANY_INT)
    1828                 :            :         return 0;
    1829                 :            : 
    1830                 :    1589160 :       wide_int result;
    1831                 :    1589160 :       scalar_int_mode imode = (op_mode == VOIDmode
    1832                 :            :                                ? result_mode
    1833                 :    1589160 :                                : as_a <scalar_int_mode> (op_mode));
    1834                 :    1589160 :       rtx_mode_t op0 = rtx_mode_t (op, imode);
    1835                 :    1589160 :       int int_value;
    1836                 :            : 
    1837                 :            : #if TARGET_SUPPORTS_WIDE_INT == 0
    1838                 :            :       /* This assert keeps the simplification from producing a result
    1839                 :            :          that cannot be represented in a CONST_DOUBLE but a lot of
    1840                 :            :          upstream callers expect that this function never fails to
    1841                 :            :          simplify something and so you if you added this to the test
    1842                 :            :          above the code would die later anyway.  If this assert
    1843                 :            :          happens, you just need to make the port support wide int.  */
    1844                 :            :       gcc_assert (width <= HOST_BITS_PER_DOUBLE_INT);
    1845                 :            : #endif
    1846                 :            : 
    1847                 :    1589160 :       switch (code)
    1848                 :            :         {
    1849                 :      97396 :         case NOT:
    1850                 :      97396 :           result = wi::bit_not (op0);
    1851                 :      97396 :           break;
    1852                 :            : 
    1853                 :     817828 :         case NEG:
    1854                 :     817828 :           result = wi::neg (op0);
    1855                 :     817828 :           break;
    1856                 :            : 
    1857                 :        435 :         case ABS:
    1858                 :        435 :           result = wi::abs (op0);
    1859                 :        435 :           break;
    1860                 :            : 
    1861                 :          0 :         case FFS:
    1862                 :          0 :           result = wi::shwi (wi::ffs (op0), result_mode);
    1863                 :          0 :           break;
    1864                 :            : 
    1865                 :          1 :         case CLZ:
    1866                 :          1 :           if (wi::ne_p (op0, 0))
    1867                 :          1 :             int_value = wi::clz (op0);
    1868                 :          0 :           else if (! CLZ_DEFINED_VALUE_AT_ZERO (imode, int_value))
    1869                 :            :             return NULL_RTX;
    1870                 :          1 :           result = wi::shwi (int_value, result_mode);
    1871                 :          1 :           break;
    1872                 :            : 
    1873                 :          0 :         case CLRSB:
    1874                 :          0 :           result = wi::shwi (wi::clrsb (op0), result_mode);
    1875                 :          0 :           break;
    1876                 :            : 
    1877                 :         17 :         case CTZ:
    1878                 :         17 :           if (wi::ne_p (op0, 0))
    1879                 :          0 :             int_value = wi::ctz (op0);
    1880                 :         34 :           else if (! CTZ_DEFINED_VALUE_AT_ZERO (imode, int_value))
    1881                 :            :             return NULL_RTX;
    1882                 :          0 :           result = wi::shwi (int_value, result_mode);
    1883                 :          0 :           break;
    1884                 :            : 
    1885                 :        303 :         case POPCOUNT:
    1886                 :        303 :           result = wi::shwi (wi::popcount (op0), result_mode);
    1887                 :        303 :           break;
    1888                 :            : 
    1889                 :          0 :         case PARITY:
    1890                 :          0 :           result = wi::shwi (wi::parity (op0), result_mode);
    1891                 :          0 :           break;
    1892                 :            : 
    1893                 :       1552 :         case BSWAP:
    1894                 :       1552 :           result = wide_int (op0).bswap ();
    1895                 :       1552 :           break;
    1896                 :            : 
    1897                 :     476708 :         case TRUNCATE:
    1898                 :     476708 :         case ZERO_EXTEND:
    1899                 :     476708 :           result = wide_int::from (op0, width, UNSIGNED);
    1900                 :     476708 :           break;
    1901                 :            : 
    1902                 :     193403 :         case SIGN_EXTEND:
    1903                 :     193403 :           result = wide_int::from (op0, width, SIGNED);
    1904                 :     193403 :           break;
    1905                 :            : 
    1906                 :            :         case SQRT:
    1907                 :            :         default:
    1908                 :            :           return 0;
    1909                 :            :         }
    1910                 :            : 
    1911                 :    1587630 :       return immed_wide_int_const (result, result_mode);
    1912                 :            :     }
    1913                 :            : 
    1914                 :   12024700 :   else if (CONST_DOUBLE_AS_FLOAT_P (op) 
    1915                 :     301323 :            && SCALAR_FLOAT_MODE_P (mode)
    1916                 :     300617 :            && SCALAR_FLOAT_MODE_P (GET_MODE (op)))
    1917                 :            :     {
    1918                 :     300617 :       REAL_VALUE_TYPE d = *CONST_DOUBLE_REAL_VALUE (op);
    1919                 :     300617 :       switch (code)
    1920                 :            :         {
    1921                 :            :         case SQRT:
    1922                 :            :           return 0;
    1923                 :        378 :         case ABS:
    1924                 :        378 :           d = real_value_abs (&d);
    1925                 :        378 :           break;
    1926                 :      12497 :         case NEG:
    1927                 :      12497 :           d = real_value_negate (&d);
    1928                 :      12497 :           break;
    1929                 :        372 :         case FLOAT_TRUNCATE:
    1930                 :            :           /* Don't perform the operation if flag_signaling_nans is on
    1931                 :            :              and the operand is a signaling NaN.  */
    1932                 :        372 :           if (HONOR_SNANS (mode) && REAL_VALUE_ISSIGNALING_NAN (d))
    1933                 :            :             return NULL_RTX;
    1934                 :        372 :           d = real_value_truncate (mode, d);
    1935                 :        372 :           break;
    1936                 :     283068 :         case FLOAT_EXTEND:
    1937                 :            :           /* Don't perform the operation if flag_signaling_nans is on
    1938                 :            :              and the operand is a signaling NaN.  */
    1939                 :     283068 :           if (HONOR_SNANS (mode) && REAL_VALUE_ISSIGNALING_NAN (d))
    1940                 :            :             return NULL_RTX;
    1941                 :            :           /* All this does is change the mode, unless changing
    1942                 :            :              mode class.  */
    1943                 :     283067 :           if (GET_MODE_CLASS (mode) != GET_MODE_CLASS (GET_MODE (op)))
    1944                 :          0 :             real_convert (&d, mode, &d);
    1945                 :            :           break;
    1946                 :          0 :         case FIX:
    1947                 :            :           /* Don't perform the operation if flag_signaling_nans is on
    1948                 :            :              and the operand is a signaling NaN.  */
    1949                 :          0 :           if (HONOR_SNANS (mode) && REAL_VALUE_ISSIGNALING_NAN (d))
    1950                 :            :             return NULL_RTX;
    1951                 :          0 :           real_arithmetic (&d, FIX_TRUNC_EXPR, &d, NULL);
    1952                 :          0 :           break;
    1953                 :       3240 :         case NOT:
    1954                 :       3240 :           {
    1955                 :       3240 :             long tmp[4];
    1956                 :       3240 :             int i;
    1957                 :            : 
    1958                 :       3240 :             real_to_target (tmp, &d, GET_MODE (op));
    1959                 :      16200 :             for (i = 0; i < 4; i++)
    1960                 :      12960 :               tmp[i] = ~tmp[i];
    1961                 :       3240 :             real_from_target (&d, tmp, mode);
    1962                 :       3240 :             break;
    1963                 :            :           }
    1964                 :          0 :         default:
    1965                 :          0 :           gcc_unreachable ();
    1966                 :            :         }
    1967                 :     299554 :       return const_double_from_real_value (d, mode);
    1968                 :            :     }
    1969                 :        706 :   else if (CONST_DOUBLE_AS_FLOAT_P (op)
    1970                 :        706 :            && SCALAR_FLOAT_MODE_P (GET_MODE (op))
    1971                 :   11724800 :            && is_int_mode (mode, &result_mode))
    1972                 :            :     {
    1973                 :        706 :       unsigned int width = GET_MODE_PRECISION (result_mode);
    1974                 :        706 :       if (width > MAX_BITSIZE_MODE_ANY_INT)
    1975                 :            :         return 0;
    1976                 :            : 
    1977                 :            :       /* Although the overflow semantics of RTL's FIX and UNSIGNED_FIX
    1978                 :            :          operators are intentionally left unspecified (to ease implementation
    1979                 :            :          by target backends), for consistency, this routine implements the
    1980                 :            :          same semantics for constant folding as used by the middle-end.  */
    1981                 :            : 
    1982                 :            :       /* This was formerly used only for non-IEEE float.
    1983                 :            :          eggert@twinsun.com says it is safe for IEEE also.  */
    1984                 :        706 :       REAL_VALUE_TYPE t;
    1985                 :        706 :       const REAL_VALUE_TYPE *x = CONST_DOUBLE_REAL_VALUE (op);
    1986                 :        706 :       wide_int wmax, wmin;
    1987                 :            :       /* This is part of the abi to real_to_integer, but we check
    1988                 :            :          things before making this call.  */
    1989                 :        706 :       bool fail;
    1990                 :            : 
    1991                 :        706 :       switch (code)
    1992                 :            :         {
    1993                 :        202 :         case FIX:
    1994                 :        202 :           if (REAL_VALUE_ISNAN (*x))
    1995                 :          0 :             return const0_rtx;
    1996                 :            : 
    1997                 :            :           /* Test against the signed upper bound.  */
    1998                 :        202 :           wmax = wi::max_value (width, SIGNED);
    1999                 :        202 :           real_from_integer (&t, VOIDmode, wmax, SIGNED);
    2000                 :        202 :           if (real_less (&t, x))
    2001                 :          0 :             return immed_wide_int_const (wmax, mode);
    2002                 :            : 
    2003                 :            :           /* Test against the signed lower bound.  */
    2004                 :        202 :           wmin = wi::min_value (width, SIGNED);
    2005                 :        202 :           real_from_integer (&t, VOIDmode, wmin, SIGNED);
    2006                 :        202 :           if (real_less (x, &t))
    2007                 :          0 :             return immed_wide_int_const (wmin, mode);
    2008                 :            : 
    2009                 :        202 :           return immed_wide_int_const (real_to_integer (x, &fail, width),
    2010                 :            :                                        mode);
    2011                 :            : 
    2012                 :        504 :         case UNSIGNED_FIX:
    2013                 :        504 :           if (REAL_VALUE_ISNAN (*x) || REAL_VALUE_NEGATIVE (*x))
    2014                 :          0 :             return const0_rtx;
    2015                 :            : 
    2016                 :            :           /* Test against the unsigned upper bound.  */
    2017                 :        504 :           wmax = wi::max_value (width, UNSIGNED);
    2018                 :        504 :           real_from_integer (&t, VOIDmode, wmax, UNSIGNED);
    2019                 :        504 :           if (real_less (&t, x))
    2020                 :          0 :             return immed_wide_int_const (wmax, mode);
    2021                 :            : 
    2022                 :        504 :           return immed_wide_int_const (real_to_integer (x, &fail, width),
    2023                 :            :                                        mode);
    2024                 :            : 
    2025                 :          0 :         default:
    2026                 :          0 :           gcc_unreachable ();
    2027                 :            :         }
    2028                 :            :     }
    2029                 :            : 
    2030                 :            :   /* Handle polynomial integers.  */
    2031                 :            :   else if (CONST_POLY_INT_P (op))
    2032                 :            :     {
    2033                 :            :       poly_wide_int result;
    2034                 :            :       switch (code)
    2035                 :            :         {
    2036                 :            :         case NEG:
    2037                 :            :           result = -const_poly_int_value (op);
    2038                 :            :           break;
    2039                 :            : 
    2040                 :            :         case NOT:
    2041                 :            :           result = ~const_poly_int_value (op);
    2042                 :            :           break;
    2043                 :            : 
    2044                 :            :         default:
    2045                 :            :           return NULL_RTX;
    2046                 :            :         }
    2047                 :            :       return immed_wide_int_const (result, mode);
    2048                 :            :     }
    2049                 :            : 
    2050                 :            :   return NULL_RTX;
    2051                 :            : }
    2052                 :            : 
    2053                 :            : /* Subroutine of simplify_binary_operation to simplify a binary operation
    2054                 :            :    CODE that can commute with byte swapping, with result mode MODE and
    2055                 :            :    operating on OP0 and OP1.  CODE is currently one of AND, IOR or XOR.
    2056                 :            :    Return zero if no simplification or canonicalization is possible.  */
    2057                 :            : 
    2058                 :            : static rtx
    2059                 :   15544000 : simplify_byte_swapping_operation (enum rtx_code code, machine_mode mode,
    2060                 :            :                                   rtx op0, rtx op1)
    2061                 :            : {
    2062                 :   15544000 :   rtx tem;
    2063                 :            : 
    2064                 :            :   /* (op (bswap x) C1)) -> (bswap (op x C2)) with C2 swapped.  */
    2065                 :   15544000 :   if (GET_CODE (op0) == BSWAP && CONST_SCALAR_INT_P (op1))
    2066                 :            :     {
    2067                 :        109 :       tem = simplify_gen_binary (code, mode, XEXP (op0, 0),
    2068                 :            :                                  simplify_gen_unary (BSWAP, mode, op1, mode));
    2069                 :        109 :       return simplify_gen_unary (BSWAP, mode, tem, mode);
    2070                 :            :     }
    2071                 :            : 
    2072                 :            :   /* (op (bswap x) (bswap y)) -> (bswap (op x y)).  */
    2073                 :   15543900 :   if (GET_CODE (op0) == BSWAP && GET_CODE (op1) == BSWAP)
    2074                 :            :     {
    2075                 :          0 :       tem = simplify_gen_binary (code, mode, XEXP (op0, 0), XEXP (op1, 0));
    2076                 :          0 :       return simplify_gen_unary (BSWAP, mode, tem, mode);
    2077                 :            :     }
    2078                 :            : 
    2079                 :            :   return NULL_RTX;
    2080                 :            : }
    2081                 :            : 
    2082                 :            : /* Subroutine of simplify_binary_operation to simplify a commutative,
    2083                 :            :    associative binary operation CODE with result mode MODE, operating
    2084                 :            :    on OP0 and OP1.  CODE is currently one of PLUS, MULT, AND, IOR, XOR,
    2085                 :            :    SMIN, SMAX, UMIN or UMAX.  Return zero if no simplification or
    2086                 :            :    canonicalization is possible.  */
    2087                 :            : 
    2088                 :            : static rtx
    2089                 :   55023400 : simplify_associative_operation (enum rtx_code code, machine_mode mode,
    2090                 :            :                                 rtx op0, rtx op1)
    2091                 :            : {
    2092                 :   55023400 :   rtx tem;
    2093                 :            : 
    2094                 :            :   /* Linearize the operator to the left.  */
    2095                 :   55023400 :   if (GET_CODE (op1) == code)
    2096                 :            :     {
    2097                 :            :       /* "(a op b) op (c op d)" becomes "((a op b) op c) op d)".  */
    2098                 :      15879 :       if (GET_CODE (op0) == code)
    2099                 :            :         {
    2100                 :      11534 :           tem = simplify_gen_binary (code, mode, op0, XEXP (op1, 0));
    2101                 :      11534 :           return simplify_gen_binary (code, mode, tem, XEXP (op1, 1));
    2102                 :            :         }
    2103                 :            : 
    2104                 :            :       /* "a op (b op c)" becomes "(b op c) op a".  */
    2105                 :       4345 :       if (! swap_commutative_operands_p (op1, op0))
    2106                 :       4345 :         return simplify_gen_binary (code, mode, op1, op0);
    2107                 :            : 
    2108                 :   55007600 :       std::swap (op0, op1);
    2109                 :            :     }
    2110                 :            : 
    2111                 :   55007600 :   if (GET_CODE (op0) == code)
    2112                 :            :     {
    2113                 :            :       /* Canonicalize "(x op c) op y" as "(x op y) op c".  */
    2114                 :   17183300 :       if (swap_commutative_operands_p (XEXP (op0, 1), op1))
    2115                 :            :         {
    2116                 :      66922 :           tem = simplify_gen_binary (code, mode, XEXP (op0, 0), op1);
    2117                 :      66922 :           return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
    2118                 :            :         }
    2119                 :            : 
    2120                 :            :       /* Attempt to simplify "(a op b) op c" as "a op (b op c)".  */
    2121                 :   17116400 :       tem = simplify_binary_operation (code, mode, XEXP (op0, 1), op1);
    2122                 :   17116400 :       if (tem != 0)
    2123                 :      14194 :         return simplify_gen_binary (code, mode, XEXP (op0, 0), tem);
    2124                 :            : 
    2125                 :            :       /* Attempt to simplify "(a op b) op c" as "(a op c) op b".  */
    2126                 :   17102200 :       tem = simplify_binary_operation (code, mode, XEXP (op0, 0), op1);
    2127                 :   17102200 :       if (tem != 0)
    2128                 :        889 :         return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
    2129                 :            :     }
    2130                 :            : 
    2131                 :            :   return 0;
    2132                 :            : }
    2133                 :            : 
    2134                 :            : /* Return a mask describing the COMPARISON.  */
    2135                 :            : static int
    2136                 :         64 : comparison_to_mask (enum rtx_code comparison)
    2137                 :            : {
    2138                 :         64 :   switch (comparison)
    2139                 :            :     {
    2140                 :            :     case LT:
    2141                 :            :       return 8;
    2142                 :         27 :     case GT:
    2143                 :         27 :       return 4;
    2144                 :          5 :     case EQ:
    2145                 :          5 :       return 2;
    2146                 :          5 :     case UNORDERED:
    2147                 :          5 :       return 1;
    2148                 :            : 
    2149                 :          0 :     case LTGT:
    2150                 :          0 :       return 12;
    2151                 :          0 :     case LE:
    2152                 :          0 :       return 10;
    2153                 :          0 :     case GE:
    2154                 :          0 :       return 6;
    2155                 :          0 :     case UNLT:
    2156                 :          0 :       return 9;
    2157                 :          0 :     case UNGT:
    2158                 :          0 :       return 5;
    2159                 :          0 :     case UNEQ:
    2160                 :          0 :       return 3;
    2161                 :            : 
    2162                 :          0 :     case ORDERED:
    2163                 :          0 :       return 14;
    2164                 :          0 :     case NE:
    2165                 :          0 :       return 13;
    2166                 :          0 :     case UNLE:
    2167                 :          0 :       return 11;
    2168                 :          0 :     case UNGE:
    2169                 :          0 :       return 7;
    2170                 :            : 
    2171                 :          0 :     default:
    2172                 :          0 :       gcc_unreachable ();
    2173                 :            :     }
    2174                 :            : }
    2175                 :            : 
    2176                 :            : /* Return a comparison corresponding to the MASK.  */
    2177                 :            : static enum rtx_code
    2178                 :         32 : mask_to_comparison (int mask)
    2179                 :            : {
    2180                 :          0 :   switch (mask)
    2181                 :            :     {
    2182                 :            :     case 8:
    2183                 :            :       return LT;
    2184                 :            :     case 4:
    2185                 :            :       return GT;
    2186                 :            :     case 2:
    2187                 :            :       return EQ;
    2188                 :            :     case 1:
    2189                 :            :       return UNORDERED;
    2190                 :            : 
    2191                 :            :     case 12:
    2192                 :            :       return LTGT;
    2193                 :            :     case 10:
    2194                 :            :       return LE;
    2195                 :            :     case 6:
    2196                 :            :       return GE;
    2197                 :            :     case 9:
    2198                 :            :       return UNLT;
    2199                 :            :     case 5:
    2200                 :            :       return UNGT;
    2201                 :            :     case 3:
    2202                 :            :       return UNEQ;
    2203                 :            : 
    2204                 :            :     case 14:
    2205                 :            :       return ORDERED;
    2206                 :            :     case 13:
    2207                 :            :       return NE;
    2208                 :            :     case 11:
    2209                 :            :       return UNLE;
    2210                 :            :     case 7:
    2211                 :            :       return UNGE;
    2212                 :            : 
    2213                 :          0 :     default:
    2214                 :          0 :       gcc_unreachable ();
    2215                 :            :     }
    2216                 :            : }
    2217                 :            : 
    2218                 :            : /* Return true if CODE is valid for comparisons of mode MODE, false
    2219                 :            :    otherwise.
    2220                 :            : 
    2221                 :            :    It is always safe to return false, even if the code was valid for the
    2222                 :            :    given mode as that will merely suppress optimizations.  */
    2223                 :            : 
    2224                 :            : static bool
    2225                 :         32 : comparison_code_valid_for_mode (enum rtx_code code, enum machine_mode mode)
    2226                 :            : {
    2227                 :         32 :   switch (code)
    2228                 :            :     {
    2229                 :            :       /* These are valid for integral, floating and vector modes.  */
    2230                 :          0 :       case NE:
    2231                 :          0 :       case EQ:
    2232                 :          0 :       case GE:
    2233                 :          0 :       case GT:
    2234                 :          0 :       case LE:
    2235                 :          0 :       case LT:
    2236                 :          0 :         return (INTEGRAL_MODE_P (mode)
    2237                 :          0 :                 || FLOAT_MODE_P (mode)
    2238                 :          0 :                 || VECTOR_MODE_P (mode));
    2239                 :            : 
    2240                 :            :       /* These are valid for floating point modes.  */
    2241                 :         32 :       case LTGT:
    2242                 :         32 :       case UNORDERED:
    2243                 :         32 :       case ORDERED:
    2244                 :         32 :       case UNEQ:
    2245                 :         32 :       case UNGE:
    2246                 :         32 :       case UNGT:
    2247                 :         32 :       case UNLE:
    2248                 :         32 :       case UNLT:
    2249                 :         32 :         return FLOAT_MODE_P (mode);
    2250                 :            : 
    2251                 :            :       /* These are filtered out in simplify_logical_operation, but
    2252                 :            :          we check for them too as a matter of safety.   They are valid
    2253                 :            :          for integral and vector modes.  */
    2254                 :          0 :       case GEU:
    2255                 :          0 :       case GTU:
    2256                 :          0 :       case LEU:
    2257                 :          0 :       case LTU:
    2258                 :          0 :         return INTEGRAL_MODE_P (mode) || VECTOR_MODE_P (mode);
    2259                 :            : 
    2260                 :          0 :       default:
    2261                 :          0 :         gcc_unreachable ();
    2262                 :            :     }
    2263                 :            : }
    2264                 :            :                                        
    2265                 :            : /* Simplify a logical operation CODE with result mode MODE, operating on OP0
    2266                 :            :    and OP1, which should be both relational operations.  Return 0 if no such
    2267                 :            :    simplification is possible.  */
    2268                 :            : rtx
    2269                 :    4230900 : simplify_logical_relational_operation (enum rtx_code code, machine_mode mode,
    2270                 :            :                                        rtx op0, rtx op1)
    2271                 :            : {
    2272                 :            :   /* We only handle IOR of two relational operations.  */
    2273                 :    4230900 :   if (code != IOR)
    2274                 :            :     return 0;
    2275                 :            : 
    2276                 :    4230900 :   if (!(COMPARISON_P (op0) && COMPARISON_P (op1)))
    2277                 :            :     return 0;
    2278                 :            : 
    2279                 :       2416 :   if (!(rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
    2280                 :        185 :         && rtx_equal_p (XEXP (op0, 1), XEXP (op1, 1))))
    2281                 :       2199 :     return 0;
    2282                 :            : 
    2283                 :         32 :   enum rtx_code code0 = GET_CODE (op0);
    2284                 :         32 :   enum rtx_code code1 = GET_CODE (op1);
    2285                 :            : 
    2286                 :            :   /* We don't handle unsigned comparisons currently.  */
    2287                 :         32 :   if (code0 == LTU || code0 == GTU || code0 == LEU || code0 == GEU)
    2288                 :            :     return 0;
    2289                 :         32 :   if (code1 == LTU || code1 == GTU || code1 == LEU || code1 == GEU)
    2290                 :            :     return 0;
    2291                 :            : 
    2292                 :         32 :   int mask0 = comparison_to_mask (code0);
    2293                 :         32 :   int mask1 = comparison_to_mask (code1);
    2294                 :            : 
    2295                 :         32 :   int mask = mask0 | mask1;
    2296                 :            : 
    2297                 :         32 :   if (mask == 15)
    2298                 :          0 :     return const_true_rtx;
    2299                 :            : 
    2300                 :         32 :   code = mask_to_comparison (mask);
    2301                 :            : 
    2302                 :            :   /* Many comparison codes are only valid for certain mode classes.  */
    2303                 :         32 :   if (!comparison_code_valid_for_mode (code, mode))
    2304                 :            :     return 0;
    2305                 :            : 
    2306                 :          4 :   op0 = XEXP (op1, 0);
    2307                 :          4 :   op1 = XEXP (op1, 1);
    2308                 :            : 
    2309                 :          4 :   return simplify_gen_relational (code, mode, VOIDmode, op0, op1);
    2310                 :            : }
    2311                 :            : 
    2312                 :            : /* Simplify a binary operation CODE with result mode MODE, operating on OP0
    2313                 :            :    and OP1.  Return 0 if no simplification is possible.
    2314                 :            : 
    2315                 :            :    Don't use this for relational operations such as EQ or LT.
    2316                 :            :    Use simplify_relational_operation instead.  */
    2317                 :            : rtx
    2318                 :  283135000 : simplify_binary_operation (enum rtx_code code, machine_mode mode,
    2319                 :            :                            rtx op0, rtx op1)
    2320                 :            : {
    2321                 :  283135000 :   rtx trueop0, trueop1;
    2322                 :  283135000 :   rtx tem;
    2323                 :            : 
    2324                 :            :   /* Relational operations don't work here.  We must know the mode
    2325                 :            :      of the operands in order to do the comparison correctly.
    2326                 :            :      Assuming a full word can give incorrect results.
    2327                 :            :      Consider comparing 128 with -128 in QImode.  */
    2328                 :  283135000 :   gcc_assert (GET_RTX_CLASS (code) != RTX_COMPARE);
    2329                 :  283135000 :   gcc_assert (GET_RTX_CLASS (code) != RTX_COMM_COMPARE);
    2330                 :            : 
    2331                 :            :   /* Make sure the constant is second.  */
    2332                 :  283135000 :   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
    2333                 :  283135000 :       && swap_commutative_operands_p (op0, op1))
    2334                 :  283135000 :     std::swap (op0, op1);
    2335                 :            : 
    2336                 :  283135000 :   trueop0 = avoid_constant_pool_reference (op0);
    2337                 :  283135000 :   trueop1 = avoid_constant_pool_reference (op1);
    2338                 :            : 
    2339                 :  283135000 :   tem = simplify_const_binary_operation (code, mode, trueop0, trueop1);
    2340                 :  283135000 :   if (tem)
    2341                 :            :     return tem;
    2342                 :  266435000 :   tem = simplify_binary_operation_1 (code, mode, op0, op1, trueop0, trueop1);
    2343                 :            : 
    2344                 :  266435000 :   if (tem)
    2345                 :            :     return tem;
    2346                 :            : 
    2347                 :            :   /* If the above steps did not result in a simplification and op0 or op1
    2348                 :            :      were constant pool references, use the referenced constants directly.  */
    2349                 :  234563000 :   if (trueop0 != op0 || trueop1 != op1)
    2350                 :     389465 :     return simplify_gen_binary (code, mode, trueop0, trueop1);
    2351                 :            : 
    2352                 :            :   return NULL_RTX;
    2353                 :            : }
    2354                 :            : 
    2355                 :            : /* Subroutine of simplify_binary_operation_1 that looks for cases in
    2356                 :            :    which OP0 and OP1 are both vector series or vector duplicates
    2357                 :            :    (which are really just series with a step of 0).  If so, try to
    2358                 :            :    form a new series by applying CODE to the bases and to the steps.
    2359                 :            :    Return null if no simplification is possible.
    2360                 :            : 
    2361                 :            :    MODE is the mode of the operation and is known to be a vector
    2362                 :            :    integer mode.  */
    2363                 :            : 
    2364                 :            : static rtx
    2365                 :     893789 : simplify_binary_operation_series (rtx_code code, machine_mode mode,
    2366                 :            :                                   rtx op0, rtx op1)
    2367                 :            : {
    2368                 :     893789 :   rtx base0, step0;
    2369                 :     893789 :   if (vec_duplicate_p (op0, &base0))
    2370                 :       6446 :     step0 = const0_rtx;
    2371                 :    1774590 :   else if (!vec_series_p (op0, &base0, &step0))
    2372                 :            :     return NULL_RTX;
    2373                 :            : 
    2374                 :       6919 :   rtx base1, step1;
    2375                 :       6919 :   if (vec_duplicate_p (op1, &base1))
    2376                 :        195 :     step1 = const0_rtx;
    2377                 :      13448 :   else if (!vec_series_p (op1, &base1, &step1))
    2378                 :            :     return NULL_RTX;
    2379                 :            : 
    2380                 :            :   /* Only create a new series if we can simplify both parts.  In other
    2381                 :            :      cases this isn't really a simplification, and it's not necessarily
    2382                 :            :      a win to replace a vector operation with a scalar operation.  */
    2383                 :       1322 :   scalar_mode inner_mode = GET_MODE_INNER (mode);
    2384                 :       1322 :   rtx new_base = simplify_binary_operation (code, inner_mode, base0, base1);
    2385                 :       1322 :   if (!new_base)
    2386                 :            :     return NULL_RTX;
    2387                 :            : 
    2388                 :        725 :   rtx new_step = simplify_binary_operation (code, inner_mode, step0, step1);
    2389                 :        725 :   if (!new_step)
    2390                 :            :     return NULL_RTX;
    2391                 :            : 
    2392                 :        725 :   return gen_vec_series (mode, new_base, new_step);
    2393                 :            : }
    2394                 :            : 
    2395                 :            : /* Subroutine of simplify_binary_operation.  Simplify a binary operation
    2396                 :            :    CODE with result mode MODE, operating on OP0 and OP1.  If OP0 and/or
    2397                 :            :    OP1 are constant pool references, TRUEOP0 and TRUEOP1 represent the
    2398                 :            :    actual constants.  */
    2399                 :            : 
    2400                 :            : static rtx
    2401                 :  266435000 : simplify_binary_operation_1 (enum rtx_code code, machine_mode mode,
    2402                 :            :                              rtx op0, rtx op1, rtx trueop0, rtx trueop1)
    2403                 :            : {
    2404                 :  266435000 :   rtx tem, reversed, opleft, opright, elt0, elt1;
    2405                 :  266435000 :   HOST_WIDE_INT val;
    2406                 :  266435000 :   scalar_int_mode int_mode, inner_mode;
    2407                 :  266435000 :   poly_int64 offset;
    2408                 :            : 
    2409                 :            :   /* Even if we can't compute a constant result,
    2410                 :            :      there are some cases worth simplifying.  */
    2411                 :            : 
    2412                 :  266435000 :   switch (code)
    2413                 :            :     {
    2414                 :  128901000 :     case PLUS:
    2415                 :            :       /* Maybe simplify x + 0 to x.  The two expressions are equivalent
    2416                 :            :          when x is NaN, infinite, or finite and nonzero.  They aren't
    2417                 :            :          when x is -0 and the rounding mode is not towards -infinity,
    2418                 :            :          since (-0) + 0 is then 0.  */
    2419                 :  128901000 :       if (!HONOR_SIGNED_ZEROS (mode) && trueop1 == CONST0_RTX (mode))
    2420                 :            :         return op0;
    2421                 :            : 
    2422                 :            :       /* ((-a) + b) -> (b - a) and similarly for (a + (-b)).  These
    2423                 :            :          transformations are safe even for IEEE.  */
    2424                 :  128350000 :       if (GET_CODE (op0) == NEG)
    2425                 :      24208 :         return simplify_gen_binary (MINUS, mode, op1, XEXP (op0, 0));
    2426                 :  128326000 :       else if (GET_CODE (op1) == NEG)
    2427                 :       5171 :         return simplify_gen_binary (MINUS, mode, op0, XEXP (op1, 0));
    2428                 :            : 
    2429                 :            :       /* (~a) + 1 -> -a */
    2430                 :  128321000 :       if (INTEGRAL_MODE_P (mode)
    2431                 :  126582000 :           && GET_CODE (op0) == NOT
    2432                 :     215905 :           && trueop1 == const1_rtx)
    2433                 :       5361 :         return simplify_gen_unary (NEG, mode, XEXP (op0, 0), mode);
    2434                 :            : 
    2435                 :            :       /* Handle both-operands-constant cases.  We can only add
    2436                 :            :          CONST_INTs to constants since the sum of relocatable symbols
    2437                 :            :          can't be handled by most assemblers.  Don't add CONST_INT
    2438                 :            :          to CONST_INT since overflow won't be computed properly if wider
    2439                 :            :          than HOST_BITS_PER_WIDE_INT.  */
    2440                 :            : 
    2441                 :  128315000 :       if ((GET_CODE (op0) == CONST
    2442                 :  128295000 :            || GET_CODE (op0) == SYMBOL_REF
    2443                 :  127020000 :            || GET_CODE (op0) == LABEL_REF)
    2444                 :  129591000 :           && poly_int_rtx_p (op1, &offset))
    2445                 :    1295840 :         return plus_constant (mode, op0, offset);
    2446                 :  127020000 :       else if ((GET_CODE (op1) == CONST
    2447                 :  126317000 :                 || GET_CODE (op1) == SYMBOL_REF
    2448                 :  125075000 :                 || GET_CODE (op1) == LABEL_REF)
    2449                 :  128290000 :                && poly_int_rtx_p (op0, &offset))
    2450                 :          0 :         return plus_constant (mode, op1, offset);
    2451                 :            : 
    2452                 :            :       /* See if this is something like X * C - X or vice versa or
    2453                 :            :          if the multiplication is written as a shift.  If so, we can
    2454                 :            :          distribute and make a new multiply, shift, or maybe just
    2455                 :            :          have X (if C is 2 in the example above).  But don't make
    2456                 :            :          something more expensive than we had before.  */
    2457                 :            : 
    2458                 :  127020000 :       if (is_a <scalar_int_mode> (mode, &int_mode))
    2459                 :            :         {
    2460                 :  124387000 :           rtx lhs = op0, rhs = op1;
    2461                 :            : 
    2462                 :  124387000 :           wide_int coeff0 = wi::one (GET_MODE_PRECISION (int_mode));
    2463                 :  124387000 :           wide_int coeff1 = wi::one (GET_MODE_PRECISION (int_mode));
    2464                 :            : 
    2465                 :  124387000 :           if (GET_CODE (lhs) == NEG)
    2466                 :            :             {
    2467                 :          0 :               coeff0 = wi::minus_one (GET_MODE_PRECISION (int_mode));
    2468                 :          0 :               lhs = XEXP (lhs, 0);
    2469                 :            :             }
    2470                 :  124387000 :           else if (GET_CODE (lhs) == MULT
    2471                 :    3316250 :                    && CONST_SCALAR_INT_P (XEXP (lhs, 1)))
    2472                 :            :             {
    2473                 :    2621690 :               coeff0 = rtx_mode_t (XEXP (lhs, 1), int_mode);
    2474                 :    2621690 :               lhs = XEXP (lhs, 0);
    2475                 :            :             }
    2476                 :  121765000 :           else if (GET_CODE (lhs) == ASHIFT
    2477                 :    7863040 :                    && CONST_INT_P (XEXP (lhs, 1))
    2478                 :    7815080 :                    && INTVAL (XEXP (lhs, 1)) >= 0
    2479                 :  129580000 :                    && INTVAL (XEXP (lhs, 1)) < GET_MODE_PRECISION (int_mode))
    2480                 :            :             {
    2481                 :    7815050 :               coeff0 = wi::set_bit_in_zero (INTVAL (XEXP (lhs, 1)),
    2482                 :    7815050 :                                             GET_MODE_PRECISION (int_mode));
    2483                 :    7815050 :               lhs = XEXP (lhs, 0);
    2484                 :            :             }
    2485                 :            : 
    2486                 :  124387000 :           if (GET_CODE (rhs) == NEG)
    2487                 :            :             {
    2488                 :          0 :               coeff1 = wi::minus_one (GET_MODE_PRECISION (int_mode));
    2489                 :          0 :               rhs = XEXP (rhs, 0);
    2490                 :            :             }
    2491                 :  124387000 :           else if (GET_CODE (rhs) == MULT
    2492                 :     184129 :                    && CONST_INT_P (XEXP (rhs, 1)))
    2493                 :            :             {
    2494                 :      97056 :               coeff1 = rtx_mode_t (XEXP (rhs, 1), int_mode);
    2495                 :      97056 :               rhs = XEXP (rhs, 0);
    2496                 :            :             }
    2497                 :  124290000 :           else if (GET_CODE (rhs) == ASHIFT
    2498                 :     287612 :                    && CONST_INT_P (XEXP (rhs, 1))
    2499                 :     280113 :                    && INTVAL (XEXP (rhs, 1)) >= 0
    2500                 :  124570000 :                    && INTVAL (XEXP (rhs, 1)) < GET_MODE_PRECISION (int_mode))
    2501                 :            :             {
    2502                 :     280108 :               coeff1 = wi::set_bit_in_zero (INTVAL (XEXP (rhs, 1)),
    2503                 :     280108 :                                             GET_MODE_PRECISION (int_mode));
    2504                 :     280108 :               rhs = XEXP (rhs, 0);
    2505                 :            :             }
    2506                 :            : 
    2507                 :  124387000 :           if (rtx_equal_p (lhs, rhs))
    2508                 :            :             {
    2509                 :     638526 :               rtx orig = gen_rtx_PLUS (int_mode, op0, op1);
    2510                 :     638526 :               rtx coeff;
    2511                 :     638526 :               bool speed = optimize_function_for_speed_p (cfun);
    2512                 :            : 
    2513                 :     638526 :               coeff = immed_wide_int_const (coeff0 + coeff1, int_mode);
    2514                 :            : 
    2515                 :     638526 :               tem = simplify_gen_binary (MULT, int_mode, lhs, coeff);
    2516                 :     638526 :               return (set_src_cost (tem, int_mode, speed)
    2517                 :    1165970 :                       <= set_src_cost (orig, int_mode, speed) ? tem : 0);
    2518                 :            :             }
    2519                 :            :         }
    2520                 :            : 
    2521                 :            :       /* (plus (xor X C1) C2) is (xor X (C1^C2)) if C2 is signbit.  */
    2522                 :  126381000 :       if (CONST_SCALAR_INT_P (op1)
    2523                 :  100297000 :           && GET_CODE (op0) == XOR
    2524                 :      10562 :           && CONST_SCALAR_INT_P (XEXP (op0, 1))
    2525                 :  126383000 :           && mode_signbit_p (mode, op1))
    2526                 :        121 :         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
    2527                 :            :                                     simplify_gen_binary (XOR, mode, op1,
    2528                 :        121 :                                                          XEXP (op0, 1)));
    2529                 :            : 
    2530                 :            :       /* Canonicalize (plus (mult (neg B) C) A) to (minus A (mult B C)).  */
    2531                 :  126381000 :       if (!HONOR_SIGN_DEPENDENT_ROUNDING (mode)
    2532                 :  126380000 :           && GET_CODE (op0) == MULT
    2533                 :  129992000 :           && GET_CODE (XEXP (op0, 0)) == NEG)
    2534                 :            :         {
    2535                 :        948 :           rtx in1, in2;
    2536                 :            : 
    2537                 :        948 :           in1 = XEXP (XEXP (op0, 0), 0);
    2538                 :        948 :           in2 = XEXP (op0, 1);
    2539                 :        948 :           return simplify_gen_binary (MINUS, mode, op1,
    2540                 :            :                                       simplify_gen_binary (MULT, mode,
    2541                 :        948 :                                                            in1, in2));
    2542                 :            :         }
    2543                 :            : 
    2544                 :            :       /* (plus (comparison A B) C) can become (neg (rev-comp A B)) if
    2545                 :            :          C is 1 and STORE_FLAG_VALUE is -1 or if C is -1 and STORE_FLAG_VALUE
    2546                 :            :          is 1.  */
    2547                 :  126380000 :       if (COMPARISON_P (op0)
    2548                 :     882829 :           && ((STORE_FLAG_VALUE == -1 && trueop1 == const1_rtx)
    2549                 :     882829 :               || (STORE_FLAG_VALUE == 1 && trueop1 == constm1_rtx))
    2550                 :  126387000 :           && (reversed = reversed_comparison (op0, mode)))
    2551                 :       7020 :         return
    2552                 :       7020 :           simplify_gen_unary (NEG, mode, reversed, mode);
    2553                 :            : 
    2554                 :            :       /* If one of the operands is a PLUS or a MINUS, see if we can
    2555                 :            :          simplify this by the associative law.
    2556                 :            :          Don't use the associative law for floating point.
    2557                 :            :          The inaccuracy makes it nonassociative,
    2558                 :            :          and subtle programs can break if operations are associated.  */
    2559                 :            : 
    2560                 :    2632210 :       if (INTEGRAL_MODE_P (mode)
    2561                 :  124635000 :           && (plus_minus_operand_p (op0)
    2562                 :  105572000 :               || plus_minus_operand_p (op1))
    2563                 :  145998000 :           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
    2564                 :            :         return tem;
    2565                 :            : 
    2566                 :            :       /* Reassociate floating point addition only when the user
    2567                 :            :          specifies associative math operations.  */
    2568                 :  107200000 :       if (FLOAT_MODE_P (mode)
    2569                 :    1738390 :           && flag_associative_math)
    2570                 :            :         {
    2571                 :     695639 :           tem = simplify_associative_operation (code, mode, op0, op1);
    2572                 :     695639 :           if (tem)
    2573                 :            :             return tem;
    2574                 :            :         }
    2575                 :            : 
    2576                 :            :       /* Handle vector series.  */
    2577                 :  107185000 :       if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
    2578                 :            :         {
    2579                 :     815778 :           tem = simplify_binary_operation_series (code, mode, op0, op1);
    2580                 :     815778 :           if (tem)
    2581                 :            :             return tem;
    2582                 :            :         }
    2583                 :            :       break;
    2584                 :            : 
    2585                 :   26113100 :     case COMPARE:
    2586                 :            :       /* Convert (compare (gt (flags) 0) (lt (flags) 0)) to (flags).  */
    2587                 :   26113100 :       if (((GET_CODE (op0) == GT && GET_CODE (op1) == LT)
    2588                 :   26113100 :            || (GET_CODE (op0) == GTU && GET_CODE (op1) == LTU))
    2589                 :         13 :           && XEXP (op0, 1) == const0_rtx && XEXP (op1, 1) == const0_rtx)
    2590                 :            :         {
    2591                 :          9 :           rtx xop00 = XEXP (op0, 0);
    2592                 :          9 :           rtx xop10 = XEXP (op1, 0);
    2593                 :            : 
    2594                 :          9 :           if (GET_CODE (xop00) == CC0 && GET_CODE (xop10) == CC0)
    2595                 :            :               return xop00;
    2596                 :            : 
    2597                 :          9 :             if (REG_P (xop00) && REG_P (xop10)
    2598                 :          9 :                 && REGNO (xop00) == REGNO (xop10)
    2599                 :          9 :                 && GET_MODE (xop00) == mode
    2600                 :          0 :                 && GET_MODE (xop10) == mode
    2601                 :          9 :                 && GET_MODE_CLASS (mode) == MODE_CC)
    2602                 :            :               return xop00;
    2603                 :            :         }
    2604                 :            :       break;
    2605                 :            : 
    2606                 :   28349700 :     case MINUS:
    2607                 :            :       /* We can't assume x-x is 0 even with non-IEEE floating point,
    2608                 :            :          but since it is zero except in very strange circumstances, we
    2609                 :            :          will treat it as zero with -ffinite-math-only.  */
    2610                 :   28349700 :       if (rtx_equal_p (trueop0, trueop1)
    2611                 :      33704 :           && ! side_effects_p (op0)
    2612                 :   28383200 :           && (!FLOAT_MODE_P (mode) || !HONOR_NANS (mode)))
    2613                 :      32126 :         return CONST0_RTX (mode);
    2614                 :            : 
    2615                 :            :       /* Change subtraction from zero into negation.  (0 - x) is the
    2616                 :            :          same as -x when x is NaN, infinite, or finite and nonzero.
    2617                 :            :          But if the mode has signed zeros, and does not round towards
    2618                 :            :          -infinity, then 0 - 0 is 0, not -0.  */
    2619                 :   28317600 :       if (!HONOR_SIGNED_ZEROS (mode) && trueop0 == CONST0_RTX (mode))
    2620                 :      84864 :         return simplify_gen_unary (NEG, mode, op1, mode);
    2621                 :            : 
    2622                 :            :       /* (-1 - a) is ~a, unless the expression contains symbolic
    2623                 :            :          constants, in which case not retaining additions and
    2624                 :            :          subtractions could cause invalid assembly to be produced.  */
    2625                 :   28232700 :       if (trueop0 == constm1_rtx
    2626                 :   28232700 :           && !contains_symbolic_reference_p (op1))
    2627                 :     109334 :         return simplify_gen_unary (NOT, mode, op1, mode);
    2628                 :            : 
    2629                 :            :       /* Subtracting 0 has no effect unless the mode has signed zeros
    2630                 :            :          and supports rounding towards -infinity.  In such a case,
    2631                 :            :          0 - 0 is -0.  */
    2632                 :   28781000 :       if (!(HONOR_SIGNED_ZEROS (mode)
    2633                 :     657569 :             && HONOR_SIGN_DEPENDENT_ROUNDING (mode))
    2634                 :   28780400 :           && trueop1 == CONST0_RTX (mode))
    2635                 :            :         return op0;
    2636                 :            : 
    2637                 :            :       /* See if this is something like X * C - X or vice versa or
    2638                 :            :          if the multiplication is written as a shift.  If so, we can
    2639                 :            :          distribute and make a new multiply, shift, or maybe just
    2640                 :            :          have X (if C is 2 in the example above).  But don't make
    2641                 :            :          something more expensive than we had before.  */
    2642                 :            : 
    2643                 :   27827600 :       if (is_a <scalar_int_mode> (mode, &int_mode))
    2644                 :            :         {
    2645                 :   27011400 :           rtx lhs = op0, rhs = op1;
    2646                 :            : 
    2647                 :   27011400 :           wide_int coeff0 = wi::one (GET_MODE_PRECISION (int_mode));
    2648                 :   27011400 :           wide_int negcoeff1 = wi::minus_one (GET_MODE_PRECISION (int_mode));
    2649                 :            : 
    2650                 :   27011400 :           if (GET_CODE (lhs) == NEG)
    2651                 :            :             {
    2652                 :      78978 :               coeff0 = wi::minus_one (GET_MODE_PRECISION (int_mode));
    2653                 :      78978 :               lhs = XEXP (lhs, 0);
    2654                 :            :             }
    2655                 :   26932400 :           else if (GET_CODE (lhs) == MULT
    2656                 :     179499 :                    && CONST_SCALAR_INT_P (XEXP (lhs, 1)))
    2657                 :            :             {
    2658                 :      84033 :               coeff0 = rtx_mode_t (XEXP (lhs, 1), int_mode);
    2659                 :      84033 :               lhs = XEXP (lhs, 0);
    2660                 :            :             }
    2661                 :   26848400 :           else if (GET_CODE (lhs) == ASHIFT
    2662                 :     200034 :                    && CONST_INT_P (XEXP (lhs, 1))
    2663                 :     198773 :                    && INTVAL (XEXP (lhs, 1)) >= 0
    2664                 :   27047200 :                    && INTVAL (XEXP (lhs, 1)) < GET_MODE_PRECISION (int_mode))
    2665                 :            :             {
    2666                 :     198773 :               coeff0 = wi::set_bit_in_zero (INTVAL (XEXP (lhs, 1)),
    2667                 :     198773 :                                             GET_MODE_PRECISION (int_mode));
    2668                 :     198773 :               lhs = XEXP (lhs, 0);
    2669                 :            :             }
    2670                 :            : 
    2671                 :   27011400 :           if (GET_CODE (rhs) == NEG)
    2672                 :            :             {
    2673                 :       6833 :               negcoeff1 = wi::one (GET_MODE_PRECISION (int_mode));
    2674                 :       6833 :               rhs = XEXP (rhs, 0);
    2675                 :            :             }
    2676                 :   27004600 :           else if (GET_CODE (rhs) == MULT
    2677                 :      62600 :                    && CONST_INT_P (XEXP (rhs, 1)))
    2678                 :            :             {
    2679                 :      50785 :               negcoeff1 = wi::neg (rtx_mode_t (XEXP (rhs, 1), int_mode));
    2680                 :      50785 :               rhs = XEXP (rhs, 0);
    2681                 :            :             }
    2682                 :   26953800 :           else if (GET_CODE (rhs) == ASHIFT
    2683                 :     215221 :                    && CONST_INT_P (XEXP (rhs, 1))
    2684                 :     214383 :                    && INTVAL (XEXP (rhs, 1)) >= 0
    2685                 :   27168200 :                    && INTVAL (XEXP (rhs, 1)) < GET_MODE_PRECISION (int_mode))
    2686                 :            :             {
    2687                 :     214383 :               negcoeff1 = wi::set_bit_in_zero (INTVAL (XEXP (rhs, 1)),
    2688                 :     214383 :                                                GET_MODE_PRECISION (int_mode));
    2689                 :     214383 :               negcoeff1 = -negcoeff1;
    2690                 :     214383 :               rhs = XEXP (rhs, 0);
    2691                 :            :             }
    2692                 :            : 
    2693                 :   27011400 :           if (rtx_equal_p (lhs, rhs))
    2694                 :            :             {
    2695                 :      79769 :               rtx orig = gen_rtx_MINUS (int_mode, op0, op1);
    2696                 :      79769 :               rtx coeff;
    2697                 :      79769 :               bool speed = optimize_function_for_speed_p (cfun);
    2698                 :            : 
    2699                 :      79769 :               coeff = immed_wide_int_const (coeff0 + negcoeff1, int_mode);
    2700                 :            : 
    2701                 :      79769 :               tem = simplify_gen_binary (MULT, int_mode, lhs, coeff);
    2702                 :      79769 :               return (set_src_cost (tem, int_mode, speed)
    2703                 :     153716 :                       <= set_src_cost (orig, int_mode, speed) ? tem : 0);
    2704                 :            :             }
    2705                 :            :         }
    2706                 :            : 
    2707                 :            :       /* (a - (-b)) -> (a + b).  True even for IEEE.  */
    2708                 :   27747800 :       if (GET_CODE (op1) == NEG)
    2709                 :       6591 :         return simplify_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
    2710                 :            : 
    2711                 :            :       /* (-x - c) may be simplified as (-c - x).  */
    2712                 :   27741200 :       if (GET_CODE (op0) == NEG
    2713                 :      80923 :           && (CONST_SCALAR_INT_P (op1) || CONST_DOUBLE_AS_FLOAT_P (op1)))
    2714                 :            :         {
    2715                 :        747 :           tem = simplify_unary_operation (NEG, mode, op1, mode);
    2716                 :        747 :           if (tem)
    2717                 :        747 :             return simplify_gen_binary (MINUS, mode, tem, XEXP (op0, 0));
    2718                 :            :         }
    2719                 :            : 
    2720                 :   27740500 :       if ((GET_CODE (op0) == CONST
    2721                 :   27716800 :            || GET_CODE (op0) == SYMBOL_REF
    2722                 :   16918400 :            || GET_CODE (op0) == LABEL_REF)
    2723                 :   38539600 :           && poly_int_rtx_p (op1, &offset))
    2724                 :      10694 :         return plus_constant (mode, op0, trunc_int_for_mode (-offset, mode));
    2725                 :            : 
    2726                 :            :       /* Don't let a relocatable value get a negative coeff.  */
    2727                 :   27729800 :       if (poly_int_rtx_p (op1) && GET_MODE (op0) != VOIDmode)
    2728                 :    3937570 :         return simplify_gen_binary (PLUS, mode,
    2729                 :            :                                     op0,
    2730                 :    3937570 :                                     neg_poly_int_rtx (mode, op1));
    2731                 :            : 
    2732                 :            :       /* (x - (x & y)) -> (x & ~y) */
    2733                 :   23792200 :       if (INTEGRAL_MODE_P (mode) && GET_CODE (op1) == AND)
    2734                 :            :         {
    2735                 :     171219 :           if (rtx_equal_p (op0, XEXP (op1, 0)))
    2736                 :            :             {
    2737                 :       4546 :               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 1),
    2738                 :       2273 :                                         GET_MODE (XEXP (op1, 1)));
    2739                 :       2273 :               return simplify_gen_binary (AND, mode, op0, tem);
    2740                 :            :             }
    2741                 :     168946 :           if (rtx_equal_p (op0, XEXP (op1, 1)))
    2742                 :            :             {
    2743                 :       4494 :               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 0),
    2744                 :       2247 :                                         GET_MODE (XEXP (op1, 0)));
    2745                 :       2247 :               return simplify_gen_binary (AND, mode, op0, tem);
    2746                 :            :             }
    2747                 :            :         }
    2748                 :            : 
    2749                 :            :       /* If STORE_FLAG_VALUE is 1, (minus 1 (comparison foo bar)) can be done
    2750                 :            :          by reversing the comparison code if valid.  */
    2751                 :   23787700 :       if (STORE_FLAG_VALUE == 1
    2752                 :   23787700 :           && trueop0 == const1_rtx
    2753                 :     617804 :           && COMPARISON_P (op1)
    2754                 :   23812800 :           && (reversed = reversed_comparison (op1, mode)))
    2755                 :            :         return reversed;
    2756                 :            : 
    2757                 :            :       /* Canonicalize (minus A (mult (neg B) C)) to (plus (mult B C) A).  */
    2758                 :   23762600 :       if (!HONOR_SIGN_DEPENDENT_ROUNDING (mode)
    2759                 :   23762000 :           && GET_CODE (op1) == MULT
    2760                 :   23919200 :           && GET_CODE (XEXP (op1, 0)) == NEG)
    2761                 :            :         {
    2762                 :        170 :           rtx in1, in2;
    2763                 :            : 
    2764                 :        170 :           in1 = XEXP (XEXP (op1, 0), 0);
    2765                 :        170 :           in2 = XEXP (op1, 1);
    2766                 :        170 :           return simplify_gen_binary (PLUS, mode,
    2767                 :            :                                       simplify_gen_binary (MULT, mode,
    2768                 :            :                                                            in1, in2),
    2769                 :        170 :                                       op0);
    2770                 :            :         }
    2771                 :            : 
    2772                 :            :       /* Canonicalize (minus (neg A) (mult B C)) to
    2773                 :            :          (minus (mult (neg B) C) A).  */
    2774                 :   23762400 :       if (!HONOR_SIGN_DEPENDENT_ROUNDING (mode)
    2775                 :   23761800 :           && GET_CODE (op1) == MULT
    2776                 :   23918800 :           && GET_CODE (op0) == NEG)
    2777                 :            :         {
    2778                 :        359 :           rtx in1, in2;
    2779                 :            : 
    2780                 :        359 :           in1 = simplify_gen_unary (NEG, mode, XEXP (op1, 0), mode);
    2781                 :        359 :           in2 = XEXP (op1, 1);
    2782                 :        359 :           return simplify_gen_binary (MINUS, mode,
    2783                 :            :                                       simplify_gen_binary (MULT, mode,
    2784                 :            :                                                            in1, in2),
    2785                 :        359 :                                       XEXP (op0, 0));
    2786                 :            :         }
    2787                 :            : 
    2788                 :            :       /* If one of the operands is a PLUS or a MINUS, see if we can
    2789                 :            :          simplify this by the associative law.  This will, for example,
    2790                 :            :          canonicalize (minus A (plus B C)) to (minus (minus A B) C).
    2791                 :            :          Don't use the associative law for floating point.
    2792                 :            :          The inaccuracy makes it nonassociative,
    2793                 :            :          and subtle programs can break if operations are associated.  */
    2794                 :            : 
    2795                 :     815771 :       if (INTEGRAL_MODE_P (mode)
    2796                 :   23028800 :           && (plus_minus_operand_p (op0)
    2797                 :   21935300 :               || plus_minus_operand_p (op1))
    2798                 :   25124200 :           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
    2799                 :            :         return tem;
    2800                 :            : 
    2801                 :            :       /* Handle vector series.  */
    2802                 :   22468000 :       if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
    2803                 :            :         {
    2804                 :      78011 :           tem = simplify_binary_operation_series (code, mode, op0, op1);
    2805                 :      78011 :           if (tem)
    2806                 :            :             return tem;
    2807                 :            :         }
    2808                 :            :       break;
    2809                 :            : 
    2810                 :   41653600 :     case MULT:
    2811                 :   41653600 :       if (trueop1 == constm1_rtx)
    2812                 :      37271 :         return simplify_gen_unary (NEG, mode, op0, mode);
    2813                 :            : 
    2814                 :   41616300 :       if (GET_CODE (op0) == NEG)
    2815                 :            :         {
    2816                 :      37269 :           rtx temp = simplify_unary_operation (NEG, mode, op1, mode);
    2817                 :            :           /* If op1 is a MULT as well and simplify_unary_operation
    2818                 :            :              just moved the NEG to the second operand, simplify_gen_binary
    2819                 :            :              below could through simplify_associative_operation move
    2820                 :            :              the NEG around again and recurse endlessly.  */
    2821                 :      37269 :           if (temp
    2822                 :        834 :               && GET_CODE (op1) == MULT
    2823                 :          0 :               && GET_CODE (temp) == MULT
    2824                 :          0 :               && XEXP (op1, 0) == XEXP (temp, 0)
    2825                 :          0 :               && GET_CODE (XEXP (temp, 1)) == NEG
    2826                 :          0 :               && XEXP (op1, 1) == XEXP (XEXP (temp, 1), 0))
    2827                 :            :             temp = NULL_RTX;
    2828                 :      37269 :           if (temp)
    2829                 :        834 :             return simplify_gen_binary (MULT, mode, XEXP (op0, 0), temp);
    2830                 :            :         }
    2831                 :   41615500 :       if (GET_CODE (op1) == NEG)
    2832                 :            :         {
    2833                 :        892 :           rtx temp = simplify_unary_operation (NEG, mode, op0, mode);
    2834                 :            :           /* If op0 is a MULT as well and simplify_unary_operation
    2835                 :            :              just moved the NEG to the second operand, simplify_gen_binary
    2836                 :            :              below could through simplify_associative_operation move
    2837                 :            :              the NEG around again and recurse endlessly.  */
    2838                 :        892 :           if (temp
    2839                 :        305 :               && GET_CODE (op0) == MULT
    2840                 :        244 :               && GET_CODE (temp) == MULT
    2841                 :        244 :               && XEXP (op0, 0) == XEXP (temp, 0)
    2842                 :          1 :               && GET_CODE (XEXP (temp, 1)) == NEG
    2843                 :          1 :               && XEXP (op0, 1) == XEXP (XEXP (temp, 1), 0))
    2844                 :            :             temp = NULL_RTX;
    2845                 :        891 :           if (temp)
    2846                 :        304 :             return simplify_gen_binary (MULT, mode, temp, XEXP (op1, 0));
    2847                 :            :         }
    2848                 :            : 
    2849                 :            :       /* Maybe simplify x * 0 to 0.  The reduction is not valid if
    2850                 :            :          x is NaN, since x * 0 is then also NaN.  Nor is it valid
    2851                 :            :          when the mode has signed zeros, since multiplying a negative
    2852                 :            :          number by 0 will give -0, not 0.  */
    2853                 :   41615200 :       if (!HONOR_NANS (mode)
    2854                 :   40765800 :           && !HONOR_SIGNED_ZEROS (mode)
    2855                 :   40765800 :           && trueop1 == CONST0_RTX (mode)
    2856                 :   41672000 :           && ! side_effects_p (op0))
    2857                 :            :         return op1;
    2858                 :            : 
    2859                 :            :       /* In IEEE floating point, x*1 is not equivalent to x for
    2860                 :            :          signalling NaNs.  */
    2861                 :   41558600 :       if (!HONOR_SNANS (mode)
    2862                 :   41558600 :           && trueop1 == CONST1_RTX (mode))
    2863                 :            :         return op0;
    2864                 :            : 
    2865                 :            :       /* Convert multiply by constant power of two into shift.  */
    2866                 :   41452500 :       if (CONST_SCALAR_INT_P (trueop1))
    2867                 :            :         {
    2868                 :    4513610 :           val = wi::exact_log2 (rtx_mode_t (trueop1, mode));
    2869                 :    4513610 :           if (val >= 0)
    2870                 :    2211000 :             return simplify_gen_binary (ASHIFT, mode, op0,
    2871                 :            :                                         gen_int_shift_amount (mode, val));
    2872                 :            :         }
    2873                 :            : 
    2874                 :            :       /* x*2 is x+x and x*(-1) is -x */
    2875                 :   39241500 :       if (CONST_DOUBLE_AS_FLOAT_P (trueop1)
    2876                 :     117983 :           && SCALAR_FLOAT_MODE_P (GET_MODE (trueop1))
    2877                 :     117983 :           && !DECIMAL_FLOAT_MODE_P (GET_MODE (trueop1))
    2878                 :     117465 :           && GET_MODE (op0) == mode)
    2879                 :            :         {
    2880                 :     117465 :           const REAL_VALUE_TYPE *d1 = CONST_DOUBLE_REAL_VALUE (trueop1);
    2881                 :            : 
    2882                 :     117465 :           if (real_equal (d1, &dconst2))
    2883                 :        452 :             return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
    2884                 :            : 
    2885                 :     117013 :           if (!HONOR_SNANS (mode)
    2886                 :     117013 :               && real_equal (d1, &dconstm1))
    2887                 :         23 :             return simplify_gen_unary (NEG, mode, op0, mode);
    2888                 :            :         }
    2889                 :            : 
    2890                 :            :       /* Optimize -x * -x as x * x.  */
    2891                 :   38170900 :       if (FLOAT_MODE_P (mode)
    2892                 :    1266430 :           && GET_CODE (op0) == NEG
    2893                 :      26133 :           && GET_CODE (op1) == NEG
    2894                 :          0 :           && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
    2895                 :   39241100 :           && !side_effects_p (XEXP (op0, 0)))
    2896                 :          0 :         return simplify_gen_binary (MULT, mode, XEXP (op0, 0), XEXP (op1, 0));
    2897                 :            : 
    2898                 :            :       /* Likewise, optimize abs(x) * abs(x) as x * x.  */
    2899                 :   39241100 :       if (SCALAR_FLOAT_MODE_P (mode)
    2900                 :    1070190 :           && GET_CODE (op0) == ABS
    2901                 :        792 :           && GET_CODE (op1) == ABS
    2902                 :          0 :           && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
    2903                 :   39241100 :           && !side_effects_p (XEXP (op0, 0)))
    2904                 :          0 :         return simplify_gen_binary (MULT, mode, XEXP (op0, 0), XEXP (op1, 0));
    2905                 :            : 
    2906                 :            :       /* Reassociate multiplication, but for floating point MULTs
    2907                 :            :          only when the user specifies unsafe math optimizations.  */
    2908                 :   39241100 :       if (! FLOAT_MODE_P (mode)
    2909                 :    1266430 :           || flag_unsafe_math_optimizations)
    2910                 :            :         {
    2911                 :   38392600 :           tem = simplify_associative_operation (code, mode, op0, op1);
    2912                 :   38392600 :           if (tem)
    2913                 :            :             return tem;
    2914                 :            :         }
    2915                 :            :       break;
    2916                 :            : 
    2917                 :    4639960 :     case IOR:
    2918                 :    4639960 :       if (trueop1 == CONST0_RTX (mode))
    2919                 :            :         return op0;
    2920                 :     184257 :       if (INTEGRAL_MODE_P (mode)
    2921                 :    4403380 :           && trueop1 == CONSTM1_RTX (mode)
    2922                 :    4419250 :           && !side_effects_p (op0))
    2923                 :            :         return op1;
    2924                 :    4414500 :       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
    2925                 :            :         return op0;
    2926                 :            :       /* A | (~A) -> -1 */
    2927                 :      39945 :       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
    2928                 :    4414390 :            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
    2929                 :         14 :           && ! side_effects_p (op0)
    2930                 :    4414420 :           && SCALAR_INT_MODE_P (mode))
    2931                 :          3 :         return constm1_rtx;
    2932                 :            : 
    2933                 :            :       /* (ior A C) is C if all bits of A that might be nonzero are on in C.  */
    2934                 :    4414400 :       if (CONST_INT_P (op1)
    2935                 :    1256370 :           && HWI_COMPUTABLE_MODE_P (mode)
    2936                 :    1256370 :           && (nonzero_bits (op0, mode) & ~UINTVAL (op1)) == 0
    2937                 :    4521100 :           && !side_effects_p (op0))
    2938                 :            :         return op1;
    2939                 :            : 
    2940                 :            :       /* Canonicalize (X & C1) | C2.  */
    2941                 :    4307710 :       if (GET_CODE (op0) == AND
    2942                 :    1101180 :           && CONST_INT_P (trueop1)
    2943                 :     253256 :           && CONST_INT_P (XEXP (op0, 1)))
    2944                 :            :         {
    2945                 :     237933 :           HOST_WIDE_INT mask = GET_MODE_MASK (mode);
    2946                 :     237933 :           HOST_WIDE_INT c1 = INTVAL (XEXP (op0, 1));
    2947                 :     237933 :           HOST_WIDE_INT c2 = INTVAL (trueop1);
    2948                 :            : 
    2949                 :            :           /* If (C1&C2) == C1, then (X&C1)|C2 becomes C2.  */
    2950                 :     237933 :           if ((c1 & c2) == c1
    2951                 :     237933 :               && !side_effects_p (XEXP (op0, 0)))
    2952                 :            :             return trueop1;
    2953                 :            : 
    2954                 :            :           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
    2955                 :     237933 :           if (((c1|c2) & mask) == mask)
    2956                 :      49326 :             return simplify_gen_binary (IOR, mode, XEXP (op0, 0), op1);
    2957                 :            :         }
    2958                 :            : 
    2959                 :            :       /* Convert (A & B) | A to A.  */
    2960                 :    4258380 :       if (GET_CODE (op0) == AND
    2961                 :    1051860 :           && (rtx_equal_p (XEXP (op0, 0), op1)
    2962                 :    1051800 :               || rtx_equal_p (XEXP (op0, 1), op1))
    2963                 :         59 :           && ! side_effects_p (XEXP (op0, 0))
    2964                 :    4258440 :           && ! side_effects_p (XEXP (op0, 1)))
    2965                 :            :         return op1;
    2966                 :            : 
    2967                 :            :       /* Convert (ior (ashift A CX) (lshiftrt A CY)) where CX+CY equals the
    2968                 :            :          mode size to (rotate A CX).  */
    2969                 :            : 
    2970                 :    4258320 :       if (GET_CODE (op1) == ASHIFT
    2971                 :    4142000 :           || GET_CODE (op1) == SUBREG)
    2972                 :            :         {
    2973                 :            :           opleft = op1;
    2974                 :            :           opright = op0;
    2975                 :            :         }
    2976                 :            :       else
    2977                 :            :         {
    2978                 :    3733700 :           opright = op1;
    2979                 :    3733700 :           opleft = op0;
    2980                 :            :         }
    2981                 :            : 
    2982                 :     450374 :       if (GET_CODE (opleft) == ASHIFT && GET_CODE (opright) == LSHIFTRT
    2983                 :       7702 :           && rtx_equal_p (XEXP (opleft, 0), XEXP (opright, 0))
    2984                 :       1197 :           && CONST_INT_P (XEXP (opleft, 1))
    2985                 :        631 :           && CONST_INT_P (XEXP (opright, 1))
    2986                 :    4258320 :           && (INTVAL (XEXP (opleft, 1)) + INTVAL (XEXP (opright, 1))
    2987                 :       1262 :               == GET_MODE_UNIT_PRECISION (mode)))
    2988                 :        422 :         return gen_rtx_ROTATE (mode, XEXP (opright, 0), XEXP (opleft, 1));
    2989                 :            : 
    2990                 :            :       /* Same, but for ashift that has been "simplified" to a wider mode
    2991                 :            :         by simplify_shift_const.  */
    2992                 :            : 
    2993                 :    4257900 :       if (GET_CODE (opleft) == SUBREG
    2994                 :     484273 :           && is_a <scalar_int_mode> (mode, &int_mode)
    2995                 :     467465 :           && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (opleft)),
    2996                 :            :                                      &inner_mode)
    2997                 :     464511 :           && GET_CODE (SUBREG_REG (opleft)) == ASHIFT
    2998                 :      27465 :           && GET_CODE (opright) == LSHIFTRT
    2999                 :        107 :           && GET_CODE (XEXP (opright, 0)) == SUBREG
    3000                 :         73 :           && known_eq (SUBREG_BYTE (opleft), SUBREG_BYTE (XEXP (opright, 0)))
    3001                 :        146 :           && GET_MODE_SIZE (int_mode) < GET_MODE_SIZE (inner_mode)
    3002                 :         73 :           && rtx_equal_p (XEXP (SUBREG_REG (opleft), 0),
    3003                 :         73 :                           SUBREG_REG (XEXP (opright, 0)))
    3004                 :         15 :           && CONST_INT_P (XEXP (SUBREG_REG (opleft), 1))
    3005                 :         15 :           && CONST_INT_P (XEXP (opright, 1))
    3006                 :    4257900 :           && (INTVAL (XEXP (SUBREG_REG (opleft), 1))
    3007                 :         15 :               + INTVAL (XEXP (opright, 1))
    3008                 :         15 :               == GET_MODE_PRECISION (int_mode)))
    3009                 :         10 :         return gen_rtx_ROTATE (int_mode, XEXP (opright, 0),
    3010                 :            :                                XEXP (SUBREG_REG (opleft), 1));
    3011                 :            : 
    3012                 :            :       /* If OP0 is (ashiftrt (plus ...) C), it might actually be
    3013                 :            :          a (sign_extend (plus ...)).  Then check if OP1 is a CONST_INT and
    3014                 :            :          the PLUS does not affect any of the bits in OP1: then we can do
    3015                 :            :          the IOR as a PLUS and we can associate.  This is valid if OP1
    3016                 :            :          can be safely shifted left C bits.  */
    3017                 :    4257890 :       if (CONST_INT_P (trueop1) && GET_CODE (op0) == ASHIFTRT
    3018                 :       6715 :           && GET_CODE (XEXP (op0, 0)) == PLUS
    3019                 :        158 :           && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
    3020                 :        104 :           && CONST_INT_P (XEXP (op0, 1))
    3021                 :        104 :           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT)
    3022                 :            :         {
    3023                 :        104 :           int count = INTVAL (XEXP (op0, 1));
    3024                 :        104 :           HOST_WIDE_INT mask = UINTVAL (trueop1) << count;
    3025                 :            : 
    3026                 :        104 :           if (mask >> count == INTVAL (trueop1)
    3027                 :         97 :               && trunc_int_for_mode (mask, mode) == mask
    3028                 :        195 :               && (mask & nonzero_bits (XEXP (op0, 0), mode)) == 0)
    3029                 :          0 :             return simplify_gen_binary (ASHIFTRT, mode,
    3030                 :            :                                         plus_constant (mode, XEXP (op0, 0),
    3031                 :            :                                                        mask),
    3032                 :            :                                         XEXP (op0, 1));
    3033                 :            :         }
    3034                 :            : 
    3035                 :            :       /* The following happens with bitfield merging.
    3036                 :            :          (X & C) | ((X | Y) & ~C) -> X | (Y & ~C) */
    3037                 :    4257890 :       if (GET_CODE (op0) == AND
    3038                 :    1051800 :           && GET_CODE (op1) == AND
    3039                 :     101110 :           && CONST_INT_P (XEXP (op0, 1))
    3040                 :      72288 :           && CONST_INT_P (XEXP (op1, 1))
    3041                 :      70095 :           && (INTVAL (XEXP (op0, 1))
    3042                 :      70095 :               == ~INTVAL (XEXP (op1, 1))))
    3043                 :            :         {
    3044                 :            :           /* The IOR may be on both sides.  */
    3045                 :      28118 :           rtx top0 = NULL_RTX, top1 = NULL_RTX;
    3046                 :      28118 :           if (GET_CODE (XEXP (op1, 0)) == IOR)
    3047                 :            :             top0 = op0, top1 = op1;
    3048                 :      28072 :           else if (GET_CODE (XEXP (op0, 0)) == IOR)
    3049                 :          0 :             top0 = op1, top1 = op0;
    3050                 :      28118 :           if (top0 && top1)
    3051                 :            :             {
    3052                 :            :               /* X may be on either side of the inner IOR.  */
    3053                 :         46 :               rtx tem = NULL_RTX;
    3054                 :         46 :               if (rtx_equal_p (XEXP (top0, 0),
    3055                 :         46 :                                XEXP (XEXP (top1, 0), 0)))
    3056                 :         35 :                 tem = XEXP (XEXP (top1, 0), 1);
    3057                 :         11 :               else if (rtx_equal_p (XEXP (top0, 0),
    3058                 :         11 :                                     XEXP (XEXP (top1, 0), 1)))
    3059                 :          1 :                 tem = XEXP (XEXP (top1, 0), 0);
    3060                 :         36 :               if (tem)
    3061                 :         36 :                 return simplify_gen_binary (IOR, mode, XEXP (top0, 0),
    3062                 :            :                                             simplify_gen_binary
    3063                 :         36 :                                               (AND, mode, tem, XEXP (top1, 1)));
    3064                 :            :             }
    3065                 :            :         }
    3066                 :            : 
    3067                 :    4257860 :       tem = simplify_byte_swapping_operation (code, mode, op0, op1);
    3068                 :    4257860 :       if (tem)
    3069                 :            :         return tem;
    3070                 :            : 
    3071                 :    4257790 :       tem = simplify_associative_operation (code, mode, op0, op1);
    3072                 :    4257790 :       if (tem)
    3073                 :            :         return tem;
    3074                 :            : 
    3075                 :    4230900 :       tem = simplify_logical_relational_operation (code, mode, op0, op1);
    3076                 :    4230900 :       if (tem)
    3077                 :            :         return tem;
    3078                 :            :       break;
    3079                 :            : 
    3080                 :    1509500 :     case XOR:
    3081                 :    1509500 :       if (trueop1 == CONST0_RTX (mode))
    3082                 :            :         return op0;
    3083                 :    1468690 :       if (INTEGRAL_MODE_P (mode) && trueop1 == CONSTM1_RTX (mode))
    3084                 :      25999 :         return simplify_gen_unary (NOT, mode, op0, mode);
    3085                 :    1442690 :       if (rtx_equal_p (trueop0, trueop1)
    3086                 :       1374 :           && ! side_effects_p (op0)
    3087                 :    1444060 :           && GET_MODE_CLASS (mode) != MODE_CC)
    3088                 :       1374 :          return CONST0_RTX (mode);
    3089                 :            : 
    3090                 :            :       /* Canonicalize XOR of the most significant bit to PLUS.  */
    3091                 :    1441310 :       if (CONST_SCALAR_INT_P (op1)
    3092                 :    1441310 :           && mode_signbit_p (mode, op1))
    3093                 :      38007 :         return simplify_gen_binary (PLUS, mode, op0, op1);
    3094                 :            :       /* (xor (plus X C1) C2) is (xor X (C1^C2)) if C1 is signbit.  */
    3095                 :    1403310 :       if (CONST_SCALAR_INT_P (op1)
    3096                 :     337741 :           && GET_CODE (op0) == PLUS
    3097                 :       2735 :           && CONST_SCALAR_INT_P (XEXP (op0, 1))
    3098                 :    1405650 :           && mode_signbit_p (mode, XEXP (op0, 1)))
    3099                 :        123 :         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
    3100                 :            :                                     simplify_gen_binary (XOR, mode, op1,
    3101                 :        123 :                                                          XEXP (op0, 1)));
    3102                 :            : 
    3103                 :            :       /* If we are XORing two things that have no bits in common,
    3104                 :            :          convert them into an IOR.  This helps to detect rotation encoded
    3105                 :            :          using those methods and possibly other simplifications.  */
    3106                 :            : 
    3107                 :    1403180 :       if (HWI_COMPUTABLE_MODE_P (mode)
    3108                 :    1403180 :           && (nonzero_bits (op0, mode)
    3109                 :    1357560 :               & nonzero_bits (op1, mode)) == 0)
    3110                 :       5554 :         return (simplify_gen_binary (IOR, mode, op0, op1));
    3111                 :            : 
    3112                 :            :       /* Convert (XOR (NOT x) (NOT y)) to (XOR x y).
    3113                 :            :          Also convert (XOR (NOT x) y) to (NOT (XOR x y)), similarly for
    3114                 :            :          (NOT y).  */
    3115                 :    1397630 :       {
    3116                 :    1397630 :         int num_negated = 0;
    3117                 :            : 
    3118                 :    1397630 :         if (GET_CODE (op0) == NOT)
    3119                 :        298 :           num_negated++, op0 = XEXP (op0, 0);
    3120                 :    1397630 :         if (GET_CODE (op1) == NOT)
    3121                 :          0 :           num_negated++, op1 = XEXP (op1, 0);
    3122                 :            : 
    3123                 :    1397630 :         if (num_negated == 2)
    3124                 :          0 :           return simplify_gen_binary (XOR, mode, op0, op1);
    3125                 :    1397630 :         else if (num_negated == 1)
    3126                 :        298 :           return simplify_gen_unary (NOT, mode,
    3127                 :            :                                      simplify_gen_binary (XOR, mode, op0, op1),
    3128                 :        298 :                                      mode);
    3129                 :            :       }
    3130                 :            : 
    3131                 :            :       /* Convert (xor (and A B) B) to (and (not A) B).  The latter may
    3132                 :            :          correspond to a machine insn or result in further simplifications
    3133                 :            :          if B is a constant.  */
    3134                 :            : 
    3135                 :    1397330 :       if (GET_CODE (op0) == AND
    3136                 :      83177 :           && rtx_equal_p (XEXP (op0, 1), op1)
    3137                 :    1405480 :           && ! side_effects_p (op1))
    3138                 :       8146 :         return simplify_gen_binary (AND, mode,
    3139                 :            :                                     simplify_gen_unary (NOT, mode,
    3140                 :            :                                                         XEXP (op0, 0), mode),
    3141                 :       8146 :                                     op1);
    3142                 :            : 
    3143                 :    1389180 :       else if (GET_CODE (op0) == AND
    3144                 :      75031 :                && rtx_equal_p (XEXP (op0, 0), op1)
    3145                 :    1389990 :                && ! side_effects_p (op1))
    3146                 :        803 :         return simplify_gen_binary (AND, mode,
    3147                 :            :                                     simplify_gen_unary (NOT, mode,
    3148                 :            :                                                         XEXP (op0, 1), mode),
    3149                 :        803 :                                     op1);
    3150                 :            : 
    3151                 :            :       /* Given (xor (ior (xor A B) C) D), where B, C and D are
    3152                 :            :          constants, simplify to (xor (ior A C) (B&~C)^D), canceling
    3153                 :            :          out bits inverted twice and not set by C.  Similarly, given
    3154                 :            :          (xor (and (xor A B) C) D), simplify without inverting C in
    3155                 :            :          the xor operand: (xor (and A C) (B&C)^D).
    3156                 :            :       */
    3157                 :    1388380 :       else if ((GET_CODE (op0) == IOR || GET_CODE (op0) == AND)
    3158                 :      81311 :                && GET_CODE (XEXP (op0, 0)) == XOR
    3159                 :       1423 :                && CONST_INT_P (op1)
    3160                 :        107 :                && CONST_INT_P (XEXP (op0, 1))
    3161                 :         93 :                && CONST_INT_P (XEXP (XEXP (op0, 0), 1)))
    3162                 :            :         {
    3163                 :         93 :           enum rtx_code op = GET_CODE (op0);
    3164                 :         93 :           rtx a = XEXP (XEXP (op0, 0), 0);
    3165                 :         93 :           rtx b = XEXP (XEXP (op0, 0), 1);
    3166                 :         93 :           rtx c = XEXP (op0, 1);
    3167                 :         93 :           rtx d = op1;
    3168                 :         93 :           HOST_WIDE_INT bval = INTVAL (b);
    3169                 :         93 :           HOST_WIDE_INT cval = INTVAL (c);
    3170                 :         93 :           HOST_WIDE_INT dval = INTVAL (d);
    3171                 :         93 :           HOST_WIDE_INT xcval;
    3172                 :            : 
    3173                 :         93 :           if (op == IOR)
    3174                 :          8 :             xcval = ~cval;
    3175                 :            :           else
    3176                 :            :             xcval = cval;
    3177                 :            : 
    3178                 :         93 :           return simplify_gen_binary (XOR, mode,
    3179                 :            :                                       simplify_gen_binary (op, mode, a, c),
    3180                 :         93 :                                       gen_int_mode ((bval & xcval) ^ dval,
    3181                 :            :                                                     mode));
    3182                 :            :         }
    3183                 :            : 
    3184                 :            :       /* Given (xor (and A B) C), using P^Q == (~P&Q) | (~Q&P),
    3185                 :            :          we can transform like this:
    3186                 :            :             (A&B)^C == ~(A&B)&C | ~C&(A&B)
    3187                 :            :                     == (~A|~B)&C | ~C&(A&B)    * DeMorgan's Law
    3188                 :            :                     == ~A&C | ~B&C | A&(~C&B)  * Distribute and re-order
    3189                 :            :          Attempt a few simplifications when B and C are both constants.  */
    3190                 :    1388290 :       if (GET_CODE (op0) == AND
    3191                 :      74143 :           && CONST_INT_P (op1)
    3192                 :       6031 :           && CONST_INT_P (XEXP (op0, 1)))
    3193                 :            :         {
    3194                 :       4913 :           rtx a = XEXP (op0, 0);
    3195                 :       4913 :           rtx b = XEXP (op0, 1);
    3196                 :       4913 :           rtx c = op1;
    3197                 :       4913 :           HOST_WIDE_INT bval = INTVAL (b);
    3198                 :       4913 :           HOST_WIDE_INT cval = INTVAL (c);
    3199                 :            : 
    3200                 :            :           /* Instead of computing ~A&C, we compute its negated value,
    3201                 :            :              ~(A|~C).  If it yields -1, ~A&C is zero, so we can
    3202                 :            :              optimize for sure.  If it does not simplify, we still try
    3203                 :            :              to compute ~A&C below, but since that always allocates
    3204                 :            :              RTL, we don't try that before committing to returning a
    3205                 :            :              simplified expression.  */
    3206                 :       4913 :           rtx n_na_c = simplify_binary_operation (IOR, mode, a,
    3207                 :            :                                                   GEN_INT (~cval));
    3208                 :            : 
    3209                 :       4913 :           if ((~cval & bval) == 0)
    3210                 :            :             {
    3211                 :        193 :               rtx na_c = NULL_RTX;
    3212                 :        193 :               if (n_na_c)
    3213                 :          0 :                 na_c = simplify_gen_unary (NOT, mode, n_na_c, mode);
    3214                 :            :               else
    3215                 :            :                 {
    3216                 :            :                   /* If ~A does not simplify, don't bother: we don't
    3217                 :            :                      want to simplify 2 operations into 3, and if na_c
    3218                 :            :                      were to simplify with na, n_na_c would have
    3219                 :            :                      simplified as well.  */
    3220                 :        193 :                   rtx na = simplify_unary_operation (NOT, mode, a, mode);
    3221                 :        193 :                   if (na)
    3222                 :          0 :                     na_c = simplify_gen_binary (AND, mode, na, c);
    3223                 :            :                 }
    3224                 :            : 
    3225                 :            :               /* Try to simplify ~A&C | ~B&C.  */
    3226                 :          0 :               if (na_c != NULL_RTX)
    3227                 :          0 :                 return simplify_gen_binary (IOR, mode, na_c,
    3228                 :          0 :                                             gen_int_mode (~bval & cval, mode));
    3229                 :            :             }
    3230                 :            :           else
    3231                 :            :             {
    3232                 :            :               /* If ~A&C is zero, simplify A&(~C&B) | ~B&C.  */
    3233                 :       4720 :               if (n_na_c == CONSTM1_RTX (mode))
    3234                 :            :                 {
    3235                 :          0 :                   rtx a_nc_b = simplify_gen_binary (AND, mode, a,
    3236                 :          0 :                                                     gen_int_mode (~cval & bval,
    3237                 :            :                                                                   mode));
    3238                 :          0 :                   return simplify_gen_binary (IOR, mode, a_nc_b,
    3239                 :          0 :                                               gen_int_mode (~bval & cval,
    3240                 :            :                                                             mode));
    3241                 :            :                 }
    3242                 :            :             }
    3243                 :            :         }
    3244                 :            : 
    3245                 :            :       /* If we have (xor (and (xor A B) C) A) with C a constant we can instead
    3246                 :            :          do (ior (and A ~C) (and B C)) which is a machine instruction on some
    3247                 :            :          machines, and also has shorter instruction path length.  */
    3248                 :    1388290 :       if (GET_CODE (op0) == AND
    3249                 :      74143 :           && GET_CODE (XEXP (op0, 0)) == XOR
    3250                 :       1322 :           && CONST_INT_P (XEXP (op0, 1))
    3251                 :    1388490 :           && rtx_equal_p (XEXP (XEXP (op0, 0), 0), trueop1))
    3252                 :            :         {
    3253                 :         19 :           rtx a = trueop1;
    3254                 :         19 :           rtx b = XEXP (XEXP (op0, 0), 1);
    3255                 :         19 :           rtx c = XEXP (op0, 1);
    3256                 :         19 :           rtx nc = simplify_gen_unary (NOT, mode, c, mode);
    3257                 :         19 :           rtx a_nc = simplify_gen_binary (AND, mode, a, nc);
    3258                 :         19 :           rtx bc = simplify_gen_binary (AND, mode, b, c);
    3259                 :         19 :           return simplify_gen_binary (IOR, mode, a_nc, bc);
    3260                 :            :         }
    3261                 :            :       /* Similarly, (xor (and (xor A B) C) B) as (ior (and A C) (and B ~C))  */
    3262                 :    1388270 :       else if (GET_CODE (op0) == AND
    3263                 :      74124 :           && GET_CODE (XEXP (op0, 0)) == XOR
    3264                 :       1303 :           && CONST_INT_P (XEXP (op0, 1))
    3265                 :    1388450 :           && rtx_equal_p (XEXP (XEXP (op0, 0), 1), trueop1))
    3266                 :            :         {
    3267                 :          4 :           rtx a = XEXP (XEXP (op0, 0), 0);
    3268                 :          4 :           rtx b = trueop1;
    3269                 :          4 :           rtx c = XEXP (op0, 1);
    3270                 :          4 :           rtx nc = simplify_gen_unary (NOT, mode, c, mode);
    3271                 :          4 :           rtx b_nc = simplify_gen_binary (AND, mode, b, nc);
    3272                 :          4 :           rtx ac = simplify_gen_binary (AND, mode, a, c);
    3273                 :          4 :           return simplify_gen_binary (IOR, mode, ac, b_nc);
    3274                 :            :         }
    3275                 :            : 
    3276                 :            :       /* (xor (comparison foo bar) (const_int 1)) can become the reversed
    3277                 :            :          comparison if STORE_FLAG_VALUE is 1.  */
    3278                 :    1388270 :       if (STORE_FLAG_VALUE == 1
    3279                 :    1388270 :           && trueop1 == const1_rtx
    3280                 :     134176 :           && COMPARISON_P (op0)
    3281                 :    1390850 :           && (reversed = reversed_comparison (op0, mode)))
    3282                 :            :         return reversed;
    3283                 :            : 
    3284                 :            :       /* (lshiftrt foo C) where C is the number of bits in FOO minus 1
    3285                 :            :          is (lt foo (const_int 0)), so we can perform the above
    3286                 :            :          simplification if STORE_FLAG_VALUE is 1.  */
    3287                 :            : 
    3288                 :    1385800 :       if (is_a <scalar_int_mode> (mode, &int_mode)
    3289                 :            :           && STORE_FLAG_VALUE == 1
    3290                 :    1340190 :           && trueop1 == const1_rtx
    3291                 :     131714 :           && GET_CODE (op0) == LSHIFTRT
    3292                 :      39888 :           && CONST_INT_P (XEXP (op0, 1))
    3293                 :    1425670 :           && INTVAL (XEXP (op0, 1)) == GET_MODE_PRECISION (int_mode) - 1)
    3294                 :      38323 :         return gen_rtx_GE (int_mode, XEXP (op0, 0), const0_rtx);
    3295                 :            : 
    3296                 :            :       /* (xor (comparison foo bar) (const_int sign-bit))
    3297                 :            :          when STORE_FLAG_VALUE is the sign bit.  */
    3298                 :    1347480 :       if (is_a <scalar_int_mode> (mode, &int_mode)
    3299                 :    1301870 :           && val_signbit_p (int_mode, STORE_FLAG_VALUE)
    3300                 :          0 :           && trueop1 == const_true_rtx
    3301                 :          0 :           && COMPARISON_P (op0)
    3302                 :    1347480 :           && (reversed = reversed_comparison (op0, int_mode)))
    3303                 :            :         return reversed;
    3304                 :            : 
    3305                 :    1347480 :       tem = simplify_byte_swapping_operation (code, mode, op0, op1);
    3306                 :    1347480 :       if (tem)
    3307                 :            :         return tem;
    3308                 :            : 
    3309                 :    1347480 :       tem = simplify_associative_operation (code, mode, op0, op1);
    3310                 :    1347480 :       if (tem)
    3311                 :            :         return tem;
    3312                 :            :       break;
    3313                 :            : 
    3314                 :   10396900 :     case AND:
    3315                 :   10396900 :       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
    3316                 :            :         return trueop1;
    3317                 :   10243900 :       if (INTEGRAL_MODE_P (mode) && trueop1 == CONSTM1_RTX (mode))
    3318                 :            :         return op0;
    3319                 :   10217400 :       if (HWI_COMPUTABLE_MODE_P (mode))
    3320                 :            :         {
    3321                 :    9867960 :           HOST_WIDE_INT nzop0 = nonzero_bits (trueop0, mode);
    3322                 :    9867960 :           HOST_WIDE_INT nzop1;
    3323                 :    9867960 :           if (CONST_INT_P (trueop1))
    3324                 :            :             {
    3325                 :    8710790 :               HOST_WIDE_INT val1 = INTVAL (trueop1);
    3326                 :            :               /* If we are turning off bits already known off in OP0, we need
    3327                 :            :                  not do an AND.  */
    3328                 :    8710790 :               if ((nzop0 & ~val1) == 0)
    3329                 :            :                 return op0;
    3330                 :            :             }
    3331                 :    9691400 :           nzop1 = nonzero_bits (trueop1, mode);
    3332                 :            :           /* If we are clearing all the nonzero bits, the result is zero.  */
    3333                 :    9691400 :           if ((nzop1 & nzop0) == 0
    3334                 :    9691400 :               && !side_effects_p (op0) && !side_effects_p (op1))
    3335                 :       4956 :             return CONST0_RTX (mode);
    3336                 :            :         }
    3337                 :   10036000 :       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0)
    3338                 :   10036000 :           && GET_MODE_CLASS (mode) != MODE_CC)
    3339                 :            :         return op0;
    3340                 :            :       /* A & (~A) -> 0 */
    3341                 :     148570 :       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
    3342                 :   10035700 :            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
    3343                 :         33 :           && ! side_effects_p (op0)
    3344                 :   10035700 :           && GET_MODE_CLASS (mode) != MODE_CC)
    3345                 :         33 :         return CONST0_RTX (mode);
    3346                 :            : 
    3347                 :            :       /* Transform (and (extend X) C) into (zero_extend (and X C)) if
    3348                 :            :          there are no nonzero bits of C outside of X's mode.  */
    3349                 :   10035700 :       if ((GET_CODE (op0) == SIGN_EXTEND
    3350                 :   10035700 :            || GET_CODE (op0) == ZERO_EXTEND)
    3351                 :       8764 :           && CONST_INT_P (trueop1)
    3352                 :       3267 :           && HWI_COMPUTABLE_MODE_P (mode)
    3353                 :   10035700 :           && (~GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))
    3354                 :       3267 :               & UINTVAL (trueop1)) == 0)
    3355                 :            :         {
    3356                 :       3050 :           machine_mode imode = GET_MODE (XEXP (op0, 0));
    3357                 :       3050 :           tem = simplify_gen_binary (AND, imode, XEXP (op0, 0),
    3358                 :       3050 :                                      gen_int_mode (INTVAL (trueop1),
    3359                 :            :                                                    imode));
    3360                 :       3050 :           return simplify_gen_unary (ZERO_EXTEND, mode, tem, imode);
    3361                 :            :         }
    3362                 :            : 
    3363                 :            :       /* Transform (and (truncate X) C) into (truncate (and X C)).  This way
    3364                 :            :          we might be able to further simplify the AND with X and potentially
    3365                 :            :          remove the truncation altogether.  */
    3366                 :   10032600 :       if (GET_CODE (op0) == TRUNCATE && CONST_INT_P (trueop1))
    3367                 :            :         {
    3368                 :       5037 :           rtx x = XEXP (op0, 0);
    3369                 :       5037 :           machine_mode xmode = GET_MODE (x);
    3370                 :       5037 :           tem = simplify_gen_binary (AND, xmode, x,
    3371                 :       5037 :                                      gen_int_mode (INTVAL (trueop1), xmode));
    3372                 :       5037 :           return simplify_gen_unary (TRUNCATE, mode, tem, xmode);
    3373                 :            :         }
    3374                 :            : 
    3375                 :            :       /* Canonicalize (A | C1) & C2 as (A & C2) | (C1 & C2).  */
    3376                 :   10027600 :       if (GET_CODE (op0) == IOR
    3377                 :     446942 :           && CONST_INT_P (trueop1)
    3378                 :      99637 :           && CONST_INT_P (XEXP (op0, 1)))
    3379                 :            :         {
    3380                 :      72818 :           HOST_WIDE_INT tmp = INTVAL (trueop1) & INTVAL (XEXP (op0, 1));
    3381                 :      72818 :           return simplify_gen_binary (IOR, mode,
    3382                 :            :                                       simplify_gen_binary (AND, mode,
    3383                 :            :                                                            XEXP (op0, 0), op1),
    3384                 :            :                                       gen_int_mode (tmp, mode));
    3385                 :            :         }
    3386                 :            : 
    3387                 :            :       /* Convert (A ^ B) & A to A & (~B) since the latter is often a single
    3388                 :            :          insn (and may simplify more).  */
    3389                 :    9954770 :       if (GET_CODE (op0) == XOR
    3390                 :      75384 :           && rtx_equal_p (XEXP (op0, 0), op1)
    3391                 :    9954770 :           && ! side_effects_p (op1))
    3392                 :          4 :         return simplify_gen_binary (AND, mode,
    3393                 :            :                                     simplify_gen_unary (NOT, mode,
    3394                 :            :                                                         XEXP (op0, 1), mode),
    3395                 :          4 :                                     op1);
    3396                 :            : 
    3397                 :    9954770 :       if (GET_CODE (op0) == XOR
    3398                 :      75380 :           && rtx_equal_p (XEXP (op0, 1), op1)
    3399                 :    9956560 :           && ! side_effects_p (op1))
    3400                 :       1789 :         return simplify_gen_binary (AND, mode,
    3401                 :            :                                     simplify_gen_unary (NOT, mode,
    3402                 :            :                                                         XEXP (op0, 0), mode),
    3403                 :       1789 :                                     op1);
    3404                 :            : 
    3405                 :            :       /* Similarly for (~(A ^ B)) & A.  */
    3406                 :    9952980 :       if (GET_CODE (op0) == NOT
    3407                 :     148537 :           && GET_CODE (XEXP (op0, 0)) == XOR
    3408                 :        280 :           && rtx_equal_p (XEXP (XEXP (op0, 0), 0), op1)
    3409                 :    9952980 :           && ! side_effects_p (op1))
    3410                 :          0 :         return simplify_gen_binary (AND, mode, XEXP (XEXP (op0, 0), 1), op1);
    3411                 :            : 
    3412                 :    9952980 :       if (GET_CODE (op0) == NOT
    3413                 :     148537 :           && GET_CODE (XEXP (op0, 0)) == XOR
    3414                 :        280 :           && rtx_equal_p (XEXP (XEXP (op0, 0), 1), op1)
    3415                 :    9952980 :           && ! side_effects_p (op1))
    3416                 :          0 :         return simplify_gen_binary (AND, mode, XEXP (XEXP (op0, 0), 0), op1);
    3417                 :            : 
    3418                 :            :       /* Convert (A | B) & A to A.  */
    3419                 :    9952980 :       if (GET_CODE (op0) == IOR
    3420                 :     374124 :           && (rtx_equal_p (XEXP (op0, 0), op1)
    3421                 :     374124 :               || rtx_equal_p (XEXP (op0, 1), op1))
    3422                 :          0 :           && ! side_effects_p (XEXP (op0, 0))
    3423                 :    9952980 :           && ! side_effects_p (XEXP (op0, 1)))
    3424                 :            :         return op1;
    3425                 :            : 
    3426                 :            :       /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
    3427                 :            :          ((A & N) + B) & M -> (A + B) & M
    3428                 :            :          Similarly if (N & M) == 0,
    3429                 :            :          ((A | N) + B) & M -> (A + B) & M
    3430                 :            :          and for - instead of + and/or ^ instead of |.
    3431                 :            :          Also, if (N & M) == 0, then
    3432                 :            :          (A +- N) & M -> A & M.  */
    3433                 :    9952980 :       if (CONST_INT_P (trueop1)
    3434                 :    8452120 :           && HWI_COMPUTABLE_MODE_P (mode)
    3435                 :    8446940 :           && ~UINTVAL (trueop1)
    3436                 :    8446940 :           && (UINTVAL (trueop1) & (UINTVAL (trueop1) + 1)) == 0
    3437                 :   15624000 :           && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS))
    3438                 :            :         {
    3439                 :     329546 :           rtx pmop[2];
    3440                 :     329546 :           int which;
    3441                 :            : 
    3442                 :     329546 :           pmop[0] = XEXP (op0, 0);
    3443                 :     329546 :           pmop[1] = XEXP (op0, 1);
    3444                 :            : 
    3445                 :     329546 :           if (CONST_INT_P (pmop[1])
    3446                 :     165143 :               && (UINTVAL (pmop[1]) & UINTVAL (trueop1)) == 0)
    3447                 :      14316 :             return simplify_gen_binary (AND, mode, pmop[0], op1);
    3448                 :            : 
    3449                 :     956742 :           for (which = 0; which < 2; which++)
    3450                 :            :             {
    3451                 :     637828 :               tem = pmop[which];
    3452                 :     637828 :               switch (GET_CODE (tem))
    3453                 :            :                 {
    3454                 :       5596 :                 case AND:
    3455                 :       5596 :                   if (CONST_INT_P (XEXP (tem, 1))
    3456                 :       5528 :                       && (UINTVAL (XEXP (tem, 1)) & UINTVAL (trueop1))
    3457                 :            :                       == UINTVAL (trueop1))
    3458                 :       3684 :                     pmop[which] = XEXP (tem, 0);
    3459                 :            :                   break;
    3460                 :       1741 :                 case IOR:
    3461                 :       1741 :                 case XOR:
    3462                 :       1741 :                   if (CONST_INT_P (XEXP (tem, 1))
    3463                 :         82 :                       && (UINTVAL (XEXP (tem, 1)) & UINTVAL (trueop1)) == 0)
    3464                 :          0 :                     pmop[which] = XEXP (tem, 0);
    3465                 :            :                   break;
    3466                 :            :                 default:
    3467                 :            :                   break;
    3468                 :            :                 }
    3469                 :            :             }
    3470                 :            : 
    3471                 :     318914 :           if (pmop[0] != XEXP (op0, 0) || pmop[1] != XEXP (op0, 1))
    3472                 :            :             {
    3473                 :       3684 :               tem = simplify_gen_binary (GET_CODE (op0), mode,
    3474                 :            :                                          pmop[0], pmop[1]);
    3475                 :       3684 :               return simplify_gen_binary (code, mode, tem, op1);
    3476                 :            :             }
    3477                 :            :         }
    3478                 :            : 
    3479                 :            :       /* (and X (ior (not X) Y) -> (and X Y) */
    3480                 :    9938660 :       if (GET_CODE (op1) == IOR
    3481                 :     313528 :           && GET_CODE (XEXP (op1, 0)) == NOT
    3482                 :    9939050 :           && rtx_equal_p (op0, XEXP (XEXP (op1, 0), 0)))
    3483                 :          0 :        return simplify_gen_binary (AND, mode, op0, XEXP (op1, 1));
    3484                 :            : 
    3485                 :            :       /* (and (ior (not X) Y) X) -> (and X Y) */
    3486                 :    9938660 :       if (GET_CODE (op0) == IOR
    3487                 :     374124 :           && GET_CODE (XEXP (op0, 0)) == NOT
    3488                 :    9945060 :           && rtx_equal_p (op1, XEXP (XEXP (op0, 0), 0)))
    3489                 :          0 :         return simplify_gen_binary (AND, mode, op1, XEXP (op0, 1));
    3490                 :            : 
    3491                 :            :       /* (and X (ior Y (not X)) -> (and X Y) */
    3492                 :    9938660 :       if (GET_CODE (op1) == IOR
    3493                 :     313528 :           && GET_CODE (XEXP (op1, 1)) == NOT
    3494                 :    9938680 :           && rtx_equal_p (op0, XEXP (XEXP (op1, 1), 0)))
    3495                 :          0 :        return simplify_gen_binary (AND, mode, op0, XEXP (op1, 0));
    3496                 :            : 
    3497                 :            :       /* (and (ior Y (not X)) X) -> (and X Y) */
    3498                 :    9938660 :       if (GET_CODE (op0) == IOR
    3499                 :     374124 :           && GET_CODE (XEXP (op0, 1)) == NOT
    3500                 :    9940820 :           && rtx_equal_p (op1, XEXP (XEXP (op0, 1), 0)))
    3501                 :          0 :         return simplify_gen_binary (AND, mode, op1, XEXP (op0, 0));
    3502                 :            : 
    3503                 :    9938660 :       tem = simplify_byte_swapping_operation (code, mode, op0, op1);
    3504                 :    9938660 :       if (tem)
    3505                 :            :         return tem;
    3506                 :            : 
    3507                 :    9938620 :       tem = simplify_associative_operation (code, mode, op0, op1);
    3508                 :    9938620 :       if (tem)
    3509                 :            :         return tem;
    3510                 :            :       break;
    3511                 :            : 
    3512                 :     306196 :     case UDIV:
    3513                 :            :       /* 0/x is 0 (or x&0 if x has side-effects).  */
    3514                 :     306196 :       if (trueop0 == CONST0_RTX (mode)
    3515                 :        236 :           && !cfun->can_throw_non_call_exceptions)
    3516                 :            :         {
    3517                 :        236 :           if (side_effects_p (op1))
    3518                 :          0 :             return simplify_gen_binary (AND, mode, op1, trueop0);
    3519                 :            :           return trueop0;
    3520                 :            :         }
    3521                 :            :       /* x/1 is x.  */
    3522                 :     305960 :       if (trueop1 == CONST1_RTX (mode))
    3523                 :            :         {
    3524                 :      10409 :           tem = rtl_hooks.gen_lowpart_no_emit (mode, op0);
    3525                 :      10409 :           if (tem)
    3526                 :            :             return tem;
    3527                 :            :         }
    3528                 :            :       /* Convert divide by power of two into shift.  */
    3529                 :     295551 :       if (CONST_INT_P (trueop1)
    3530                 :     295551 :           && (val = exact_log2 (UINTVAL (trueop1))) > 0)
    3531                 :      89191 :         return simplify_gen_binary (LSHIFTRT, mode, op0,
    3532                 :            :                                     gen_int_shift_amount (mode, val));
    3533                 :            :       break;
    3534                 :            : 
    3535                 :     695390 :     case DIV:
    3536                 :            :       /* Handle floating point and integers separately.  */
    3537                 :     695390 :       if (SCALAR_FLOAT_MODE_P (mode))
    3538                 :            :         {
    3539                 :            :           /* Maybe change 0.0 / x to 0.0.  This transformation isn't
    3540                 :            :              safe for modes with NaNs, since 0.0 / 0.0 will then be
    3541                 :            :              NaN rather than 0.0.  Nor is it safe for modes with signed
    3542                 :            :              zeros, since dividing 0 by a negative number gives -0.0  */
    3543                 :     182966 :           if (trueop0 == CONST0_RTX (mode)
    3544                 :       2925 :               && !HONOR_NANS (mode)
    3545                 :          9 :               && !HONOR_SIGNED_ZEROS (mode)
    3546                 :     182975 :               && ! side_effects_p (op1))
    3547                 :            :             return op0;
    3548                 :            :           /* x/1.0 is x.  */
    3549                 :     182957 :           if (trueop1 == CONST1_RTX (mode)
    3550                 :     182957 :               && !HONOR_SNANS (mode))
    3551                 :            :             return op0;
    3552                 :            : 
    3553                 :     182952 :           if (CONST_DOUBLE_AS_FLOAT_P (trueop1)
    3554                 :      22634 :               && trueop1 != CONST0_RTX (mode))
    3555                 :            :             {
    3556                 :      17646 :               const REAL_VALUE_TYPE *d1 = CONST_DOUBLE_REAL_VALUE (trueop1);
    3557                 :            : 
    3558                 :            :               /* x/-1.0 is -x.  */
    3559                 :      17646 :               if (real_equal (d1, &dconstm1)
    3560                 :      17646 :                   && !HONOR_SNANS (mode))
    3561                 :          0 :                 return simplify_gen_unary (NEG, mode, op0, mode);
    3562                 :            : 
    3563                 :            :               /* Change FP division by a constant into multiplication.
    3564                 :            :                  Only do this with -freciprocal-math.  */
    3565                 :      17646 :               if (flag_reciprocal_math
    3566                 :      17646 :                   && !real_equal (d1, &dconst0))
    3567                 :            :                 {
    3568                 :          3 :                   REAL_VALUE_TYPE d;
    3569                 :          3 :                   real_arithmetic (&d, RDIV_EXPR, &dconst1, d1);
    3570                 :          3 :                   tem = const_double_from_real_value (d, mode);
    3571                 :          3 :                   return simplify_gen_binary (MULT, mode, op0, tem);
    3572                 :            :                 }
    3573                 :            :             }
    3574                 :            :         }
    3575                 :     512424 :       else if (SCALAR_INT_MODE_P (mode))
    3576                 :            :         {
    3577                 :            :           /* 0/x is 0 (or x&0 if x has side-effects).  */
    3578                 :     501059 :           if (trueop0 == CONST0_RTX (mode)
    3579                 :        613 :               && !cfun->can_throw_non_call_exceptions)
    3580                 :            :             {
    3581                 :        549 :               if (side_effects_p (op1))
    3582                 :          8 :                 return simplify_gen_binary (AND, mode, op1, trueop0);
    3583                 :            :               return trueop0;
    3584                 :            :             }
    3585                 :            :           /* x/1 is x.  */
    3586                 :     500510 :           if (trueop1 == CONST1_RTX (mode))
    3587                 :            :             {
    3588                 :         50 :               tem = rtl_hooks.gen_lowpart_no_emit (mode, op0);
    3589                 :         50 :               if (tem)
    3590                 :            :                 return tem;
    3591                 :            :             }
    3592                 :            :           /* x/-1 is -x.  */
    3593                 :     500460 :           if (trueop1 == constm1_rtx)
    3594                 :            :             {
    3595                 :        109 :               rtx x = rtl_hooks.gen_lowpart_no_emit (mode, op0);
    3596                 :        109 :               if (x)
    3597                 :        109 :                 return simplify_gen_unary (NEG, mode, x, mode);
    3598                 :            :             }
    3599                 :            :         }
    3600                 :            :       break;
    3601                 :            : 
    3602                 :     307822 :     case UMOD:
    3603                 :            :       /* 0%x is 0 (or x&0 if x has side-effects).  */
    3604                 :     307822 :       if (trueop0 == CONST0_RTX (mode))
    3605                 :            :         {
    3606                 :        471 :           if (side_effects_p (op1))
    3607                 :          0 :             return simplify_gen_binary (AND, mode, op1, trueop0);
    3608                 :            :           return trueop0;
    3609                 :            :         }
    3610                 :            :       /* x%1 is 0 (of x&0 if x has side-effects).  */
    3611                 :     307351 :       if (trueop1 == CONST1_RTX (mode))
    3612                 :            :         {
    3613                 :      12225 :           if (side_effects_p (op0))
    3614                 :          0 :             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
    3615                 :      12225 :           return CONST0_RTX (mode);
    3616                 :            :         }
    3617                 :            :       /* Implement modulus by power of two as AND.  */
    3618                 :     295126 :       if (CONST_INT_P (trueop1)
    3619                 :     295126 :           && exact_log2 (UINTVAL (trueop1)) > 0)
    3620                 :      58963 :         return simplify_gen_binary (AND, mode, op0,
    3621                 :      58963 :                                     gen_int_mode (UINTVAL (trueop1) - 1,
    3622                 :            :                                                   mode));
    3623                 :            :       break;
    3624                 :            : 
    3625                 :     295811 :     case MOD:
    3626                 :            :       /* 0%x is 0 (or x&0 if x has side-effects).  */
    3627                 :     295811 :       if (trueop0 == CONST0_RTX (mode))
    3628                 :            :         {
    3629                 :        576 :           if (side_effects_p (op1))
    3630                 :          8 :             return simplify_gen_binary (AND, mode, op1, trueop0);
    3631                 :            :           return trueop0;
    3632                 :            :         }
    3633                 :            :       /* x%1 and x%-1 is 0 (or x&0 if x has side-effects).  */
    3634                 :     295235 :       if (trueop1 == CONST1_RTX (mode) || trueop1 == constm1_rtx)
    3635                 :            :         {
    3636                 :         85 :           if (side_effects_p (op0))
    3637                 :          0 :             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
    3638                 :         85 :           return CONST0_RTX (mode);
    3639                 :            :         }
    3640                 :            :       break;
    3641                 :            : 
    3642                 :     111984 :     case ROTATERT:
    3643                 :     111984 :     case ROTATE:
    3644                 :            :       /* Canonicalize rotates by constant amount.  If op1 is bitsize / 2,
    3645                 :            :          prefer left rotation, if op1 is from bitsize / 2 + 1 to
    3646                 :            :          bitsize - 1, use other direction of rotate with 1 .. bitsize / 2 - 1
    3647                 :            :          amount instead.  */
    3648                 :            : #if defined(HAVE_rotate) && defined(HAVE_rotatert)
    3649                 :     111984 :       if (CONST_INT_P (trueop1)
    3650                 :     380067 :           && IN_RANGE (INTVAL (trueop1),
    3651                 :            :                        GET_MODE_UNIT_PRECISION (mode) / 2 + (code == ROTATE),
    3652                 :            :                        GET_MODE_UNIT_PRECISION (mode) - 1))
    3653                 :            :         {
    3654                 :       8839 :           int new_amount = GET_MODE_UNIT_PRECISION (mode) - INTVAL (trueop1);
    3655                 :       8839 :           rtx new_amount_rtx = gen_int_shift_amount (mode, new_amount);
    3656                 :       9005 :           return simplify_gen_binary (code == ROTATE ? ROTATERT : ROTATE,
    3657                 :            :                                       mode, op0, new_amount_rtx);
    3658                 :            :         }
    3659                 :            : #endif
    3660                 :            :       /* FALLTHRU */
    3661                 :    3794730 :     case ASHIFTRT:
    3662                 :    3794730 :       if (trueop1 == CONST0_RTX (mode))
    3663                 :            :         return op0;
    3664                 :    3788780 :       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
    3665                 :            :         return op0;
    3666                 :            :       /* Rotating ~0 always results in ~0.  */
    3667                 :    3788550 :       if (CONST_INT_P (trueop0)
    3668                 :       7319 :           && HWI_COMPUTABLE_MODE_P (mode)
    3669                 :       7319 :           && UINTVAL (trueop0) == GET_MODE_MASK (mode)
    3670                 :    3788550 :           && ! side_effects_p (op1))
    3671                 :            :         return op0;
    3672                 :            : 
    3673                 :   19078400 :     canonicalize_shift:
    3674                 :            :       /* Given:
    3675                 :            :          scalar modes M1, M2
    3676                 :            :          scalar constants c1, c2
    3677                 :            :          size (M2) > size (M1)
    3678                 :            :          c1 == size (M2) - size (M1)
    3679                 :            :          optimize:
    3680                 :            :          ([a|l]shiftrt:M1 (subreg:M1 (lshiftrt:M2 (reg:M2) (const_int <c1>))
    3681                 :            :                                  <low_part>)
    3682                 :            :                       (const_int <c2>))
    3683                 :            :          to:
    3684                 :            :          (subreg:M1 ([a|l]shiftrt:M2 (reg:M2) (const_int <c1 + c2>))
    3685                 :            :                     <low_part>).  */
    3686                 :   19078400 :       if ((code == ASHIFTRT || code == LSHIFTRT)
    3687                 :    7125920 :           && is_a <scalar_int_mode> (mode, &int_mode)
    3688                 :    6882130 :           && SUBREG_P (op0)
    3689                 :     765047 :           && CONST_INT_P (op1)
    3690                 :     764204 :           && GET_CODE (SUBREG_REG (op0)) == LSHIFTRT
    3691                 :      11889 :           && is_a <scalar_int_mode> (GET_MODE (SUBREG_REG (op0)),
    3692                 :            :                                      &inner_mode)
    3693                 :      11889 :           && CONST_INT_P (XEXP (SUBREG_REG (op0), 1))
    3694                 :      23490 :           && GET_MODE_BITSIZE (inner_mode) > GET_MODE_BITSIZE (int_mode)
    3695                 :      11733 :           && (INTVAL (XEXP (SUBREG_REG (op0), 1))
    3696                 :      23466 :               == GET_MODE_BITSIZE (inner_mode) - GET_MODE_BITSIZE (int_mode))
    3697                 :   19089600 :           && subreg_lowpart_p (op0))
    3698                 :            :         {
    3699                 :      11228 :           rtx tmp = gen_int_shift_amount
    3700                 :      11228 :             (inner_mode, INTVAL (XEXP (SUBREG_REG (op0), 1)) + INTVAL (op1));
    3701                 :            : 
    3702                 :            :          /* Combine would usually zero out the value when combining two
    3703                 :            :             local shifts and the range becomes larger or equal to the mode.
    3704                 :            :             However since we fold away one of the shifts here combine won't
    3705                 :            :             see it so we should immediately zero the result if it's out of
    3706                 :            :             range.  */
    3707                 :      11228 :          if (code == LSHIFTRT
    3708                 :      19371 :              && INTVAL (tmp) >= GET_MODE_BITSIZE (inner_mode))
    3709                 :          3 :           tmp = const0_rtx;
    3710                 :            :          else
    3711                 :      11225 :            tmp = simplify_gen_binary (code,
    3712                 :            :                                       inner_mode,
    3713                 :      11225 :                                       XEXP (SUBREG_REG (op0), 0),
    3714                 :            :                                       tmp);
    3715                 :            : 
    3716                 :      11228 :           return lowpart_subreg (int_mode, tmp, inner_mode);
    3717                 :            :         }
    3718                 :            : 
    3719                 :            :       if (SHIFT_COUNT_TRUNCATED && CONST_INT_P (op1))
    3720                 :            :         {
    3721                 :            :           val = INTVAL (op1) & (GET_MODE_UNIT_PRECISION (mode) - 1);
    3722                 :            :           if (val != INTVAL (op1))
    3723                 :            :             return simplify_gen_binary (code, mode, op0,
    3724                 :            :                                         gen_int_shift_amount (mode, val));
    3725                 :            :         }
    3726                 :            :       break;
    3727                 :            : 
    3728                 :   11968800 :     case ASHIFT:
    3729                 :   11968800 :     case SS_ASHIFT:
    3730                 :   11968800 :     case US_ASHIFT:
    3731                 :   11968800 :       if (trueop1 == CONST0_RTX (mode))
    3732                 :            :         return op0;
    3733                 :   11867800 :       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
    3734                 :            :         return op0;
    3735                 :   11849400 :       goto canonicalize_shift;
    3736                 :            : 
    3737                 :    4409160 :     case LSHIFTRT:
    3738                 :    4409160 :       if (trueop1 == CONST0_RTX (mode))
    3739                 :            :         return op0;
    3740                 :    3443030 :       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
    3741                 :            :         return op0;
    3742                 :            :       /* Optimize (lshiftrt (clz X) C) as (eq X 0).  */
    3743                 :    3440440 :       if (GET_CODE (op0) == CLZ
    3744                 :          0 :           && is_a <scalar_int_mode> (GET_MODE (XEXP (op0, 0)), &inner_mode)
    3745                 :          0 :           && CONST_INT_P (trueop1)
    3746                 :            :           && STORE_FLAG_VALUE == 1
    3747                 :    3440440 :           && INTVAL (trueop1) < GET_MODE_UNIT_PRECISION (mode))
    3748                 :            :         {
    3749                 :          0 :           unsigned HOST_WIDE_INT zero_val = 0;
    3750                 :            : 
    3751                 :          0 :           if (CLZ_DEFINED_VALUE_AT_ZERO (inner_mode, zero_val)
    3752                 :          0 :               && zero_val == GET_MODE_PRECISION (inner_mode)
    3753                 :          0 :               && INTVAL (trueop1) == exact_log2 (zero_val))
    3754                 :          0 :             return simplify_gen_relational (EQ, mode, inner_mode,
    3755                 :          0 :                                             XEXP (op0, 0), const0_rtx);
    3756                 :            :         }
    3757                 :    3440440 :       goto canonicalize_shift;
    3758                 :            : 
    3759                 :     160992 :     case SMIN:
    3760                 :     160992 :       if (HWI_COMPUTABLE_MODE_P (mode)
    3761                 :     116963 :           && mode_signbit_p (mode, trueop1)
    3762                 :     160992 :           && ! side_effects_p (op0))
    3763                 :            :         return op1;
    3764                 :     160992 :       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
    3765                 :            :         return op0;
    3766                 :     160960 :       tem = simplify_associative_operation (code, mode, op0, op1);
    3767                 :     160960 :       if (tem)
    3768                 :            :         return tem;
    3769                 :            :       break;
    3770                 :            : 
    3771                 :     129752 :     case SMAX:
    3772                 :     129752 :       if (HWI_COMPUTABLE_MODE_P (mode)
    3773                 :     107476 :           && CONST_INT_P (trueop1)
    3774                 :      96632 :           && (UINTVAL (trueop1) == GET_MODE_MASK (mode) >> 1)
    3775                 :     129752 :           && ! side_effects_p (op0))
    3776                 :            :         return op1;
    3777                 :     129752 :       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
    3778                 :            :         return op0;
    3779                 :     129720 :       tem = simplify_associative_operation (code, mode, op0, op1);
    3780                 :     129720 :       if (tem)
    3781                 :            :         return tem;
    3782                 :            :       break;
    3783                 :            : 
    3784                 :      80091 :     case UMIN:
    3785                 :      80091 :       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
    3786                 :            :         return op1;
    3787                 :      79924 :       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
    3788                 :            :         return op0;
    3789                 :      79900 :       tem = simplify_associative_operation (code, mode, op0, op1);
    3790                 :      79900 :       if (tem)
    3791                 :            :         return tem;
    3792                 :            :       break;
    3793                 :            : 
    3794                 :      20768 :     case UMAX:
    3795                 :      20768 :       if (trueop1 == constm1_rtx && ! side_effects_p (op0))
    3796                 :            :         return op1;
    3797                 :      20768 :       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
    3798                 :            :         return op0;
    3799                 :      20744 :       tem = simplify_associative_operation (code, mode, op0, op1);
    3800                 :      20744 :       if (tem)
    3801                 :            :         return tem;
    3802                 :            :       break;
    3803                 :            : 
    3804                 :            :     case SS_PLUS:
    3805                 :            :     case US_PLUS:
    3806                 :            :     case SS_MINUS:
    3807                 :            :     case US_MINUS:
    3808                 :            :     case SS_MULT:
    3809                 :            :     case US_MULT:
    3810                 :            :     case SS_DIV:
    3811                 :            :     case US_DIV:
    3812                 :            :       /* ??? There are simplifications that can be done.  */
    3813                 :            :       return 0;
    3814                 :            : 
    3815                 :        490 :     case VEC_SERIES:
    3816                 :        980 :       if (op1 == CONST0_RTX (GET_MODE_INNER (mode)))
    3817                 :         48 :         return gen_vec_duplicate (mode, op0);
    3818                 :        442 :       if (valid_for_const_vector_p (mode, op0)
    3819                 :        442 :           && valid_for_const_vector_p (mode, op1))
    3820                 :         48 :         return gen_const_vec_series (mode, op0, op1);
    3821                 :            :       return 0;
    3822                 :            : 
    3823                 :    1619180 :     case VEC_SELECT:
    3824                 :    1619180 :       if (!VECTOR_MODE_P (mode))
    3825                 :            :         {
    3826                 :     432056 :           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
    3827                 :     864112 :           gcc_assert (mode == GET_MODE_INNER (GET_MODE (trueop0)));
    3828                 :     432056 :           gcc_assert (GET_CODE (trueop1) == PARALLEL);
    3829                 :     432056 :           gcc_assert (XVECLEN (trueop1, 0) == 1);
    3830                 :            : 
    3831                 :            :           /* We can't reason about selections made at runtime.  */
    3832                 :     432056 :           if (!CONST_INT_P (XVECEXP (trueop1, 0, 0)))
    3833                 :  266435000 :             return 0;
    3834                 :            : 
    3835                 :     432056 :           if (vec_duplicate_p (trueop0, &elt0))
    3836                 :        579 :             return elt0;
    3837                 :            : 
    3838                 :     431477 :           if (GET_CODE (trueop0) == CONST_VECTOR)
    3839                 :       5739 :             return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP
    3840                 :            :                                                       (trueop1, 0, 0)));
    3841                 :            : 
    3842                 :            :           /* Extract a scalar element from a nested VEC_SELECT expression
    3843                 :            :              (with optional nested VEC_CONCAT expression).  Some targets
    3844                 :            :              (i386) extract scalar element from a vector using chain of
    3845                 :            :              nested VEC_SELECT expressions.  When input operand is a memory
    3846                 :            :              operand, this operation can be simplified to a simple scalar
    3847                 :            :              load from an offseted memory address.  */
    3848                 :     425738 :           int n_elts;
    3849                 :     425738 :           if (GET_CODE (trueop0) == VEC_SELECT
    3850                 :     425738 :               && (GET_MODE_NUNITS (GET_MODE (XEXP (trueop0, 0)))
    3851                 :      55151 :                   .is_constant (&n_elts)))
    3852                 :            :             {
    3853                 :      55151 :               rtx op0 = XEXP (trueop0, 0);
    3854                 :      55151 :               rtx op1 = XEXP (trueop0, 1);
    3855                 :            : 
    3856                 :      55151 :               int i = INTVAL (XVECEXP (trueop1, 0, 0));
    3857                 :      55151 :               int elem;
    3858                 :            : 
    3859                 :      55151 :               rtvec vec;
    3860                 :      55151 :               rtx tmp_op, tmp;
    3861                 :            : 
    3862                 :      55151 :               gcc_assert (GET_CODE (op1) == PARALLEL);
    3863                 :      55151 :               gcc_assert (i < n_elts);
    3864                 :            : 
    3865                 :            :               /* Select element, pointed by nested selector.  */
    3866                 :      55151 :               elem = INTVAL (XVECEXP (op1, 0, i));
    3867                 :            : 
    3868                 :            :               /* Handle the case when nested VEC_SELECT wraps VEC_CONCAT.  */
    3869                 :      55151 :               if (GET_CODE (op0) == VEC_CONCAT)
    3870                 :            :                 {
    3871                 :      14145 :                   rtx op00 = XEXP (op0, 0);
    3872                 :      14145 :                   rtx op01 = XEXP (op0, 1);
    3873                 :            : 
    3874                 :      14145 :                   machine_mode mode00, mode01;
    3875                 :      14145 :                   int n_elts00, n_elts01;
    3876                 :            : 
    3877                 :      14145 :                   mode00 = GET_MODE (op00);
    3878                 :      14145 :                   mode01 = GET_MODE (op01);
    3879                 :            : 
    3880                 :            :                   /* Find out the number of elements of each operand.
    3881                 :            :                      Since the concatenated result has a constant number
    3882                 :            :                      of elements, the operands must too.  */
    3883                 :      28290 :                   n_elts00 = GET_MODE_NUNITS (mode00).to_constant ();
    3884                 :      28290 :                   n_elts01 = GET_MODE_NUNITS (mode01).to_constant ();
    3885                 :            : 
    3886                 :      14145 :                   gcc_assert (n_elts == n_elts00 + n_elts01);
    3887                 :            : 
    3888                 :            :                   /* Select correct operand of VEC_CONCAT
    3889                 :            :                      and adjust selector. */
    3890                 :      14145 :                   if (elem < n_elts01)
    3891                 :            :                     tmp_op = op00;
    3892                 :            :                   else
    3893                 :            :                     {
    3894                 :          8 :                       tmp_op = op01;
    3895                 :          8 :                       elem -= n_elts00;
    3896                 :            :                     }
    3897                 :            :                 }
    3898                 :            :               else
    3899                 :            :                 tmp_op = op0;
    3900                 :            : 
    3901                 :      55151 :               vec = rtvec_alloc (1);
    3902                 :      55151 :               RTVEC_ELT (vec, 0) = GEN_INT (elem);
    3903                 :            : 
    3904                 :      55151 :               tmp = gen_rtx_fmt_ee (code, mode,
    3905                 :            :                                     tmp_op, gen_rtx_PARALLEL (VOIDmode, vec));
    3906                 :      55151 :               return tmp;
    3907                 :            :             }
    3908                 :            :         }
    3909                 :            :       else
    3910                 :            :         {
    3911                 :    1187120 :           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
    3912                 :    3561370 :           gcc_assert (GET_MODE_INNER (mode)
    3913                 :            :                       == GET_MODE_INNER (GET_MODE (trueop0)));
    3914                 :    1187120 :           gcc_assert (GET_CODE (trueop1) == PARALLEL);
    3915                 :            : 
    3916                 :    1187120 :           if (vec_duplicate_p (trueop0, &elt0))
    3917                 :            :             /* It doesn't matter which elements are selected by trueop1,
    3918                 :            :                because they are all the same.  */
    3919                 :       6698 :             return gen_vec_duplicate (mode, elt0);
    3920                 :            : 
    3921                 :    1180420 :           if (GET_CODE (trueop0) == CONST_VECTOR)
    3922                 :            :             {
    3923                 :      10169 :               unsigned n_elts = XVECLEN (trueop1, 0);
    3924                 :      10169 :               rtvec v = rtvec_alloc (n_elts);
    3925                 :      10169 :               unsigned int i;
    3926                 :            : 
    3927                 :      20338 :               gcc_assert (known_eq (n_elts, GET_MODE_NUNITS (mode)));
    3928                 :      77525 :               for (i = 0; i < n_elts; i++)
    3929                 :            :                 {
    3930                 :      67356 :                   rtx x = XVECEXP (trueop1, 0, i);
    3931                 :            : 
    3932                 :      67356 :                   if (!CONST_INT_P (x))
    3933                 :            :                     return 0;
    3934                 :            : 
    3935                 :      67356 :                   RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0,
    3936                 :            :                                                        INTVAL (x));
    3937                 :            :                 }
    3938                 :            : 
    3939                 :      10169 :               return gen_rtx_CONST_VECTOR (mode, v);
    3940                 :            :             }
    3941                 :            : 
    3942                 :            :           /* Recognize the identity.  */
    3943                 :    1170260 :           if (GET_MODE (trueop0) == mode)
    3944                 :            :             {
    3945                 :     307087 :               bool maybe_ident = true;
    3946                 :     307087 :               for (int i = 0; i < XVECLEN (trueop1, 0); i++)
    3947                 :            :                 {
    3948                 :     307061 :                   rtx j = XVECEXP (trueop1, 0, i);
    3949                 :     307061 :                   if (!CONST_INT_P (j) || INTVAL (j) != i)
    3950                 :            :                     {
    3951                 :            :                       maybe_ident = false;
    3952                 :            :                       break;
    3953                 :            :                     }
    3954                 :            :                 }
    3955                 :     190277 :               if (maybe_ident)
    3956                 :            :                 return trueop0;
    3957                 :            :             }
    3958                 :            : 
    3959                 :            :           /* If we build {a,b} then permute it, build the result directly.  */
    3960                 :    1170230 :           if (XVECLEN (trueop1, 0) == 2
    3961                 :     308219 :               && CONST_INT_P (XVECEXP (trueop1, 0, 0))
    3962                 :     308219 :               && CONST_INT_P (XVECEXP (trueop1, 0, 1))
    3963                 :     308219 :               && GET_CODE (trueop0) == VEC_CONCAT
    3964                 :      58017 :               && GET_CODE (XEXP (trueop0, 0)) == VEC_CONCAT
    3965                 :         42 :               && GET_MODE (XEXP (trueop0, 0)) == mode
    3966                 :         42 :               && GET_CODE (XEXP (trueop0, 1)) == VEC_CONCAT
    3967                 :         27 :               && GET_MODE (XEXP (trueop0, 1)) == mode)
    3968                 :            :             {
    3969                 :         27 :               unsigned int i0 = INTVAL (XVECEXP (trueop1, 0, 0));
    3970                 :         27 :               unsigned int i1 = INTVAL (XVECEXP (trueop1, 0, 1));
    3971                 :         27 :               rtx subop0, subop1;
    3972                 :            : 
    3973                 :         27 :               gcc_assert (i0 < 4 && i1 < 4);
    3974                 :         27 :               subop0 = XEXP (XEXP (trueop0, i0 / 2), i0 % 2);
    3975                 :         27 :               subop1 = XEXP (XEXP (trueop0, i1 / 2), i1 % 2);
    3976                 :            : 
    3977                 :         27 :               return simplify_gen_binary (VEC_CONCAT, mode, subop0, subop1);
    3978                 :            :             }
    3979                 :            : 
    3980                 :    1170200 :           if (XVECLEN (trueop1, 0) == 2
    3981                 :     308192 :               && CONST_INT_P (XVECEXP (trueop1, 0, 0))
    3982                 :     308192 :               && CONST_INT_P (XVECEXP (trueop1, 0, 1))
    3983                 :     308192 :               && GET_CODE (trueop0) == VEC_CONCAT
    3984                 :      57990 :               && GET_MODE (trueop0) == mode)
    3985                 :            :             {
    3986                 :          2 :               unsigned int i0 = INTVAL (XVECEXP (trueop1, 0, 0));
    3987                 :          2 :               unsigned int i1 = INTVAL (XVECEXP (trueop1, 0, 1));
    3988                 :          2 :               rtx subop0, subop1;
    3989                 :            : 
    3990                 :          2 :               gcc_assert (i0 < 2 && i1 < 2);
    3991                 :          2 :               subop0 = XEXP (trueop0, i0);
    3992                 :          2 :               subop1 = XEXP (trueop0, i1);
    3993                 :            : 
    3994                 :          2 :               return simplify_gen_binary (VEC_CONCAT, mode, subop0, subop1);
    3995                 :            :             }
    3996                 :            : 
    3997                 :            :           /* If we select one half of a vec_concat, return that.  */
    3998                 :    1170200 :           int l0, l1;
    3999                 :    1170200 :           if (GET_CODE (trueop0) == VEC_CONCAT
    4000                 :     609556 :               && (GET_MODE_NUNITS (GET_MODE (XEXP (trueop0, 0)))
    4001                 :     609556 :                   .is_constant (&l0))
    4002                 :     609556 :               && (GET_MODE_NUNITS (GET_MODE (XEXP (trueop0, 1)))
    4003                 :     609556 :                   .is_constant (&l1))
    4004                 :    1779760 :               && CONST_INT_P (XVECEXP (trueop1, 0, 0)))
    4005                 :            :             {
    4006                 :     609556 :               rtx subop0 = XEXP (trueop0, 0);
    4007                 :     609556 :               rtx subop1 = XEXP (trueop0, 1);
    4008                 :     609556 :               machine_mode mode0 = GET_MODE (subop0);
    4009                 :     609556 :               machine_mode mode1 = GET_MODE (subop1);
    4010                 :     609556 :               int i0 = INTVAL (XVECEXP (trueop1, 0, 0));
    4011                 :     609556 :               if (i0 == 0 && !side_effects_p (op1) && mode == mode0)
    4012                 :            :                 {
    4013                 :     393197 :                   bool success = true;
    4014                 :     393197 :                   for (int i = 1; i < l0; ++i)
    4015                 :            :                     {
    4016                 :     392202 :                       rtx j = XVECEXP (trueop1, 0, i);
    4017                 :     392202 :                       if (!CONST_INT_P (j) || INTVAL (j) != i)
    4018                 :            :                         {
    4019                 :            :                           success = false;
    4020                 :            :                           break;
    4021                 :            :                         }
    4022                 :            :                     }
    4023                 :     337324 :                   if (success)
    4024                 :            :                     return subop0;
    4025                 :            :                 }
    4026                 :     608561 :               if (i0 == l0 && !side_effects_p (op0) && mode == mode1)
    4027                 :            :                 {
    4028                 :       2784 :                   bool success = true;
    4029                 :       2784 :                   for (int i = 1; i < l1; ++i)
    4030                 :            :                     {
    4031                 :       2256 :                       rtx j = XVECEXP (trueop1, 0, i);
    4032                 :       2256 :                       if (!CONST_INT_P (j) || INTVAL (j) != i0 + i)
    4033                 :            :                         {
    4034                 :            :                           success = false;
    4035                 :            :                           break;
    4036                 :            :                         }
    4037                 :            :                     }
    4038                 :        528 :                   if (success)
    4039                 :            :                     return subop1;
    4040                 :            :                 }
    4041                 :            :             }
    4042                 :            :         }
    4043                 :            : 
    4044                 :    1539260 :       if (XVECLEN (trueop1, 0) == 1
    4045                 :     370659 :           && CONST_INT_P (XVECEXP (trueop1, 0, 0))
    4046                 :     370659 :           && GET_CODE (trueop0) == VEC_CONCAT)
    4047                 :            :         {
    4048                 :        161 :           rtx vec = trueop0;
    4049                 :        322 :           offset = INTVAL (XVECEXP (trueop1, 0, 0)) * GET_MODE_SIZE (mode);
    4050                 :            : 
    4051                 :            :           /* Try to find the element in the VEC_CONCAT.  */
    4052                 :        322 :           while (GET_MODE (vec) != mode
    4053                 :        322 :                  && GET_CODE (vec) == VEC_CONCAT)
    4054                 :            :             {
    4055                 :        161 :               poly_int64 vec_size;
    4056                 :            : 
    4057                 :        161 :               if (CONST_INT_P (XEXP (vec, 0)))
    4058                 :            :                 {
    4059                 :            :                   /* vec_concat of two const_ints doesn't make sense with
    4060                 :            :                      respect to modes.  */
    4061                 :          0 :                   if (CONST_INT_P (XEXP (vec, 1)))
    4062                 :          0 :                     return 0;
    4063                 :            : 
    4064                 :          0 :                   vec_size = GET_MODE_SIZE (GET_MODE (trueop0))
    4065                 :          0 :                              - GET_MODE_SIZE (GET_MODE (XEXP (vec, 1)));
    4066                 :            :                 }
    4067                 :            :               else
    4068                 :        322 :                 vec_size = GET_MODE_SIZE (GET_MODE (XEXP (vec, 0)));
    4069                 :            : 
    4070                 :        161 :               if (known_lt (offset, vec_size))
    4071                 :        139 :                 vec = XEXP (vec, 0);
    4072                 :         22 :               else if (known_ge (offset, vec_size))
    4073                 :            :                 {
    4074                 :         22 :                   offset -= vec_size;
    4075                 :         22 :                   vec = XEXP (vec, 1);
    4076                 :            :                 }
    4077                 :            :               else
    4078                 :            :                 break;
    4079                 :        161 :               vec = avoid_constant_pool_reference (vec);
    4080                 :            :             }
    4081                 :            : 
    4082                 :        161 :           if (GET_MODE (vec) == mode)
    4083                 :            :             return vec;
    4084                 :            :         }
    4085                 :            : 
    4086                 :            :       /* If we select elements in a vec_merge that all come from the same
    4087                 :            :          operand, select from that operand directly.  */
    4088                 :    1539150 :       if (GET_CODE (op0) == VEC_MERGE)
    4089                 :            :         {
    4090                 :       2126 :           rtx trueop02 = avoid_constant_pool_reference (XEXP (op0, 2));
    4091                 :       2126 :           if (CONST_INT_P (trueop02))
    4092                 :            :             {
    4093                 :       1283 :               unsigned HOST_WIDE_INT sel = UINTVAL (trueop02);
    4094                 :       1283 :               bool all_operand0 = true;
    4095                 :       1283 :               bool all_operand1 = true;
    4096                 :       5203 :               for (int i = 0; i < XVECLEN (trueop1, 0); i++)
    4097                 :            :                 {
    4098                 :       3920 :                   rtx j = XVECEXP (trueop1, 0, i);
    4099                 :       3920 :                   if (sel & (HOST_WIDE_INT_1U << UINTVAL (j)))
    4100                 :            :                     all_operand1 = false;
    4101                 :            :                   else
    4102                 :       2405 :                     all_operand0 = false;
    4103                 :            :                 }
    4104                 :       1283 :               if (all_operand0 && !side_effects_p (XEXP (op0, 1)))
    4105                 :        514 :                 return simplify_gen_binary (VEC_SELECT, mode, XEXP (op0, 0), op1);
    4106                 :        769 :               if (all_operand1 && !side_effects_p (XEXP (op0, 0)))
    4107                 :          2 :                 return simplify_gen_binary (VEC_SELECT, mode, XEXP (op0, 1), op1);
    4108                 :            :             }
    4109                 :            :         }
    4110                 :            : 
    4111                 :            :       /* If we have two nested selects that are inverses of each
    4112                 :            :          other, replace them with the source operand.  */
    4113                 :    1538630 :       if (GET_CODE (trueop0) == VEC_SELECT
    4114                 :      27999 :           && GET_MODE (XEXP (trueop0, 0)) == mode)
    4115                 :            :         {
    4116                 :        303 :           rtx op0_subop1 = XEXP (trueop0, 1);
    4117                 :        303 :           gcc_assert (GET_CODE (op0_subop1) == PARALLEL);
    4118                 :        606 :           gcc_assert (known_eq (XVECLEN (trueop1, 0), GET_MODE_NUNITS (mode)));
    4119                 :            : 
    4120                 :            :           /* Apply the outer ordering vector to the inner one.  (The inner
    4121                 :            :              ordering vector is expressly permitted to be of a different
    4122                 :            :              length than the outer one.)  If the result is { 0, 1, ..., n-1 }
    4123                 :            :              then the two VEC_SELECTs cancel.  */
    4124                 :        397 :           for (int i = 0; i < XVECLEN (trueop1, 0); ++i)
    4125                 :            :             {
    4126                 :        397 :               rtx x = XVECEXP (trueop1, 0, i);
    4127                 :        397 :               if (!CONST_INT_P (x))
    4128                 :            :                 return 0;
    4129                 :        397 :               rtx y = XVECEXP (op0_subop1, 0, INTVAL (x));
    4130                 :        397 :               if (!CONST_INT_P (y) || i != INTVAL (y))
    4131                 :            :                 return 0;
    4132                 :            :             }
    4133                 :          0 :           return XEXP (trueop0, 0);
    4134                 :            :         }
    4135                 :            : 
    4136                 :            :       return 0;
    4137                 :    1060010 :     case VEC_CONCAT:
    4138                 :    1060010 :       {
    4139                 :    1060010 :         machine_mode op0_mode = (GET_MODE (trueop0) != VOIDmode
    4140                 :    1060010 :                                       ? GET_MODE (trueop0)
    4141                 :       3208 :                                       : GET_MODE_INNER (mode));
    4142                 :    1060010 :         machine_mode op1_mode = (GET_MODE (trueop1) != VOIDmode
    4143                 :    1060010 :                                       ? GET_MODE (trueop1)
    4144                 :      30184 :                                       : GET_MODE_INNER (mode));
    4145                 :            : 
    4146                 :    1060010 :         gcc_assert (VECTOR_MODE_P (mode));
    4147                 :    4240030 :         gcc_assert (known_eq (GET_MODE_SIZE (op0_mode)
    4148                 :            :                               + GET_MODE_SIZE (op1_mode),
    4149                 :            :                               GET_MODE_SIZE (mode)));
    4150                 :            : 
    4151                 :    1060010 :         if (VECTOR_MODE_P (op0_mode))
    4152                 :    2574170 :           gcc_assert (GET_MODE_INNER (mode)
    4153                 :            :                       == GET_MODE_INNER (op0_mode));
    4154                 :            :         else
    4155                 :     403900 :           gcc_assert (GET_MODE_INNER (mode) == op0_mode);
    4156                 :            : 
    4157                 :    1060010 :         if (VECTOR_MODE_P (op1_mode))
    4158                 :    2574170 :           gcc_assert (GET_MODE_INNER (mode)
    4159                 :            :                       == GET_MODE_INNER (op1_mode));
    4160                 :            :         else
    4161                 :     403900 :           gcc_assert (GET_MODE_INNER (mode) == op1_mode);
    4162                 :            : 
    4163                 :    1060010 :         unsigned int n_elts, in_n_elts;
    4164                 :    1060010 :         if ((GET_CODE (trueop0) == CONST_VECTOR
    4165                 :    1053840 :              || CONST_SCALAR_INT_P (trueop0) 
    4166                 :    1050630 :              || CONST_DOUBLE_AS_FLOAT_P (trueop0))
    4167                 :       9696 :             && (GET_CODE (trueop1) == CONST_VECTOR
    4168                 :       7971 :                 || CONST_SCALAR_INT_P (trueop1) 
    4169                 :       7971 :                 || CONST_DOUBLE_AS_FLOAT_P (trueop1))
    4170                 :       3450 :             && GET_MODE_NUNITS (mode).is_constant (&n_elts)
    4171                 :    1061730 :             && GET_MODE_NUNITS (op0_mode).is_constant (&in_n_elts))
    4172                 :            :           {
    4173                 :       1725 :             rtvec v = rtvec_alloc (n_elts);
    4174                 :       1725 :             unsigned int i;
    4175                 :      17017 :             for (i = 0; i < n_elts; i++)
    4176                 :            :               {
    4177                 :      15292 :                 if (i < in_n_elts)
    4178                 :            :                   {
    4179                 :       7630 :                     if (!VECTOR_MODE_P (op0_mode))
    4180                 :          0 :                       RTVEC_ELT (v, i) = trueop0;
    4181                 :            :                     else
    4182                 :       7630 :                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, i);
    4183                 :            :                   }
    4184                 :            :                 else
    4185                 :            :                   {
    4186                 :       7662 :                     if (!VECTOR_MODE_P (op1_mode))
    4187                 :          0 :                       RTVEC_ELT (v, i) = trueop1;
    4188                 :            :                     else
    4189                 :       7662 :                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop1,
    4190                 :            :                                                            i - in_n_elts);
    4191                 :            :                   }
    4192                 :            :               }
    4193                 :            : 
    4194                 :       1725 :             return gen_rtx_CONST_VECTOR (mode, v);
    4195                 :            :           }
    4196                 :            : 
    4197                 :            :         /* Try to merge two VEC_SELECTs from the same vector into a single one.
    4198                 :            :            Restrict the transformation to avoid generating a VEC_SELECT with a
    4199                 :            :            mode unrelated to its operand.  */
    4200                 :    1058280 :         if (GET_CODE (trueop0) == VEC_SELECT
    4201                 :      43119 :             && GET_CODE (trueop1) == VEC_SELECT
    4202                 :      11056 :             && rtx_equal_p (XEXP (trueop0, 0), XEXP (trueop1, 0))
    4203                 :    1065260 :             && GET_MODE (XEXP (trueop0, 0)) == mode)
    4204                 :            :           {
    4205                 :       6966 :             rtx par0 = XEXP (trueop0, 1);
    4206                 :       6966 :             rtx par1 = XEXP (trueop1, 1);
    4207                 :       6966 :             int len0 = XVECLEN (par0, 0);
    4208                 :       6966 :             int len1 = XVECLEN (par1, 0);
    4209                 :       6966 :             rtvec vec = rtvec_alloc (len0 + len1);
    4210                 :      55591 :             for (int i = 0; i < len0; i++)
    4211                 :      48625 :               RTVEC_ELT (vec, i) = XVECEXP (par0, 0, i);
    4212                 :      55591 :             for (int i = 0; i < len1; i++)
    4213                 :      48625 :               RTVEC_ELT (vec, len0 + i) = XVECEXP (par1, 0, i);
    4214                 :       6966 :             return simplify_gen_binary (VEC_SELECT, mode, XEXP (trueop0, 0),
    4215                 :       6966 :                                         gen_rtx_PARALLEL (VOIDmode, vec));
    4216                 :            :           }
    4217                 :            :       }
    4218                 :            :       return 0;
    4219                 :            : 
    4220                 :          0 :     default:
    4221                 :          0 :       gcc_unreachable ();
    4222                 :            :     }
    4223                 :            : 
    4224                 :  231358000 :   if (mode == GET_MODE (op0)
    4225                 :  203006000 :       && mode == GET_MODE (op1)
    4226                 :   88449100 :       && vec_duplicate_p (op0, &elt0)
    4227                 :  231368000 :       && vec_duplicate_p (op1, &elt1))
    4228                 :            :     {
    4229                 :            :       /* Try applying the operator to ELT and see if that simplifies.
    4230                 :            :          We can duplicate the result if so.
    4231                 :            : 
    4232                 :            :          The reason we don't use simplify_gen_binary is that it isn't
    4233                 :            :          necessarily a win to convert things like:
    4234                 :            : 
    4235                 :            :            (plus:V (vec_duplicate:V (reg:S R1))
    4236                 :            :                    (vec_duplicate:V (reg:S R2)))
    4237                 :            : 
    4238                 :            :          to:
    4239                 :            : 
    4240                 :            :            (vec_duplicate:V (plus:S (reg:S R1) (reg:S R2)))
    4241                 :            : 
    4242                 :            :          The first might be done entirely in vector registers while the
    4243                 :            :          second might need a move between register files.  */
    4244                 :        124 :       tem = simplify_binary_operation (code, GET_MODE_INNER (mode),
    4245                 :            :                                        elt0, elt1);
    4246                 :         62 :       if (tem)
    4247                 :          0 :         return gen_vec_duplicate (mode, tem);
    4248                 :            :     }
    4249                 :            : 
    4250                 :            :   return 0;
    4251                 :            : }
    4252                 :            : 
    4253                 :            : /* Return true if binary operation OP distributes over addition in operand
    4254                 :            :    OPNO, with the other operand being held constant.  OPNO counts from 1.  */
    4255                 :            : 
    4256                 :            : static bool
    4257                 :       2001 : distributes_over_addition_p (rtx_code op, int opno)
    4258                 :            : {
    4259                 :       2001 :   switch (op)
    4260                 :            :     {
    4261                 :            :     case PLUS:
    4262                 :            :     case MINUS:
    4263                 :            :     case MULT:
    4264                 :            :       return true;
    4265                 :            : 
    4266                 :         48 :     case ASHIFT:
    4267                 :         48 :       return opno == 1;
    4268                 :            : 
    4269                 :        750 :     default:
    4270                 :        750 :       return false;
    4271                 :            :     }
    4272                 :            : }
    4273                 :            : 
    4274                 :            : rtx
    4275                 :  285268000 : simplify_const_binary_operation (enum rtx_code code, machine_mode mode,
    4276                 :            :                                  rtx op0, rtx op1)
    4277                 :            : {
    4278                 :  285268000 :   if (VECTOR_MODE_P (mode)
    4279                 :    5078290 :       && code != VEC_CONCAT
    4280                 :    4014580 :       && GET_CODE (op0) == CONST_VECTOR
    4281                 :      28104 :       && GET_CODE (op1) == CONST_VECTOR)
    4282                 :            :     {
    4283                 :       2238 :       bool step_ok_p;
    4284                 :       2238 :       if (CONST_VECTOR_STEPPED_P (op0)
    4285                 :       2238 :           && CONST_VECTOR_STEPPED_P (op1))
    4286                 :            :         /* We can operate directly on the encoding if:
    4287                 :            : 
    4288                 :            :               a3 - a2 == a2 - a1 && b3 - b2 == b2 - b1
    4289                 :            :             implies
    4290                 :            :               (a3 op b3) - (a2 op b2) == (a2 op b2) - (a1 op b1)
    4291                 :            : 
    4292                 :            :            Addition and subtraction are the supported operators
    4293                 :            :            for which this is true.  */
    4294                 :        237 :         step_ok_p = (code == PLUS || code == MINUS);
    4295                 :       2001 :       else if (CONST_VECTOR_STEPPED_P (op0))
    4296                 :            :         /* We can operate directly on stepped encodings if:
    4297                 :            : 
    4298                 :            :              a3 - a2 == a2 - a1
    4299                 :            :            implies:
    4300                 :            :              (a3 op c) - (a2 op c) == (a2 op c) - (a1 op c)
    4301                 :            : 
    4302                 :            :            which is true if (x -> x op c) distributes over addition.  */
    4303                 :        472 :         step_ok_p = distributes_over_addition_p (code, 1);
    4304                 :            :       else
    4305                 :            :         /* Similarly in reverse.  */
    4306                 :       1529 :         step_ok_p = distributes_over_addition_p (code, 2);
    4307                 :       4476 :       rtx_vector_builder builder;
    4308                 :       2238 :       if (!builder.new_binary_operation (mode, op0, op1, step_ok_p))
    4309                 :            :         return 0;
    4310                 :            : 
    4311                 :       2238 :       unsigned int count = builder.encoded_nelts ();
    4312                 :       9781 :       for (unsigned int i = 0; i < count; i++)
    4313                 :            :         {
    4314                 :      15536 :           rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
    4315                 :            :                                              CONST_VECTOR_ELT (op0, i),
    4316                 :       7768 :                                              CONST_VECTOR_ELT (op1, i));
    4317                 :       7768 :           if (!x || !valid_for_const_vector_p (mode, x))
    4318                 :        225 :             return 0;
    4319                 :       7543 :           builder.quick_push (x);
    4320                 :            :         }
    4321                 :       2013 :       return builder.build ();
    4322                 :            :     }
    4323                 :            : 
    4324                 :  285266000 :   if (VECTOR_MODE_P (mode)
    4325                 :    5076050 :       && code == VEC_CONCAT
    4326                 :    1063710 :       && (CONST_SCALAR_INT_P (op0)
    4327                 :    1058420 :           || CONST_FIXED_P (op0)
    4328                 :    1058420 :           || CONST_DOUBLE_AS_FLOAT_P (op0))
    4329                 :       7230 :       && (CONST_SCALAR_INT_P (op1)
    4330                 :       5148 :           || CONST_DOUBLE_AS_FLOAT_P (op1)
    4331                 :       3528 :           || CONST_FIXED_P (op1)))
    4332                 :            :     {
    4333                 :            :       /* Both inputs have a constant number of elements, so the result
    4334                 :            :          must too.  */
    4335                 :       7404 :       unsigned n_elts = GET_MODE_NUNITS (mode).to_constant ();
    4336                 :       3702 :       rtvec v = rtvec_alloc (n_elts);
    4337                 :            : 
    4338                 :       3702 :       gcc_assert (n_elts >= 2);
    4339                 :       3702 :       if (n_elts == 2)
    4340                 :            :         {
    4341                 :       3702 :           gcc_assert (GET_CODE (op0) != CONST_VECTOR);
    4342                 :       3702 :           gcc_assert (GET_CODE (op1) != CONST_VECTOR);
    4343                 :            : 
    4344                 :       3702 :           RTVEC_ELT (v, 0) = op0;
    4345                 :       3702 :           RTVEC_ELT (v, 1) = op1;
    4346                 :            :         }
    4347                 :            :       else
    4348                 :            :         {
    4349                 :          0 :           unsigned op0_n_elts = GET_MODE_NUNITS (GET_MODE (op0)).to_constant ();
    4350                 :          0 :           unsigned op1_n_elts = GET_MODE_NUNITS (GET_MODE (op1)).to_constant ();
    4351                 :          0 :           unsigned i;
    4352                 :            : 
    4353                 :          0 :           gcc_assert (GET_CODE (op0) == CONST_VECTOR);
    4354                 :          0 :           gcc_assert (GET_CODE (op1) == CONST_VECTOR);
    4355                 :          0 :           gcc_assert (op0_n_elts + op1_n_elts == n_elts);
    4356                 :            : 
    4357                 :          0 :           for (i = 0; i < op0_n_elts; ++i)
    4358                 :          0 :             RTVEC_ELT (v, i) = CONST_VECTOR_ELT (op0, i);
    4359                 :          0 :           for (i = 0; i < op1_n_elts; ++i)
    4360                 :          0 :             RTVEC_ELT (v, op0_n_elts+i) = CONST_VECTOR_ELT (op1, i);
    4361                 :            :         }
    4362                 :            : 
    4363                 :       3702 :       return gen_rtx_CONST_VECTOR (mode, v);
    4364                 :            :     }
    4365                 :            : 
    4366                 :  285262000 :   if (SCALAR_FLOAT_MODE_P (mode)
    4367                 :    3466930 :       && CONST_DOUBLE_AS_FLOAT_P (op0) 
    4368                 :      42539 :       && CONST_DOUBLE_AS_FLOAT_P (op1)
    4369                 :       8575 :       && mode == GET_MODE (op0) && mode == GET_MODE (op1))
    4370                 :            :     {
    4371                 :       8575 :       if (code == AND
    4372                 :            :           || code == IOR
    4373                 :       8575 :           || code == XOR)
    4374                 :            :         {
    4375                 :        638 :           long tmp0[4];
    4376                 :        638 :           long tmp1[4];
    4377                 :        638 :           REAL_VALUE_TYPE r;
    4378                 :        638 :           int i;
    4379                 :            : 
    4380                 :        638 :           real_to_target (tmp0, CONST_DOUBLE_REAL_VALUE (op0),
    4381                 :        638 :                           GET_MODE (op0));
    4382                 :        638 :           real_to_target (tmp1, CONST_DOUBLE_REAL_VALUE (op1),
    4383                 :        638 :                           GET_MODE (op1));
    4384                 :       3190 :           for (i = 0; i < 4; i++)
    4385                 :            :             {
    4386                 :       2552 :               switch (code)
    4387                 :            :               {
    4388                 :       1640 :               case AND:
    4389                 :       1640 :                 tmp0[i] &= tmp1[i];
    4390                 :       1640 :                 break;
    4391                 :        544 :               case IOR:
    4392                 :        544 :                 tmp0[i] |= tmp1[i];
    4393                 :        544 :                 break;
    4394                 :        368 :               case XOR:
    4395                 :        368 :                 tmp0[i] ^= tmp1[i];
    4396                 :        368 :                 break;
    4397                 :            :               default:
    4398                 :            :                 gcc_unreachable ();
    4399                 :            :               }
    4400                 :            :             }
    4401                 :        638 :            real_from_target (&r, tmp0, mode);
    4402                 :        638 :            return const_double_from_real_value (r, mode);
    4403                 :            :         }
    4404                 :            :       else
    4405                 :            :         {
    4406                 :       7937 :           REAL_VALUE_TYPE f0, f1, value, result;
    4407                 :       7937 :           const REAL_VALUE_TYPE *opr0, *opr1;
    4408                 :       7937 :           bool inexact;
    4409                 :            : 
    4410                 :       7937 :           opr0 = CONST_DOUBLE_REAL_VALUE (op0);
    4411                 :       7937 :           opr1 = CONST_DOUBLE_REAL_VALUE (op1);
    4412                 :            : 
    4413                 :       7937 :           if (HONOR_SNANS (mode)
    4414                 :       7937 :               && (REAL_VALUE_ISSIGNALING_NAN (*opr0)
    4415                 :        735 :                   || REAL_VALUE_ISSIGNALING_NAN (*opr1)))
    4416                 :         10 :             return 0;
    4417                 :            : 
    4418                 :       7927 :           real_convert (&f0, mode, opr0);
    4419                 :       7927 :           real_convert (&f1, mode, opr1);
    4420                 :            : 
    4421                 :       7927 :           if (code == DIV
    4422                 :       3769 :               && real_equal (&f1, &dconst0)
    4423                 :      11483 :               && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
    4424                 :       3556 :             return 0;
    4425                 :            : 
    4426                 :      21782 :           if (MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
    4427                 :       4304 :               && flag_trapping_math
    4428                 :       8547 :               && REAL_VALUE_ISINF (f0) && REAL_VALUE_ISINF (f1))
    4429                 :            :             {
    4430                 :          0 :               int s0 = REAL_VALUE_NEGATIVE (f0);
    4431                 :          0 :               int s1 = REAL_VALUE_NEGATIVE (f1);
    4432                 :            : 
    4433                 :          0 :               switch (code)
    4434                 :            :                 {
    4435                 :          0 :                 case PLUS:
    4436                 :            :                   /* Inf + -Inf = NaN plus exception.  */
    4437                 :          0 :                   if (s0 != s1)
    4438                 :            :                     return 0;
    4439                 :            :                   break;
    4440                 :          0 :                 case MINUS:
    4441                 :            :                   /* Inf - Inf = NaN plus exception.  */
    4442                 :          0 :                   if (s0 == s1)
    4443                 :            :                     return 0;
    4444                 :            :                   break;
    4445                 :            :                 case DIV:
    4446                 :            :                   /* Inf / Inf = NaN plus exception.  */
    4447                 :            :                   return 0;
    4448                 :            :                 default:
    4449                 :            :                   break;
    4450                 :            :                 }
    4451                 :            :             }
    4452                 :            : 
    4453                 :       7766 :           if (code == MULT && MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
    4454                 :       1911 :               && flag_trapping_math
    4455                 :       6211 :               && ((REAL_VALUE_ISINF (f0) && real_equal (&f1, &dconst0))
    4456                 :       1840 :                   || (REAL_VALUE_ISINF (f1)
    4457                 :          0 :                       && real_equal (&f0, &dconst0))))
    4458                 :            :             /* Inf * 0 = NaN plus exception.  */
    4459                 :          0 :             return 0;
    4460                 :            : 
    4461                 :       4371 :           inexact = real_arithmetic (&value, rtx_to_tree_code (code),
    4462                 :            :                                      &f0, &f1);
    4463                 :       4371 :           real_convert (&result, mode, &value);
    4464                 :            : 
    4465                 :            :           /* Don't constant fold this floating point operation if
    4466                 :            :              the result has overflowed and flag_trapping_math.  */
    4467                 :            : 
    4468                 :       4371 :           if (flag_trapping_math
    4469                 :      16698 :               && MODE_HAS_INFINITIES (mode)
    4470                 :       4176 :               && REAL_VALUE_ISINF (result)
    4471                 :       1321 :               && !REAL_VALUE_ISINF (f0)
    4472                 :       5692 :               && !REAL_VALUE_ISINF (f1))
    4473                 :            :             /* Overflow plus exception.  */
    4474                 :       1321 :             return 0;
    4475                 :            : 
    4476                 :            :           /* Don't constant fold this floating point operation if the
    4477                 :            :              result may dependent upon the run-time rounding mode and
    4478                 :            :              flag_rounding_math is set, or if GCC's software emulation
    4479                 :            :              is unable to accurately represent the result.  */
    4480                 :            : 
    4481                 :       3050 :           if ((flag_rounding_math
    4482                 :      20071 :                || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
    4483                 :       3050 :               && (inexact || !real_identical (&result, &value)))
    4484                 :        176 :             return NULL_RTX;
    4485                 :            : 
    4486                 :       2874 :           return const_double_from_real_value (result, mode);
    4487                 :            :         }
    4488                 :            :     }
    4489                 :            : 
    4490                 :            :   /* We can fold some multi-word operations.  */
    4491                 :  285254000 :   scalar_int_mode int_mode;
    4492                 :  285254000 :   if (is_a <scalar_int_mode> (mode, &int_mode)
    4493                 :  250610000 :       && CONST_SCALAR_INT_P (op0)
    4494                 :   21313800 :       && CONST_SCALAR_INT_P (op1)
    4495                 :  304078000 :       && GET_MODE_PRECISION (int_mode) <= MAX_BITSIZE_MODE_ANY_INT)
    4496                 :            :     {
    4497                 :   18824600 :       wide_int result;
    4498                 :   18824600 :       wi::overflow_type overflow;
    4499                 :   18824600 :       rtx_mode_t pop0 = rtx_mode_t (op0, int_mode);
    4500                 :   18824600 :       rtx_mode_t pop1 = rtx_mode_t (op1, int_mode);
    4501                 :            : 
    4502                 :            : #if TARGET_SUPPORTS_WIDE_INT == 0
    4503                 :            :       /* This assert keeps the simplification from producing a result
    4504                 :            :          that cannot be represented in a CONST_DOUBLE but a lot of
    4505                 :            :          upstream callers expect that this function never fails to
    4506                 :            :          simplify something and so you if you added this to the test
    4507                 :            :          above the code would die later anyway.  If this assert
    4508                 :            :          happens, you just need to make the port support wide int.  */
    4509                 :            :       gcc_assert (GET_MODE_PRECISION (int_mode) <= HOST_BITS_PER_DOUBLE_INT);
    4510                 :            : #endif
    4511                 :   18824600 :       switch (code)
    4512                 :            :         {
    4513                 :     291868 :         case MINUS:
    4514                 :     291868 :           result = wi::sub (pop0, pop1);
    4515                 :     291868 :           break;
    4516                 :            : 
    4517                 :   15266800 :         case PLUS:
    4518                 :   15266800 :           result = wi::add (pop0, pop1);
    4519                 :   15266800 :           break;
    4520                 :            : 
    4521                 :     123913 :         case MULT:
    4522                 :     123913 :           result = wi::mul (pop0, pop1);
    4523                 :     123913 :           break;
    4524                 :            : 
    4525                 :       1659 :         case DIV:
    4526                 :       1659 :           result = wi::div_trunc (pop0, pop1, SIGNED, &overflow);
    4527                 :       1659 :           if (overflow)
    4528                 :            :             return NULL_RTX;
    4529                 :            :           break;
    4530                 :            : 
    4531                 :        142 :         case MOD:
    4532                 :        142 :           result = wi::mod_trunc (pop0, pop1, SIGNED, &overflow);
    4533                 :        142 :           if (overflow)
    4534                 :            :             return NULL_RTX;
    4535                 :            :           break;
    4536                 :            : 
    4537                 :       2629 :         case UDIV:
    4538                 :       2629 :           result = wi::div_trunc (pop0, pop1, UNSIGNED, &overflow);
    4539                 :       2629 :           if (overflow)
    4540                 :            :             return NULL_RTX;
    4541                 :            :           break;
    4542                 :            : 
    4543                 :       2569 :         case UMOD:
    4544                 :       2569 :           result = wi::mod_trunc (pop0, pop1, UNSIGNED, &overflow);
    4545                 :       2569 :           if (overflow)
    4546                 :            :             return NULL_RTX;
    4547                 :            :           break;
    4548                 :            : 
    4549                 :      82975 :         case AND:
    4550                 :      82975 :           result = wi::bit_and (pop0, pop1);
    4551                 :      82975 :           break;
    4552                 :            : 
    4553                 :      90851 :         case IOR:
    4554                 :      90851 :           result = wi::bit_or (pop0, pop1);
    4555                 :      90851 :           break;
    4556                 :            : 
    4557                 :      21234 :         case XOR:
    4558                 :      21234 :           result = wi::bit_xor (pop0, pop1);
    4559                 :      21234 :           break;
    4560                 :            : 
    4561                 :        205 :         case SMIN:
    4562                 :        205 :           result = wi::smin (pop0, pop1);
    4563                 :        205 :           break;
    4564                 :            : 
    4565                 :        243 :         case SMAX:
    4566                 :        243 :           result = wi::smax (pop0, pop1);
    4567                 :        243 :           break;
    4568                 :            : 
    4569                 :        376 :         case UMIN:
    4570                 :        376 :           result = wi::umin (pop0, pop1);
    4571                 :        376 :           break;
    4572                 :            : 
    4573                 :        266 :         case UMAX:
    4574                 :        266 :           result = wi::umax (pop0, pop1);
    4575                 :        266 :           break;
    4576                 :            : 
    4577                 :    2913780 :         case LSHIFTRT:
    4578                 :    2913780 :         case ASHIFTRT:
    4579                 :    2913780 :         case ASHIFT:
    4580                 :    2913780 :           {
    4581                 :    2913780 :             wide_int wop1 = pop1;
    4582                 :    2913780 :             if (SHIFT_COUNT_TRUNCATED)
    4583                 :            :               wop1 = wi::umod_trunc (wop1, GET_MODE_PRECISION (int_mode));
    4584                 :    2913780 :             else if (wi::geu_p (wop1, GET_MODE_PRECISION (int_mode)))
    4585                 :         27 :               return NULL_RTX;
    4586                 :            : 
    4587                 :    2913750 :             switch (code)
    4588                 :            :               {
    4589                 :    1352880 :               case LSHIFTRT:
    4590                 :    1352880 :                 result = wi::lrshift (pop0, wop1);
    4591                 :    1352880 :                 break;
    4592                 :            : 
    4593                 :      27498 :               case ASHIFTRT:
    4594                 :      27498 :                 result = wi::arshift (pop0, wop1);
    4595                 :      27498 :                 break;
    4596                 :            : 
    4597                 :    1533370 :               case ASHIFT:
    4598                 :    1533370 :                 result = wi::lshift (pop0, wop1);
    4599                 :    1533370 :                 break;
    4600                 :            : 
    4601                 :          0 :               default:
    4602                 :          0 :                 gcc_unreachable ();
    4603                 :            :               }
    4604                 :    2913750 :             break;
    4605                 :            :           }
    4606                 :      25060 :         case ROTATE:
    4607                 :      25060 :         case ROTATERT:
    4608                 :      25060 :           {
    4609                 :      25060 :             if (wi::neg_p (pop1))
    4610                 :            :               return NULL_RTX;
    4611                 :            : 
    4612                 :      25030 :             switch (code)
    4613                 :            :               {
    4614                 :       6429 :               case ROTATE:
    4615                 :       6429 :                 result = wi::lrotate (pop0, pop1);
    4616                 :       6429 :                 break;
    4617                 :            : 
    4618                 :      18601 :               case ROTATERT:
    4619                 :      18601 :                 result = wi::rrotate (pop0, pop1);
    4620                 :      18601 :                 break;
    4621                 :            : 
    4622                 :          0 :               default:
    4623                 :          0 :                 gcc_unreachable ();
    4624                 :            :               }
    4625                 :            :             break;
    4626                 :            :           }
    4627                 :            :         default:
    4628                 :            :           return NULL_RTX;
    4629                 :            :         }
    4630                 :   18824000 :       return immed_wide_int_const (result, int_mode);
    4631                 :            :     }
    4632                 :            : 
    4633                 :            :   /* Handle polynomial integers.  */
    4634                 :            :   if (NUM_POLY_INT_COEFFS > 1
    4635                 :            :       && is_a <scalar_int_mode> (mode, &int_mode)
    4636                 :            :       && poly_int_rtx_p (op0)
    4637                 :            :       && poly_int_rtx_p (op1))
    4638                 :            :     {
    4639                 :            :       poly_wide_int result;
    4640                 :            :       switch (code)
    4641                 :            :         {
    4642                 :            :         case PLUS:
    4643                 :            :           result = wi::to_poly_wide (op0, mode) + wi::to_poly_wide (op1, mode);
    4644                 :            :           break;
    4645                 :            : 
    4646                 :            :         case MINUS:
    4647                 :            :           result = wi::to_poly_wide (op0, mode) - wi::to_poly_wide (op1, mode);
    4648                 :            :           break;
    4649                 :            : 
    4650                 :            :         case MULT:
    4651                 :            :           if (CONST_SCALAR_INT_P (op1))
    4652                 :            :             result = wi::to_poly_wide (op0, mode) * rtx_mode_t (op1, mode);
    4653                 :            :           else
    4654                 :            :             return NULL_RTX;
    4655                 :            :           break;
    4656                 :            : 
    4657                 :            :         case ASHIFT:
    4658                 :            :           if (CONST_SCALAR_INT_P (op1))
    4659                 :            :             {
    4660                 :            :               wide_int shift = rtx_mode_t (op1, mode);
    4661                 :            :               if (SHIFT_COUNT_TRUNCATED)
    4662                 :            :                 shift = wi::umod_trunc (shift, GET_MODE_PRECISION (int_mode));
    4663                 :            :               else if (wi::geu_p (shift, GET_MODE_PRECISION (int_mode)))
    4664                 :            :                 return NULL_RTX;
    4665                 :            :               result = wi::to_poly_wide (op0, mode) << shift;
    4666                 :            :             }
    4667                 :            :           else
    4668                 :            :             return NULL_RTX;
    4669                 :            :           break;
    4670                 :            : 
    4671                 :            :         case IOR:
    4672                 :            :           if (!CONST_SCALAR_INT_P (op1)
    4673                 :            :               || !can_ior_p (wi::to_poly_wide (op0, mode),
    4674                 :            :                              rtx_mode_t (op1, mode), &result))
    4675                 :            :             return NULL_RTX;
    4676                 :            :           break;
    4677                 :            : 
    4678                 :            :         default:
    4679                 :            :           return NULL_RTX;
    4680                 :            :         }
    4681                 :            :       return immed_wide_int_const (result, int_mode);
    4682                 :            :     }
    4683                 :            : 
    4684                 :            :   return NULL_RTX;
    4685                 :            : }
    4686                 :            : 
    4687                 :            : 
    4688                 :            : 
    4689                 :            : /* Return a positive integer if X should sort after Y.  The value
    4690                 :            :    returned is 1 if and only if X and Y are both regs.  */
    4691                 :            : 
    4692                 :            : static int
    4693                 :   62186700 : simplify_plus_minus_op_data_cmp (rtx x, rtx y)
    4694                 :            : {
    4695                 :   62186700 :   int result;
    4696                 :            : 
    4697                 :   62186700 :   result = (commutative_operand_precedence (y)
    4698                 :   62186700 :             - commutative_operand_precedence (x));
    4699                 :   62186700 :   if (result)
    4700                 :   42897400 :     return result + result;
    4701                 :            : 
    4702                 :            :   /* Group together equal REGs to do more simplification.  */
    4703                 :   19289300 :   if (REG_P (x) && REG_P (y))
    4704                 :    3460230 :     return REGNO (x) > REGNO (y);
    4705                 :            : 
    4706                 :            :   return 0;
    4707                 :            : }
    4708                 :            : 
    4709                 :            : /* Simplify and canonicalize a PLUS or MINUS, at least one of whose
    4710                 :            :    operands may be another PLUS or MINUS.
    4711                 :            : 
    4712                 :            :    Rather than test for specific case, we do this by a brute-force method
    4713                 :            :    and do all possible simplifications until no more changes occur.  Then
    4714                 :            :    we rebuild the operation.
    4715                 :            : 
    4716                 :            :    May return NULL_RTX when no changes were made.  */
    4717                 :            : 
    4718                 :            : static rtx
    4719                 :   20987000 : simplify_plus_minus (enum rtx_code code, machine_mode mode, rtx op0,
    4720                 :            :                      rtx op1)
    4721                 :            : {
    4722                 :   20987000 :   struct simplify_plus_minus_op_data
    4723                 :            :   {
    4724                 :            :     rtx op;
    4725                 :            :     short neg;
    4726                 :            :   } ops[16];
    4727                 :   20987000 :   rtx result, tem;
    4728                 :   20987000 :   int n_ops = 2;
    4729                 :   20987000 :   int changed, n_constants, canonicalized = 0;
    4730                 :   20987000 :   int i, j;
    4731                 :            : 
    4732                 :   20987000 :   memset (ops, 0, sizeof ops);
    4733                 :            : 
    4734                 :            :   /* Set up the two operands and then expand them until nothing has been
    4735                 :            :      changed.  If we run out of room in our array, give up; this should
    4736                 :            :      almost never happen.  */
    4737                 :            : 
    4738                 :   20987000 :   ops[0].op = op0;
    4739                 :   20987000 :   ops[0].neg = 0;
    4740                 :   20987000 :   ops[1].op = op1;
    4741                 :   20987000 :   ops[1].neg = (code == MINUS);
    4742                 :            : 
    4743                 :   42521900 :   do
    4744                 :            :     {
    4745                 :   42521900 :       changed = 0;
    4746                 :   42521900 :       n_constants = 0;
    4747                 :            : 
    4748                 :  171651000 :       for (i = 0; i < n_ops; i++)
    4749                 :            :         {
    4750                 :  129129000 :           rtx this_op = ops[i].op;
    4751                 :  129129000 :           int this_neg = ops[i].neg;
    4752                 :  129129000 :           enum rtx_code this_code = GET_CODE (this_op);
    4753                 :            : 
    4754                 :  129129000 :           switch (this_code)
    4755                 :            :             {
    4756                 :   21344800 :             case PLUS:
    4757                 :   21344800 :             case MINUS:
    4758                 :   21344800 :               if (n_ops == ARRAY_SIZE (ops))
    4759                 :            :                 return NULL_RTX;
    4760                 :            : 
    4761                 :   21344800 :               ops[n_ops].op = XEXP (this_op, 1);
    4762                 :   21344800 :               ops[n_ops].neg = (this_code == MINUS) ^ this_neg;
    4763                 :   21344800 :               n_ops++;
    4764                 :            : 
    4765                 :   21344800 :               ops[i].op = XEXP (this_op, 0);
    4766                 :   21344800 :               changed = 1;
    4767                 :            :               /* If this operand was negated then we will potentially
    4768                 :            :                  canonicalize the expression.  Similarly if we don't
    4769                 :            :                  place the operands adjacent we're re-ordering the
    4770                 :            :                  expression and thus might be performing a
    4771                 :            :                  canonicalization.  Ignore register re-ordering.
    4772                 :            :                  ??? It might be better to shuffle the ops array here,
    4773                 :            :                  but then (plus (plus (A, B), plus (C, D))) wouldn't
    4774                 :            :                  be seen as non-canonical.  */
    4775                 :   21344800 :               if (this_neg
    4776                 :   21207000 :                   || (i != n_ops - 2
    4777                 :   20752600 :                       && !(REG_P (ops[i].op) && REG_P (ops[n_ops - 1].op))))
    4778                 :   19044900 :                 canonicalized = 1;
    4779                 :            :               break;
    4780                 :            : 
    4781                 :       1447 :             case NEG:
    4782                 :       1447 :               ops[i].op = XEXP (this_op, 0);
    4783                 :       1447 :               ops[i].neg = ! this_neg;
    4784                 :       1447 :               changed = 1;
    4785                 :       1447 :               canonicalized = 1;
    4786                 :       1447 :               break;
    4787                 :            : 
    4788                 :     478408 :             case CONST:
    4789                 :     478408 :               if (n_ops != ARRAY_SIZE (ops)
    4790                 :     478408 :                   && GET_CODE (XEXP (this_op, 0)) == PLUS
    4791                 :     383829 :                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 0))
    4792                 :     366036 :                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 1)))
    4793                 :            :                 {
    4794                 :     366036 :                   ops[i].op = XEXP (XEXP (this_op, 0), 0);
    4795                 :     366036 :                   ops[n_ops].op = XEXP (XEXP (this_op, 0), 1);
    4796                 :     366036 :                   ops[n_ops].neg = this_neg;
    4797                 :     366036 :                   n_ops++;
    4798                 :     366036 :                   changed = 1;
    4799                 :     366036 :                   canonicalized = 1;
    4800                 :            :                 }
    4801                 :            :               break;
    4802                 :            : 
    4803                 :      15160 :             case NOT:
    4804                 :            :               /* ~a -> (-a - 1) */
    4805                 :      15160 :               if (n_ops != ARRAY_SIZE (ops))
    4806                 :            :                 {
    4807                 :      15160 :                   ops[n_ops].op = CONSTM1_RTX (mode);
    4808                 :      15160 :                   ops[n_ops++].neg = this_neg;
    4809                 :      15160 :                   ops[i].op = XEXP (this_op, 0);
    4810                 :      15160 :                   ops[i].neg = !this_neg;
    4811                 :      15160 :                   changed = 1;
    4812                 :      15160 :                   canonicalized = 1;
    4813                 :            :                 }
    4814                 :            :               break;
    4815                 :            : 
    4816                 :   68959200 :             CASE_CONST_SCALAR_INT:
    4817                 :   68959200 :             case CONST_POLY_INT:
    4818                 :   68959200 :               n_constants++;
    4819                 :   68959200 :               if (this_neg)
    4820                 :            :                 {
    4821                 :     220260 :                   ops[i].op = neg_poly_int_rtx (mode, this_op);
    4822                 :     220260 :                   ops[i].neg = 0;
    4823                 :     220260 :                   changed = 1;
    4824                 :     220260 :                   canonicalized = 1;
    4825                 :            :                 }
    4826                 :            :               break;
    4827                 :            : 
    4828                 :            :             default:
    4829                 :            :               break;
    4830                 :            :             }
    4831                 :            :         }
    4832                 :            :     }
    4833                 :   42521900 :   while (changed);
    4834                 :            : 
    4835                 :   20987000 :   if (n_constants > 1)
    4836                 :   14703000 :     canonicalized = 1;
    4837                 :            : 
    4838                 :   20987000 :   gcc_assert (n_ops >= 2);
    4839                 :            : 
    4840                 :            :   /* If we only have two operands, we can avoid the loops.  */
    4841                 :   20987000 :   if (n_ops == 2)
    4842                 :            :     {
    4843                 :          0 :       enum rtx_code code = ops[0].neg || ops[1].neg ? MINUS : PLUS;
    4844                 :          0 :       rtx lhs, rhs;
    4845                 :            : 
    4846                 :            :       /* Get the two operands.  Be careful with the order, especially for
    4847                 :            :          the cases where code == MINUS.  */
    4848                 :          0 :       if (ops[0].neg && ops[1].neg)
    4849                 :            :         {
    4850                 :          0 :           lhs = gen_rtx_NEG (mode, ops[0].op);
    4851                 :          0 :           rhs = ops[1].op;
    4852                 :            :         }
    4853                 :          0 :       else if (ops[0].neg)
    4854                 :            :         {
    4855                 :          0 :           lhs = ops[1].op;
    4856                 :          0 :           rhs = ops[0].op;
    4857                 :            :         }
    4858                 :            :       else
    4859                 :            :         {
    4860                 :          0 :           lhs = ops[0].op;
    4861                 :          0 :           rhs = ops[1].op;
    4862                 :            :         }
    4863                 :            : 
    4864                 :          0 :       return simplify_const_binary_operation (code, mode, lhs, rhs);
    4865                 :            :     }
    4866                 :            : 
    4867                 :            :   /* Now simplify each pair of operands until nothing changes.  */
    4868                 :   35869100 :   while (1)
    4869                 :            :     {
    4870                 :            :       /* Insertion sort is good enough for a small array.  */
    4871                 :   93529600 :       for (i = 1; i < n_ops; i++)
    4872                 :            :         {
    4873                 :   57660400 :           struct simplify_plus_minus_op_data save;
    4874                 :   57660400 :           int cmp;
    4875                 :            : 
    4876                 :   57660400 :           j = i - 1;
    4877                 :   57660400 :           cmp = simplify_plus_minus_op_data_cmp (ops[j].op, ops[i].op);
    4878                 :   57660400 :           if (cmp <= 0)
    4879                 :   52541200 :             continue;
    4880                 :            :           /* Just swapping registers doesn't count as canonicalization.  */
    4881                 :    5119200 :           if (cmp != 1)
    4882                 :    4008200 :             canonicalized = 1;
    4883                 :            : 
    4884                 :    5119200 :           save = ops[i];
    4885                 :    6084820 :           do
    4886                 :    6084820 :             ops[j + 1] = ops[j];
    4887                 :    6084820 :           while (j--
    4888                 :    6084820 :                  && simplify_plus_minus_op_data_cmp (ops[j].op, save.op) > 0);
    4889                 :    5119200 :           ops[j + 1] = save;
    4890                 :            :         }
    4891                 :            : 
    4892                 :   35869100 :       changed = 0;
    4893                 :   93529600 :       for (i = n_ops - 1; i > 0; i--)
    4894                 :  137627000 :         for (j = i - 1; j >= 0; j--)
    4895                 :            :           {
    4896                 :   80231500 :             rtx lhs = ops[j].op, rhs = ops[i].op;
    4897                 :   80231500 :             int lneg = ops[j].neg, rneg = ops[i].neg;
    4898                 :            : 
    4899                 :   80231500 :             if (lhs != 0 && rhs != 0)
    4900                 :            :               {
    4901                 :   65058100 :                 enum rtx_code ncode = PLUS;
    4902                 :            : 
    4903                 :   65058100 :                 if (lneg != rneg)
    4904                 :            :                   {
    4905                 :    4184460 :                     ncode = MINUS;
    4906                 :    4184460 :                     if (lneg)
    4907                 :    2563530 :                       std::swap (lhs, rhs);
    4908                 :            :                   }
    4909                 :   60873700 :                 else if (swap_commutative_operands_p (lhs, rhs))
    4910                 :      79510 :                   std::swap (lhs, rhs);
    4911                 :            : 
    4912                 :   65058100 :                 if ((GET_CODE (lhs) == CONST || CONST_INT_P (lhs))
    4913                 :   16292800 :                     && (GET_CODE (rhs) == CONST || CONST_INT_P (rhs)))
    4914                 :            :                   {
    4915                 :   14731800 :                     rtx tem_lhs, tem_rhs;
    4916                 :            : 
    4917                 :   14731800 :                     tem_lhs = GET_CODE (lhs) == CONST ? XEXP (lhs, 0) : lhs;
    4918                 :   14731800 :                     tem_rhs = GET_CODE (rhs) == CONST ? XEXP (rhs, 0) : rhs;
    4919                 :   14731800 :                     tem = simplify_binary_operation (ncode, mode, tem_lhs,
    4920                 :            :                                                      tem_rhs);
    4921                 :            : 
    4922                 :   14731800 :                     if (tem && !CONSTANT_P (tem))
    4923                 :        880 :                       tem = gen_rtx_CONST (GET_MODE (tem), tem);
    4924                 :            :                   }
    4925                 :            :                 else
    4926                 :   50326300 :                   tem = simplify_binary_operation (ncode, mode, lhs, rhs);
    4927                 :            : 
    4928                 :   65058100 :                 if (tem)
    4929                 :            :                   {
    4930                 :            :                     /* Reject "simplifications" that just wrap the two
    4931                 :            :                        arguments in a CONST.  Failure to do so can result
    4932                 :            :                        in infinite recursion with simplify_binary_operation
    4933                 :            :                        when it calls us to simplify CONST operations.
    4934                 :            :                        Also, if we find such a simplification, don't try
    4935                 :            :                        any more combinations with this rhs:  We must have
    4936                 :            :                        something like symbol+offset, ie. one of the
    4937                 :            :                        trivial CONST expressions we handle later.  */
    4938                 :   15380700 :                     if (GET_CODE (tem) == CONST
    4939                 :     266259 :                         && GET_CODE (XEXP (tem, 0)) == ncode
    4940                 :     266177 :                         && XEXP (XEXP (tem, 0), 0) == lhs
    4941                 :     265379 :                         && XEXP (XEXP (tem, 0), 1) == rhs)
    4942                 :            :                       break;
    4943                 :   15115300 :                     lneg &= rneg;
    4944                 :   15115300 :                     if (GET_CODE (tem) == NEG)
    4945                 :       8282 :                       tem = XEXP (tem, 0), lneg = !lneg;
    4946                 :   15115300 :                     if (poly_int_rtx_p (tem) && lneg)
    4947                 :          0 :                       tem = neg_poly_int_rtx (mode, tem), lneg = 0;
    4948                 :            : 
    4949                 :   15115300 :                     ops[i].op = tem;
    4950                 :   15115300 :                     ops[i].neg = lneg;
    4951                 :   15115300 :                     ops[j].op = NULL_RTX;
    4952                 :   15115300 :                     changed = 1;
    4953                 :   15115300 :                     canonicalized = 1;
    4954                 :            :                   }
    4955                 :            :               }
    4956                 :            :           }
    4957                 :            : 
    4958                 :   35869100 :       if (!changed)
    4959                 :            :         break;
    4960                 :            : 
    4961                 :            :       /* Pack all the operands to the lower-numbered entries.  */
    4962                 :   59826900 :       for (i = 0, j = 0; j < n_ops; j++)
    4963                 :   44944800 :         if (ops[j].op)
    4964                 :            :           {
    4965                 :   29829500 :             ops[i] = ops[j];
    4966                 :   29829500 :             i++;
    4967                 :            :           }
    4968                 :            :       n_ops = i;
    4969                 :            :     }
    4970                 :            : 
    4971                 :            :   /* If nothing changed, check that rematerialization of rtl instructions
    4972                 :            :      is still required.  */
    4973                 :   20987000 :   if (!canonicalized)
    4974                 :            :     {
    4975                 :            :       /* Perform rematerialization if only all operands are registers and
    4976                 :            :          all operations are PLUS.  */
    4977                 :            :       /* ??? Also disallow (non-global, non-frame) fixed registers to work
    4978                 :            :          around rs6000 and how it uses the CA register.  See PR67145.  */
    4979                 :    1981900 :       for (i = 0; i < n_ops; i++)
    4980                 :    1648640 :         if (ops[i].neg
    4981                 :    1512830 :             || !REG_P (ops[i].op)
    4982                 :    2777290 :             || (REGNO (ops[i].op) < FIRST_PSEUDO_REGISTER
    4983                 :       6249 :                 && fixed_regs[REGNO (ops[i].op)]
    4984                 :        170 :                 && !global_regs[REGNO (ops[i].op)]
    4985                 :        170 :                 && ops[i].op != frame_pointer_rtx
    4986                 :         56 :                 && ops[i].op != arg_pointer_rtx
    4987                 :         18 :                 && ops[i].op != stack_pointer_rtx))
    4988                 :            :           return NULL_RTX;
    4989                 :     333256 :       goto gen_result;
    4990                 :            :     }
    4991                 :            : 
    4992                 :            :   /* Create (minus -C X) instead of (neg (const (plus X C))).  */
    4993                 :   20133800 :   if (n_ops == 2
    4994                 :   14394700 :       && CONST_INT_P (ops[1].op)
    4995                 :   14248600 :       && CONSTANT_P (ops[0].op)
    4996                 :          0 :       && ops[0].neg)
    4997                 :          0 :     return gen_rtx_fmt_ee (MINUS, mode, ops[1].op, ops[0].op);
    4998                 :            : 
    4999                 :            :   /* We suppressed creation of trivial CONST expressions in the
    5000                 :            :      combination loop to avoid recursion.  Create one manually now.
    5001                 :            :      The combination loop should have ensured that there is exactly
    5002                 :            :      one CONST_INT, and the sort will have ensured that it is last
    5003                 :            :      in the array and that any other constant will be next-to-last.  */
    5004                 :            : 
    5005                 :   20133800 :   if (n_ops > 1
    5006                 :   19921400 :       && poly_int_rtx_p (ops[n_ops - 1].op)
    5007                 :   38972600 :       && CONSTANT_P (ops[n_ops - 2].op))
    5008                 :            :     {
    5009                 :     436705 :       rtx value = ops[n_ops - 1].op;
    5010                 :     436705 :       if (ops[n_ops - 1].neg ^ ops[n_ops - 2].neg)
    5011                 :     158081 :         value = neg_poly_int_rtx (mode, value);
    5012                 :     436705 :       if (CONST_INT_P (value))
    5013                 :            :         {
    5014                 :     873410 :           ops[n_ops - 2].op = plus_constant (mode, ops[n_ops - 2].op,
    5015                 :     436705 :                                              INTVAL (value));
    5016                 :     436705 :           n_ops--;
    5017                 :            :         }
    5018                 :            :     }
    5019                 :            : 
    5020                 :            :   /* Put a non-negated operand first, if possible.  */
    5021                 :            : 
    5022                 :   20766700 :   for (i = 0; i < n_ops && ops[i].neg; i++)
    5023                 :     632903 :     continue;
    5024                 :   20133800 :   if (i == n_ops)
    5025                 :       2590 :     ops[0].op = gen_rtx_NEG (mode, ops[0].op);
    5026                 :   20131200 :   else if (i != 0)
    5027                 :            :     {
    5028                 :     576030 :       tem = ops[0].op;
    5029                 :     576030 :       ops[0] = ops[i];
    5030                 :     576030 :       ops[i].op = tem;
    5031                 :     576030 :       ops[i].neg = 1;
    5032                 :            :     }
    5033                 :            : 
    5034                 :            :   /* Now make the result by performing the requested operations.  */
    5035                 :   19555200 :  gen_result:
    5036                 :   20467000 :   result = ops[0].op;
    5037                 :   46587500 :   for (i = 1; i < n_ops; i++)
    5038                 :   52240900 :     result = gen_rtx_fmt_ee (ops[i].neg ? MINUS : PLUS,
    5039                 :            :                              mode, result, ops[i].op);
    5040                 :            : 
    5041                 :            :   return result;
    5042                 :            : }
    5043                 :            : 
    5044                 :            : /* Check whether an operand is suitable for calling simplify_plus_minus.  */
    5045                 :            : static bool
    5046                 :  275171000 : plus_minus_operand_p (const_rtx x)
    5047                 :            : {
    5048                 :  275171000 :   return GET_CODE (x) == PLUS
    5049                 :  275171000 :          || GET_CODE (x) == MINUS
    5050                 :  275171000 :          || (GET_CODE (x) == CONST
    5051                 :     838817 :              && GET_CODE (XEXP (x, 0)) == PLUS
    5052                 :     399683 :              && CONSTANT_P (XEXP (XEXP (x, 0), 0))
    5053                 :     338604 :              && CONSTANT_P (XEXP (XEXP (x, 0), 1)));
    5054                 :            : }
    5055                 :            : 
    5056                 :            : /* Like simplify_binary_operation except used for relational operators.
    5057                 :            :    MODE is the mode of the result. If MODE is VOIDmode, both operands must
    5058                 :            :    not also be VOIDmode.
    5059                 :            : 
    5060                 :            :    CMP_MODE specifies in which mode the comparison is done in, so it is
    5061                 :            :    the mode of the operands.  If CMP_MODE is VOIDmode, it is taken from
    5062                 :            :    the operands or, if both are VOIDmode, the operands are compared in
    5063                 :            :    "infinite precision".  */
    5064                 :            : rtx
    5065                 :   70482000 : simplify_relational_operation (enum rtx_code code, machine_mode mode,
    5066                 :            :                                machine_mode cmp_mode, rtx op0, rtx op1)
    5067                 :            : {
    5068                 :   70482000 :   rtx tem, trueop0, trueop1;
    5069                 :            : 
    5070                 :   70482000 :   if (cmp_mode == VOIDmode)
    5071                 :   14678600 :     cmp_mode = GET_MODE (op0);
    5072                 :   70482000 :   if (cmp_mode == VOIDmode)
    5073                 :      73867 :     cmp_mode = GET_MODE (op1);
    5074                 :            : 
    5075                 :   70482000 :   tem = simplify_const_relational_operation (code, cmp_mode, op0, op1);
    5076                 :   70482000 :   if (tem)
    5077                 :            :     {
    5078                 :     169836 :       if (SCALAR_FLOAT_MODE_P (mode))
    5079                 :            :         {
    5080                 :         33 :           if (tem == const0_rtx)
    5081                 :         33 :             return CONST0_RTX (mode);
    5082                 :            : #ifdef FLOAT_STORE_FLAG_VALUE
    5083                 :            :           {
    5084                 :            :             REAL_VALUE_TYPE val;
    5085                 :            :             val = FLOAT_STORE_FLAG_VALUE (mode);
    5086                 :            :             return const_double_from_real_value (val, mode);
    5087                 :            :           }
    5088                 :            : #else
    5089                 :            :           return NULL_RTX;
    5090                 :            : #endif
    5091                 :            :         }
    5092                 :     169803 :       if (VECTOR_MODE_P (mode))
    5093                 :            :         {
    5094                 :         46 :           if (tem == const0_rtx)
    5095                 :          8 :             return CONST0_RTX (mode);
    5096                 :            : #ifdef VECTOR_STORE_FLAG_VALUE
    5097                 :            :           {
    5098                 :            :             rtx val = VECTOR_STORE_FLAG_VALUE (mode);
    5099                 :            :             if (val == NULL_RTX)
    5100                 :            :               return NULL_RTX;
    5101                 :            :             if (val == const1_rtx)
    5102                 :            :               return CONST1_RTX (mode);
    5103                 :            : 
    5104                 :            :             return gen_const_vec_duplicate (mode, val);
    5105                 :            :           }
    5106                 :            : #else
    5107                 :            :           return NULL_RTX;
    5108                 :            : #endif
    5109                 :            :         }
    5110                 :            :       /* For vector comparison with scalar int result, it is unknown
    5111                 :            :          if the target means here a comparison into an integral bitmask,
    5112                 :            :          or comparison where all comparisons true mean const_true_rtx
    5113                 :            :          whole result, or where any comparisons true mean const_true_rtx
    5114                 :            :          whole result.  For const0_rtx all the cases are the same.  */
    5115                 :     169757 :       if (VECTOR_MODE_P (cmp_mode)
    5116                 :          1 :           && SCALAR_INT_MODE_P (mode)
    5117                 :          1 :           && tem == const_true_rtx)
    5118                 :            :         return NULL_RTX;
    5119                 :            : 
    5120                 :     169756 :       return tem;
    5121                 :            :     }
    5122                 :            : 
    5123                 :            :   /* For the following tests, ensure const0_rtx is op1.  */
    5124                 :   70312200 :   if (swap_commutative_operands_p (op0, op1)
    5125                 :   70312200 :       || (op0 == const0_rtx && op1 != const0_rtx))
    5126                 :    1062320 :     std::swap (op0, op1), code = swap_condition (code);
    5127                 :            : 
    5128                 :            :   /* If op0 is a compare, extract the comparison arguments from it.  */
    5129                 :   70312200 :   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
    5130                 :    5725640 :     return simplify_gen_relational (code, mode, VOIDmode,
    5131                 :    5725640 :                                     XEXP (op0, 0), XEXP (op0, 1));
    5132                 :            : 
    5133                 :   64586500 :   if (GET_MODE_CLASS (cmp_mode) == MODE_CC
    5134                 :            :       || CC0_P (op0))
    5135                 :            :     return NULL_RTX;
    5136                 :            : 
    5137                 :   45408900 :   trueop0 = avoid_constant_pool_reference (op0);
    5138                 :   45408900 :   trueop1 = avoid_constant_pool_reference (op1);
    5139                 :   45408900 :   return simplify_relational_operation_1 (code, mode, cmp_mode,
    5140                 :   45408900 :                                           trueop0, trueop1);
    5141                 :            : }
    5142                 :            : 
    5143                 :            : /* This part of simplify_relational_operation is only used when CMP_MODE
    5144                 :            :    is not in class MODE_CC (i.e. it is a real comparison).
    5145                 :            : 
    5146                 :            :    MODE is the mode of the result, while CMP_MODE specifies in which
    5147                 :            :    mode the comparison is done in, so it is the mode of the operands.  */
    5148                 :            : 
    5149                 :            : static rtx
    5150                 :   45408900 : simplify_relational_operation_1 (enum rtx_code code, machine_mode mode,
    5151                 :            :                                  machine_mode cmp_mode, rtx op0, rtx op1)
    5152                 :            : {
    5153                 :   45408900 :   enum rtx_code op0code = GET_CODE (op0);
    5154                 :            : 
    5155                 :   45408900 :   if (op1 == const0_rtx && COMPARISON_P (op0))
    5156                 :            :     {
    5157                 :            :       /* If op0 is a comparison, extract the comparison arguments
    5158                 :            :          from it.  */
    5159                 :     123605 :       if (code == NE)
    5160                 :            :         {
    5161                 :      60168 :           if (GET_MODE (op0) == mode)
    5162                 :         21 :             return simplify_rtx (op0);
    5163                 :            :           else
    5164                 :      60147 :             return simplify_gen_relational (GET_CODE (op0), mode, VOIDmode,
    5165                 :      60147 :                                             XEXP (op0, 0), XEXP (op0, 1));
    5166                 :            :         }
    5167                 :      63437 :       else if (code == EQ)
    5168                 :            :         {
    5169                 :      62383 :           enum rtx_code new_code = reversed_comparison_code (op0, NULL);
    5170                 :      62383 :           if (new_code != UNKNOWN)
    5171                 :      62087 :             return simplify_gen_relational (new_code, mode, VOIDmode,
    5172                 :      62087 :                                             XEXP (op0, 0), XEXP (op0, 1));
    5173                 :            :         }
    5174                 :            :     }
    5175                 :            : 
    5176                 :            :   /* (LTU/GEU (PLUS a C) C), where C is constant, can be simplified to
    5177                 :            :      (GEU/LTU a -C).  Likewise for (LTU/GEU (PLUS a C) a).  */
    5178                 :   45286700 :   if ((code == LTU || code == GEU)
    5179                 :    1106810 :       && GET_CODE (op0) == PLUS
    5180                 :     236746 :       && CONST_INT_P (XEXP (op0, 1))
    5181                 :      89530 :       && (rtx_equal_p (op1, XEXP (op0, 0))
    5182                 :      83317 :           || rtx_equal_p (op1, XEXP (op0, 1)))
    5183                 :            :       /* (LTU/GEU (PLUS a 0) 0) is not the same as (GEU/LTU a 0). */
    5184                 :   45308800 :       && XEXP (op0, 1) != const0_rtx)
    5185                 :            :     {
    5186                 :      22074 :       rtx new_cmp
    5187                 :      22074 :         = simplify_gen_unary (NEG, cmp_mode, XEXP (op0, 1), cmp_mode);
    5188                 :      22754 :       return simplify_gen_relational ((code == LTU ? GEU : LTU), mode,
    5189                 :      22074 :                                       cmp_mode, XEXP (op0, 0), new_cmp);
    5190                 :            :     }
    5191                 :            : 
    5192                 :            :   /* (GTU (PLUS a C) (C - 1)) where C is a non-zero constant can be
    5193                 :            :      transformed into (LTU a -C).  */
    5194                 :   45264600 :   if (code == GTU && GET_CODE (op0) == PLUS && CONST_INT_P (op1)
    5195                 :     140525 :       && CONST_INT_P (XEXP (op0, 1))
    5196                 :     104862 :       && (UINTVAL (op1) == UINTVAL (XEXP (op0, 1)) - 1)
    5197                 :        828 :       && XEXP (op0, 1) != const0_rtx)
    5198                 :            :     {
    5199                 :        828 :       rtx new_cmp
    5200                 :        828 :         = simplify_gen_unary (NEG, cmp_mode, XEXP (op0, 1), cmp_mode);
    5201                 :        828 :       return simplify_gen_relational (LTU, mode, cmp_mode,
    5202                 :        828 :                                        XEXP (op0, 0), new_cmp);
    5203                 :            :     }
    5204                 :            : 
    5205                 :            :   /* Canonicalize (LTU/GEU (PLUS a b) b) as (LTU/GEU (PLUS a b) a).  */
    5206                 :   45263800 :   if ((code == LTU || code == GEU)
    5207                 :    1084740 :       && GET_CODE (op0) == PLUS
    5208                 :     214672 :       && rtx_equal_p (op1, XEXP (op0, 1))
    5209                 :            :       /* Don't recurse "infinitely" for (LTU/GEU (PLUS b b) b).  */
    5210                 :   45273900 :       && !rtx_equal_p (op1, XEXP (op0, 0)))
    5211                 :      10092 :     return simplify_gen_relational (code, mode, cmp_mode, op0,
    5212                 :      10092 :                                     copy_rtx (XEXP (op0, 0)));
    5213                 :            : 
    5214                 :   45253700 :   if (op1 == const0_rtx)
    5215                 :            :     {
    5216                 :            :       /* Canonicalize (GTU x 0) as (NE x 0).  */
    5217                 :   21789700 :       if (code == GTU)
    5218                 :      27138 :         return simplify_gen_relational (NE, mode, cmp_mode, op0, op1);
    5219                 :            :       /* Canonicalize (LEU x 0) as (EQ x 0).  */
    5220                 :   21762600 :       if (code == LEU)
    5221                 :      13089 :         return simplify_gen_relational (EQ, mode, cmp_mode, op0, op1);
    5222                 :            :     }
    5223                 :   23464000 :   else if (op1 == const1_rtx)
    5224                 :            :     {
    5225                 :    1539670 :       switch (code)
    5226                 :            :         {
    5227                 :       1497 :         case GE:
    5228                 :            :           /* Canonicalize (GE x 1) as (GT x 0).  */
    5229                 :       1497 :           return simplify_gen_relational (GT, mode, cmp_mode,
    5230                 :       1497 :                                           op0, const0_rtx);
    5231                 :      13367 :         case GEU:
    5232                 :            :           /* Canonicalize (GEU x 1) as (NE x 0).  */
    5233                 :      13367 :           return simplify_gen_relational (NE, mode, cmp_mode,
    5234                 :      13367 :                                           op0, const0_rtx);
    5235                 :       2222 :         case LT:
    5236                 :            :           /* Canonicalize (LT x 1) as (LE x 0).  */
    5237                 :       2222 :           return simplify_gen_relational (LE, mode, cmp_mode,
    5238                 :       2222 :                                           op0, const0_rtx);
    5239                 :      28883 :         case LTU:
    5240                 :            :           /* Canonicalize (LTU x 1) as (EQ x 0).  */
    5241                 :      28883 :           return simplify_gen_relational (EQ, mode, cmp_mode,
    5242                 :      28883 :                                           op0, const0_rtx);
    5243                 :            :         default:
    5244                 :            :           break;
    5245                 :            :         }
    5246                 :            :     }
    5247                 :   21924300 :   else if (op1 == constm1_rtx)
    5248                 :            :     {
    5249                 :            :       /* Canonicalize (LE x -1) as (LT x 0).  */
    5250                 :     473464 :       if (code == LE)
    5251                 :       1251 :         return simplify_gen_relational (LT, mode, cmp_mode, op0, const0_rtx);
    5252                 :            :       /* Canonicalize (GT x -1) as (GE x 0).  */
    5253                 :     472213 :       if (code == GT)
    5254                 :       3611 :         return simplify_gen_relational (GE, mode, cmp_mode, op0, const0_rtx);
    5255                 :            :     }
    5256                 :            : 
    5257                 :            :   /* (eq/ne (plus x cst1) cst2) simplifies to (eq/ne x (cst2 - cst1))  */
    5258                 :   45162600 :   if ((code == EQ || code == NE)
    5259                 :   32211000 :       && (op0code == PLUS || op0code == MINUS)
    5260                 :    1222060 :       && CONSTANT_P (op1)
    5261                 :     451975 :       && CONSTANT_P (XEXP (op0, 1))
    5262                 :     266208 :       && (INTEGRAL_MODE_P (cmp_mode) || flag_unsafe_math_optimizations))
    5263                 :            :     {
    5264                 :     266208 :       rtx x = XEXP (op0, 0);
    5265                 :     266208 :       rtx c = XEXP (op0, 1);
    5266                 :     266208 :       enum rtx_code invcode = op0code == PLUS ? MINUS : PLUS;
    5267                 :     266208 :       rtx tem = simplify_gen_binary (invcode, cmp_mode, op1, c);
    5268                 :            : 
    5269                 :            :       /* Detect an infinite recursive condition, where we oscillate at this
    5270                 :            :          simplification case between:
    5271                 :            :             A + B == C  <--->  C - B == A,
    5272                 :            :          where A, B, and C are all constants with non-simplifiable expressions,
    5273                 :            :          usually SYMBOL_REFs.  */
    5274                 :     266208 :       if (GET_CODE (tem) == invcode
    5275                 :         46 :           && CONSTANT_P (x)
    5276                 :     266226 :           && rtx_equal_p (c, XEXP (tem, 1)))
    5277                 :            :         return NULL_RTX;
    5278                 :            : 
    5279                 :     266190 :       return simplify_gen_relational (code, mode, cmp_mode, x, tem);
    5280                 :            :     }
    5281                 :            : 
    5282                 :            :   /* (ne:SI (zero_extract:SI FOO (const_int 1) BAR) (const_int 0))) is
    5283                 :            :      the same as (zero_extract:SI FOO (const_int 1) BAR).  */
    5284                 :   44896400 :   scalar_int_mode int_mode, int_cmp_mode;
    5285                 :   44896400 :   if (code == NE
    5286                 :   16768700 :       && op1 == const0_rtx
    5287                 :    1071690 :       && is_int_mode (mode, &int_mode)
    5288                 :    1071690 :       && is_a <scalar_int_mode> (cmp_mode, &int_cmp_mode)
    5289                 :            :       /* ??? Work-around BImode bugs in the ia64 backend.  */
    5290                 :    1071690 :       && int_mode != BImode
    5291                 :    1071690 :       && int_cmp_mode != BImode
    5292                 :    1071690 :       && nonzero_bits (op0, int_cmp_mode) == 1
    5293                 :   44896400 :       && STORE_FLAG_VALUE == 1)
    5294                 :      19282 :     return GET_MODE_SIZE (int_mode) > GET_MODE_SIZE (int_cmp_mode)
    5295                 :       9641 :            ? simplify_gen_unary (ZERO_EXTEND, int_mode, op0, int_cmp_mode)
    5296                 :       6162 :            : lowpart_subreg (int_mode, op0, int_cmp_mode);
    5297                 :            : 
    5298                 :            :   /* (eq/ne (xor x y) 0) simplifies to (eq/ne x y).  */
    5299                 :   44886800 :   if ((code == EQ || code == NE)
    5300                 :   31935100 :       && op1 == const0_rtx
    5301                 :   18768400 :       && op0code == XOR)
    5302                 :       4371 :     return simplify_gen_relational (code, mode, cmp_mode,
    5303                 :       4371 :                                     XEXP (op0, 0), XEXP (op0, 1));
    5304                 :            : 
    5305                 :            :   /* (eq/ne (xor x y) x) simplifies to (eq/ne y 0).  */
    5306                 :   44882400 :   if ((code == EQ || code == NE)
    5307                 :   31930800 :       && op0code == XOR
    5308                 :       4089 :       && rtx_equal_p (XEXP (op0, 0), op1)
    5309                 :   44882400 :       && !side_effects_p (XEXP (op0, 0)))
    5310                 :          0 :     return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 1),
    5311                 :          0 :                                     CONST0_RTX (mode));
    5312                 :            : 
    5313                 :            :   /* Likewise (eq/ne (xor x y) y) simplifies to (eq/ne x 0).  */
    5314                 :   44882400 :   if ((code == EQ || code == NE)
    5315                 :   31930800 :       && op0code == XOR
    5316                 :       4089 :       && rtx_equal_p (XEXP (op0, 1), op1)
    5317                 :   44882600 :       && !side_effects_p (XEXP (op0, 1)))
    5318                 :        164 :     return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 0),
    5319                 :        164 :                                     CONST0_RTX (mode));
    5320                 :            : 
    5321                 :            :   /* (eq/ne (xor x C1) C2) simplifies to (eq/ne x (C1^C2)).  */
    5322                 :   44882200 :   if ((code == EQ || code == NE)
    5323                 :   31930600 :       && op0code == XOR
    5324                 :       3925 :       && CONST_SCALAR_INT_P (op1)
    5325                 :       1088 :       && CONST_SCALAR_INT_P (XEXP (op0, 1)))
    5326                 :          9 :     return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 0),
    5327                 :            :                                     simplify_gen_binary (XOR, cmp_mode,
    5328                 :          9 :                                                          XEXP (op0, 1), op1));
    5329                 :            : 
    5330                 :            :   /* Simplify eq/ne (and/ior x y) x/y) for targets with a BICS instruction or
    5331                 :            :      constant folding if x/y is a constant.  */
    5332                 :   44882200 :   if ((code == EQ || code == NE)
    5333                 :   31930600 :       && (op0code == AND || op0code == IOR)
    5334                 :    2230720 :       && !side_effects_p (op1)
    5335                 :   47112900 :       && op1 != CONST0_RTX (cmp_mode))
    5336                 :            :     {
    5337                 :            :       /* Both (eq/ne (and x y) x) and (eq/ne (ior x y) y) simplify to
    5338                 :            :          (eq/ne (and (not y) x) 0).  */
    5339                 :     214152 :       if ((op0code == AND && rtx_equal_p (XEXP (op0, 0), op1))
    5340                 :     427841 :           || (op0code == IOR && rtx_equal_p (XEXP (op0, 1), op1)))
    5341                 :            :         {
    5342                 :      14510 :           rtx not_y = simplify_gen_unary (NOT, cmp_mode, XEXP (op0, 1),
    5343                 :            :                                           cmp_mode);
    5344                 :      14510 :           rtx lhs = simplify_gen_binary (AND, cmp_mode, not_y, XEXP (op0, 0));
    5345                 :            : 
    5346                 :      14510 :           return simplify_gen_relational (code, mode, cmp_mode, lhs,
    5347                 :      14510 :                                           CONST0_RTX (cmp_mode));
    5348                 :            :         }
    5349                 :            : 
    5350                 :            :       /* Both (eq/ne (and x y) y) and (eq/ne (ior x y) x) simplify to
    5351                 :            :          (eq/ne (and (not x) y) 0).  */
    5352                 :     199676 :       if ((op0code == AND && rtx_equal_p (XEXP (op0, 1), op1))
    5353                 :     383620 :           || (op0code == IOR && rtx_equal_p (XEXP (op0, 0), op1)))
    5354                 :            :         {
    5355                 :      29741 :           rtx not_x = simplify_gen_unary (NOT, cmp_mode, XEXP (op0, 0),
    5356                 :            :                                           cmp_mode);
    5357                 :      29741 :           rtx lhs = simplify_gen_binary (AND, cmp_mode, not_x, XEXP (op0, 1));
    5358                 :            : 
    5359                 :      29741 :           return simplify_gen_relational (code, mode, cmp_mode, lhs,
    5360                 :      29741 :                                           CONST0_RTX (cmp_mode));
    5361                 :            :         }
    5362                 :            :     }
    5363                 :            : 
    5364                 :            :   /* (eq/ne (bswap x) C1) simplifies to (eq/ne x C2) with C2 swapped.  */
    5365                 :   44838000 :   if ((code == EQ || code == NE)
    5366                 :   31886300 :       && GET_CODE (op0) == BSWAP
    5367                 :        608 :       && CONST_SCALAR_INT_P (op1))
    5368                 :        167 :     return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 0),
    5369                 :            :                                     simplify_gen_unary (BSWAP, cmp_mode,
    5370                 :        167 :                                                         op1, cmp_mode));
    5371                 :            : 
    5372                 :            :   /* (eq/ne (bswap x) (bswap y)) simplifies to (eq/ne x y).  */
    5373                 :   44837800 :   if ((code == EQ || code == NE)
    5374                 :   31886200 :       && GET_CODE (op0) == BSWAP
    5375                 :        441 :       && GET_CODE (op1) == BSWAP)
    5376                 :         46 :     return simplify_gen_relational (code, mode, cmp_mode,
    5377                 :         46 :                                     XEXP (op0, 0), XEXP (op1, 0));
    5378                 :            : 
    5379                 :   44837800 :   if (op0code == POPCOUNT && op1 == const0_rtx)
    5380                 :          0 :     switch (code)
    5381                 :            :       {
    5382                 :          0 :       case EQ:
    5383                 :          0 :       case LE:
    5384                 :          0 :       case LEU:
    5385                 :            :         /* (eq (popcount x) (const_int 0)) -> (eq x (const_int 0)).  */
    5386                 :          0 :         return simplify_gen_relational (EQ, mode, GET_MODE (XEXP (op0, 0)),
    5387                 :          0 :                                         XEXP (op0, 0), const0_rtx);
    5388                 :            : 
    5389                 :          0 :       case NE:
    5390                 :          0 :       case GT:
    5391                 :          0 :       case GTU:
    5392                 :            :         /* (ne (popcount x) (const_int 0)) -> (ne x (const_int 0)).  */
    5393                 :          0 :         return simplify_gen_relational (NE, mode, GET_MODE (XEXP (op0, 0)),
    5394                 :          0 :                                         XEXP (op0, 0), const0_rtx);
    5395                 :            : 
    5396                 :            :       default:
    5397                 :            :         break;
    5398                 :            :       }
    5399                 :            : 
    5400                 :            :   return NULL_RTX;
    5401                 :            : }
    5402                 :            : 
    5403                 :            : enum
    5404                 :            : {
    5405                 :            :   CMP_EQ = 1,
    5406                 :            :   CMP_LT = 2,
    5407                 :            :   CMP_GT = 4,
    5408                 :            :   CMP_LTU = 8,
    5409                 :            :   CMP_GTU = 16
    5410                 :            : };
    5411                 :            : 
    5412                 :            : 
    5413                 :            : /* Convert the known results for EQ, LT, GT, LTU, GTU contained in
    5414                 :            :    KNOWN_RESULT to a CONST_INT, based on the requested comparison CODE
    5415                 :            :    For KNOWN_RESULT to make sense it should be either CMP_EQ, or the
    5416                 :            :    logical OR of one of (CMP_LT, CMP_GT) and one of (CMP_LTU, CMP_GTU).
    5417                 :            :    For floating-point comparisons, assume that the operands were ordered.  */
    5418                 :            : 
    5419                 :            : static rtx
    5420                 :     144950 : comparison_result (enum rtx_code code, int known_results)
    5421                 :            : {
    5422                 :     144950 :   switch (code)
    5423                 :            :     {
    5424                 :      91567 :     case EQ:
    5425                 :      91567 :     case UNEQ:
    5426                 :      91567 :       return (known_results & CMP_EQ) ? const_true_rtx : const0_rtx;
    5427                 :      42518 :     case NE:
    5428                 :      42518 :     case LTGT:
    5429                 :      42518 :       return (known_results & CMP_EQ) ? const0_rtx : const_true_rtx;
    5430                 :            : 
    5431                 :        219 :     case LT:
    5432                 :        219 :     case UNLT:
    5433                 :        219 :       return (known_results & CMP_LT) ? const_true_rtx : const0_rtx;
    5434                 :        676 :     case GE:
    5435                 :        676 :     case UNGE:
    5436                 :        676 :       return (known_results & CMP_LT) ? const0_rtx : const_true_rtx;
    5437                 :            : 
    5438                 :        566 :     case GT:
    5439                 :        566 :     case UNGT:
    5440                 :        566 :       return (known_results & CMP_GT) ? const_true_rtx : const0_rtx;
    5441                 :        784 :     case LE:
    5442                 :        784 :     case UNLE:
    5443                 :        784 :       return (known_results & CMP_GT) ? const0_rtx : const_true_rtx;
    5444                 :            : 
    5445                 :       1941 :     case LTU:
    5446                 :       1941 :       return (known_results & CMP_LTU) ? const_true_rtx : const0_rtx;
    5447                 :         86 :     case GEU:
    5448                 :         86 :       return (known_results & CMP_LTU) ? const0_rtx : const_true_rtx;
    5449                 :            : 
    5450                 :       5465 :     case GTU:
    5451                 :       5465 :       return (known_results & CMP_GTU) ? const_true_rtx : const0_rtx;
    5452                 :       1128 :     case LEU:
    5453                 :       1128 :       return (known_results & CMP_GTU) ? const0_rtx : const_true_rtx;
    5454                 :            : 
    5455                 :          0 :     case ORDERED:
    5456                 :          0 :       return const_true_rtx;
    5457                 :          0 :     case UNORDERED:
    5458                 :          0 :       return const0_rtx;
    5459                 :          0 :     default:
    5460                 :          0 :       gcc_unreachable ();
    5461                 :            :     }
    5462                 :            : }
    5463                 :            : 
    5464                 :            : /* Check if the given comparison (done in the given MODE) is actually
    5465                 :            :    a tautology or a contradiction.  If the mode is VOIDmode, the
    5466                 :            :    comparison is done in "infinite precision".  If no simplification
    5467                 :            :    is possible, this function returns zero.  Otherwise, it returns
    5468                 :            :    either const_true_rtx or const0_rtx.  */
    5469                 :            : 
    5470                 :            : rtx
    5471                 :   73376000 : simplify_const_relational_operation (enum rtx_code code,
    5472                 :            :                                      machine_mode mode,
    5473                 :            :                                      rtx op0, rtx op1)
    5474                 :            : {
    5475                 :   73376000 :   rtx tem;
    5476                 :   73376000 :   rtx trueop0;
    5477                 :   73376000 :   rtx trueop1;
    5478                 :            : 
    5479                 :   73376000 :   gcc_assert (mode != VOIDmode
    5480                 :            :               || (GET_MODE (op0) == VOIDmode
    5481                 :            :                   && GET_MODE (op1) == VOIDmode));
    5482                 :            : 
    5483                 :            :   /* If op0 is a compare, extract the comparison arguments from it.  */
    5484                 :   73376000 :   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
    5485                 :            :     {
    5486                 :    5727600 :       op1 = XEXP (op0, 1);
    5487                 :    5727600 :       op0 = XEXP (op0, 0);
    5488                 :            : 
    5489                 :    5727600 :       if (GET_MODE (op0) != VOIDmode)
    5490                 :    5715000 :         mode = GET_MODE (op0);
    5491                 :      12596 :       else if (GET_MODE (op1) != VOIDmode)
    5492                 :      10950 :         mode = GET_MODE (op1);
    5493                 :            :       else
    5494                 :            :         return 0;
    5495                 :            :     }
    5496                 :            : 
    5497                 :            :   /* We can't simplify MODE_CC values since we don't know what the
    5498                 :            :      actual comparison is.  */
    5499                 :   73374400 :   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC || CC0_P (op0))
    5500                 :            :     return 0;
    5501                 :            : 
    5502                 :            :   /* Make sure the constant is second.  */
    5503                 :   54196800 :   if (swap_commutative_operands_p (op0, op1))
    5504                 :            :     {
    5505                 :    1161000 :       std::swap (op0, op1);
    5506                 :    1161000 :       code = swap_condition (code);
    5507                 :            :     }
    5508                 :            : 
    5509                 :   54196800 :   trueop0 = avoid_constant_pool_reference (op0);
    5510                 :   54196800 :   trueop1 = avoid_constant_pool_reference (op1);
    5511                 :            : 
    5512                 :            :   /* For integer comparisons of A and B maybe we can simplify A - B and can
    5513                 :            :      then simplify a comparison of that with zero.  If A and B are both either
    5514                 :            :      a register or a CONST_INT, this can't help; testing for these cases will
    5515                 :            :      prevent infinite recursion here and speed things up.
    5516                 :            : 
    5517                 :            :      We can only do this for EQ and NE comparisons as otherwise we may
    5518                 :            :      lose or introduce overflow which we cannot disregard as undefined as
    5519                 :            :      we do not know the signedness of the operation on either the left or
    5520                 :            :      the right hand side of the comparison.  */
    5521                 :            : 
    5522                 :   54196800 :   if (INTEGRAL_MODE_P (mode) && trueop1 != const0_rtx
    5523                 :   23793200 :       && (code == EQ || code == NE)
    5524                 :   14803500 :       && ! ((REG_P (op0) || CONST_INT_P (trueop0))
    5525                 :   10283700 :             && (REG_P (op1) || CONST_INT_P (trueop1)))
    5526                 :    5902840 :       && (tem = simplify_binary_operation (MINUS, mode, op0, op1)) != 0
    5527                 :            :       /* We cannot do this if tem is a nonzero address.  */
    5528                 :   57090900 :       && ! nonzero_address_p (tem))
    5529                 :    2894040 :     return simplify_const_relational_operation (signed_condition (code),
    5530                 :    2894040 :                                                 mode, tem, const0_rtx);
    5531                 :            : 
    5532                 :   51302800 :   if (! HONOR_NANS (mode) && code == ORDERED)
    5533                 :          0 :     return const_true_rtx;
    5534                 :            : 
    5535                 :   51302800 :   if (! HONOR_NANS (mode) && code == UNORDERED)
    5536                 :          0 :     return const0_rtx;
    5537                 :            : 
    5538                 :            :   /* For modes without NaNs, if the two operands are equal, we know the
    5539                 :            :      result except if they have side-effects.  Even with NaNs we know
    5540                 :            :      the result of unordered comparisons and, if signaling NaNs are
    5541                 :            :      irrelevant, also the result of LT/GT/LTGT.  */
    5542                 :   51302800 :   if ((! HONOR_NANS (trueop0)
    5543                 :    3025950 :        || code == UNEQ || code == UNLE || code == UNGE
    5544                 :    2947170 :        || ((code == LT || code == GT || code == LTGT)
    5545                 :    2179690 :            && ! HONOR_SNANS (trueop0)))
    5546                 :   50530600 :       && rtx_equal_p (trueop0, trueop1)
    5547                 :   51384700 :       && ! side_effects_p (trueop0))
    5548                 :      81885 :     return comparison_result (code, CMP_EQ);
    5549                 :            : 
    5550                 :            :   /* If the operands are floating-point constants, see if we can fold
    5551                 :            :      the result.  */
    5552                 :   51220900 :   if (CONST_DOUBLE_AS_FLOAT_P (trueop0)
    5553                 :        910 :       && CONST_DOUBLE_AS_FLOAT_P (trueop1)
    5554                 :        910 :       && SCALAR_FLOAT_MODE_P (GET_MODE (trueop0)))
    5555                 :            :     {
    5556                 :        910 :       const REAL_VALUE_TYPE *d0 = CONST_DOUBLE_REAL_VALUE (trueop0);
    5557                 :        910 :       const REAL_VALUE_TYPE *d1 = CONST_DOUBLE_REAL_VALUE (trueop1);
    5558                 :            : 
    5559                 :            :       /* Comparisons are unordered iff at least one of the values is NaN.  */
    5560                 :        910 :       if (REAL_VALUE_ISNAN (*d0) || REAL_VALUE_ISNAN (*d1))
    5561                 :         46 :         switch (code)
    5562                 :            :           {
    5563                 :          0 :           case UNEQ:
    5564                 :          0 :           case UNLT:
    5565                 :          0 :           case UNGT:
    5566                 :          0 :           case UNLE:
    5567                 :          0 :           case UNGE:
    5568                 :          0 :           case NE:
    5569                 :          0 :           case UNORDERED:
    5570                 :          0 :             return const_true_rtx;
    5571                 :         46 :           case EQ:
    5572                 :         46 :           case LT:
    5573                 :         46 :           case GT:
    5574                 :         46 :           case LE:
    5575                 :         46 :           case GE:
    5576                 :         46 :           case LTGT:
    5577                 :         46 :           case ORDERED:
    5578                 :         46 :             return const0_rtx;
    5579                 :            :           default:
    5580                 :            :             return 0;
    5581                 :            :           }
    5582                 :            : 
    5583                 :        921 :       return comparison_result (code,
    5584                 :        921 :                                 (real_equal (d0, d1) ? CMP_EQ :
    5585                 :        921 :                                  real_less (d0, d1) ? CMP_LT : CMP_GT));
    5586                 :            :     }
    5587                 :            : 
    5588                 :            :   /* Otherwise, see if the operands are both integers.  */
    5589                 :   51220000 :   if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode)
    5590                 :   47999000 :       && CONST_SCALAR_INT_P (trueop0) && CONST_SCALAR_INT_P (trueop1))
    5591                 :            :     {
    5592                 :            :       /* It would be nice if we really had a mode here.  However, the
    5593                 :            :          largest int representable on the target is as good as
    5594                 :            :          infinite.  */
    5595                 :      62201 :       machine_mode cmode = (mode == VOIDmode) ? MAX_MODE_INT : mode;
    5596                 :      62201 :       rtx_mode_t ptrueop0 = rtx_mode_t (trueop0, cmode);
    5597                 :      62201 :       rtx_mode_t ptrueop1 = rtx_mode_t (trueop1, cmode);
    5598                 :            : 
    5599                 :      62201 :       if (wi::eq_p (ptrueop0, ptrueop1))
    5600                 :          0 :         return comparison_result (code, CMP_EQ);
    5601                 :            :       else
    5602                 :            :         {
    5603                 :      62201 :           int cr = wi::lts_p (ptrueop0, ptrueop1) ? CMP_LT : CMP_GT;
    5604                 :      62201 :           cr |= wi::ltu_p (ptrueop0, ptrueop1) ? CMP_LTU : CMP_GTU;
    5605                 :      62201 :           return comparison_result (code, cr);
    5606                 :            :         }
    5607                 :            :     }
    5608                 :            : 
    5609                 :            :   /* Optimize comparisons with upper and lower bounds.  */
    5610                 :   51157800 :   scalar_int_mode int_mode;
    5611                 :   51157800 :   if (CONST_INT_P (trueop1)
    5612                 :   35418100 :       && is_a <scalar_int_mode> (mode, &int_mode)
    5613                 :   35418100 :       && HWI_COMPUTABLE_MODE_P (int_mode)
    5614                 :   86425100 :       && !side_effects_p (trueop0))
    5615                 :            :     {
    5616                 :   35183800 :       int sign;
    5617                 :   35183800 :       unsigned HOST_WIDE_INT nonzero = nonzero_bits (trueop0, int_mode);
    5618                 :   35183800 :       HOST_WIDE_INT val = INTVAL (trueop1);
    5619                 :   35183800 :       HOST_WIDE_INT mmin, mmax;
    5620                 :            : 
    5621                 :   35183800 :       if (code == GEU
    5622                 :   35183800 :           || code == LEU
    5623                 :   33856600 :           || code == GTU
    5624                 :   33856600 :           || code == LTU)
    5625                 :            :         sign = 0;
    5626                 :            :       else
    5627                 :   32734700 :         sign = 1;
    5628                 :            : 
    5629                 :            :       /* Get a reduced range if the sign bit is zero.  */
    5630                 :   35183800 :       if (nonzero <= (GET_MODE_MASK (int_mode) >> 1))
    5631                 :            :         {
    5632                 :    3161440 :           mmin = 0;
    5633                 :    3161440 :           mmax = nonzero;
    5634                 :            :         }
    5635                 :            :       else
    5636                 :            :         {
    5637                 :   32022400 :           rtx mmin_rtx, mmax_rtx;
    5638                 :   32022400 :           get_mode_bounds (int_mode, sign, int_mode, &mmin_rtx, &mmax_rtx);
    5639                 :            : 
    5640                 :   32022400 :           mmin = INTVAL (mmin_rtx);
    5641                 :   32022400 :           mmax = INTVAL (mmax_rtx);
    5642                 :   32022400 :           if (sign)
    5643                 :            :             {
    5644                 :   29678300 :               unsigned int sign_copies
    5645                 :   29678300 :                 = num_sign_bit_copies (trueop0, int_mode);
    5646                 :            : 
    5647                 :   29678300 :               mmin >>= (sign_copies - 1);
    5648                 :   29678300 :               mmax >>= (sign_copies - 1);
    5649                 :            :             }
    5650                 :            :         }
    5651                 :            : 
    5652                 :   35183800 :       switch (code)
    5653                 :            :         {
    5654                 :            :         /* x >= y is always true for y <= mmin, always false for y > mmax.  */
    5655                 :      74431 :         case GEU:
    5656                 :      74431 :           if ((unsigned HOST_WIDE_INT) val <= (unsigned HOST_WIDE_INT) mmin)
    5657                 :        669 :             return const_true_rtx;
    5658                 :      73762 :           if ((unsigned HOST_WIDE_INT) val > (unsigned HOST_WIDE_INT) mmax)
    5659                 :          0 :             return const0_rtx;
    5660                 :            :           break;
    5661                 :    1167790 :         case GE:
    5662                 :    1167790 :           if (val <= mmin)
    5663                 :        213 :             return const_true_rtx;
    5664                 :    1167580 :           if (val > mmax)
    5665                 :          0 :             return const0_rtx;
    5666                 :            :           break;
    5667                 :            : 
    5668                 :            :         /* x <= y is always true for y >= mmax, always false for y < mmin.  */
    5669                 :    1252840 :         case LEU:
    5670                 :    1252840 :           if ((unsigned HOST_WIDE_INT) val >= (unsigned HOST_WIDE_INT) mmax)
    5671                 :       4187 :             return const_true_rtx;
    5672                 :    1248650 :           if ((unsigned HOST_WIDE_INT) val < (unsigned HOST_WIDE_INT) mmin)
    5673                 :          0 :             return const0_rtx;
    5674                 :            :           break;
    5675                 :    1308880 :         case LE:
    5676                 :    1308880 :           if (val >= mmax)
    5677                 :        470 :             return const_true_rtx;
    5678                 :    1308410 :           if (val < mmin)
    5679                 :          1 :             return const0_rtx;
    5680                 :            :           break;
    5681                 :            : 
    5682                 :   13381600 :         case EQ:
    5683                 :            :           /* x == y is always false for y out of range.  */
    5684                 :   13381600 :           if (val < mmin || val > mmax)
    5685                 :        211 :             return const0_rtx;
    5686                 :            :           break;
    5687                 :            : 
    5688                 :            :         /* x > y is always false for y >= mmax, always true for y < mmin.  */
    5689                 :     914554 :         case GTU:
    5690                 :     914554 :           if ((unsigned HOST_WIDE_INT) val >= (unsigned HOST_WIDE_INT) mmax)
    5691                 :       8058 :             return const0_rtx;
    5692                 :     906496 :           if ((unsigned HOST_WIDE_INT) val < (unsigned HOST_WIDE_INT) mmin)
    5693                 :          0 :             return const_true_rtx;
    5694                 :            :           break;
    5695                 :    1227560 :         case GT:
    5696                 :    1227560 :           if (val >= mmax)
    5697                 :        213 :             return const0_rtx;
    5698                 :    1227350 :           if (val < mmin)
    5699                 :          5 :             return const_true_rtx;
    5700                 :            :           break;
    5701                 :            : 
    5702                 :            :         /* x < y is always false for y <= mmin, always true for y > mmax.  */
    5703                 :     207359 :         case LTU:
    5704                 :     207359 :           if ((unsigned HOST_WIDE_INT) val <= (unsigned HOST_WIDE_INT) mmin)
    5705                 :       1795 :             return const0_rtx;
    5706                 :     205564 :           if ((unsigned HOST_WIDE_INT) val > (unsigned HOST_WIDE_INT) mmax)
    5707                 :       5476 :             return const_true_rtx;
    5708                 :            :           break;
    5709                 :     648511 :         case LT:
    5710                 :     648511 :           if (val <= mmin)
    5711                 :       1694 :             return const0_rtx;
    5712                 :     646817 :           if (val > mmax)
    5713                 :       1206 :             return const_true_rtx;
    5714                 :            :           break;
    5715                 :            : 
    5716                 :   15000300 :         case NE:
    5717                 :            :           /* x != y is always true for y out of range.  */
    5718                 :   15000300 :           if (val < mmin || val > mmax)
    5719                 :        172 :             return const_true_rtx;
    5720                 :            :           break;
    5721                 :            : 
    5722                 :            :         default:
    5723                 :            :           break;
    5724                 :            :         }
    5725                 :            :     }
    5726                 :            : 
    5727                 :            :   /* Optimize integer comparisons with zero.  */
    5728                 :   51133400 :   if (is_a <scalar_int_mode> (mode, &int_mode)
    5729                 :   47939200 :       && trueop1 == const0_rtx
    5730                 :   27138300 :       && !side_effects_p (trueop0))
    5731                 :            :     {
    5732                 :            :       /* Some addresses are known to be nonzero.  We don't know
    5733                 :            :          their sign, but equality comparisons are known.  */
    5734                 :   27058700 :       if (nonzero_address_p (trueop0))
    5735                 :            :         {
    5736                 :        224 :           if (code == EQ || code == LEU)
    5737                 :         67 :             return const0_rtx;
    5738                 :        157 :           if (code == NE || code == GTU)
    5739                 :        157 :             return const_true_rtx;
    5740                 :            :         }
    5741                 :            : 
    5742                 :            :       /* See if the first operand is an IOR with a constant.  If so, we
    5743                 :            :          may be able to determine the result of this comparison.  */
    5744                 :   27058500 :       if (GET_CODE (op0) == IOR)
    5745                 :            :         {
    5746                 :     870745 :           rtx inner_const = avoid_constant_pool_reference (XEXP (op0, 1));
    5747                 :     870745 :           if (CONST_INT_P (inner_const) && inner_const != const0_rtx)
    5748                 :            :             {
    5749                 :        398 :               int sign_bitnum = GET_MODE_PRECISION (int_mode) - 1;
    5750                 :        796 :               int has_sign = (HOST_BITS_PER_WIDE_INT >= sign_bitnum
    5751                 :        398 :                               && (UINTVAL (inner_const)
    5752                 :            :                                   & (HOST_WIDE_INT_1U
    5753                 :        398 :                                      << sign_bitnum)));
    5754                 :            : 
    5755                 :        398 :               switch (code)
    5756                 :            :                 {
    5757                 :            :                 case EQ:
    5758                 :            :                 case LEU:
    5759                 :            :                   return const0_rtx;
    5760                 :         12 :                 case NE:
    5761                 :         12 :                 case GTU:
    5762                 :         12 :                   return const_true_rtx;
    5763                 :        154 :                 case LT:
    5764                 :        154 :                 case LE:
    5765                 :        154 :                   if (has_sign)
    5766                 :          0 :                     return const_true_rtx;
    5767                 :            :                   break;
    5768                 :        230 :                 case GT:
    5769                 :        230 :                 case GE:
    5770                 :        230 :                   if (has_sign)
    5771                 :            :                     return const0_rtx;
    5772                 :            :                   break;
    5773                 :            :                 default:
    5774                 :            :                   break;
    5775                 :            :                 }
    5776                 :            :             }
    5777                 :            :         }
    5778                 :            :     }
    5779                 :            : 
    5780                 :            :   /* Optimize comparison of ABS with zero.  */
    5781                 :   27355700 :   if (trueop1 == CONST0_RTX (mode) && !side_effects_p (trueop0)
    5782                 :   78409100 :       && (GET_CODE (trueop0) == ABS
    5783                 :   27275900 :           || (GET_CODE (trueop0) == FLOAT_EXTEND
    5784                 :          6 :               && GET_CODE (XEXP (trueop0, 0)) == ABS)))
    5785                 :            :     {
    5786                 :        199 :       switch (code)
    5787                 :            :         {
    5788                 :         12 :         case LT:
    5789                 :            :           /* Optimize abs(x) < 0.0.  */
    5790                 :         12 :           if (!INTEGRAL_MODE_P (mode) && !HONOR_SNANS (mode))
    5791                 :         12 :             return const0_rtx;
    5792                 :            :           break;
    5793                 :            : 
    5794                 :          0 :         case GE:
    5795                 :            :           /* Optimize abs(x) >= 0.0.  */
    5796                 :          0 :           if (!INTEGRAL_MODE_P (mode) && !HONOR_NANS (mode))
    5797                 :          0 :             return const_true_rtx;
    5798                 :            :           break;
    5799                 :            : 
    5800                 :          0 :         case UNGE:
    5801                 :            :           /* Optimize ! (abs(x) < 0.0).  */
    5802                 :          0 :           return const_true_rtx;
    5803                 :            : 
    5804                 :            :         default:
    5805                 :            :           break;
    5806                 :            :         }
    5807                 :            :     }
    5808                 :            : 
    5809                 :            :   return 0;
    5810                 :            : }
    5811                 :            : 
    5812                 :            : /* Recognize expressions of the form (X CMP 0) ? VAL : OP (X)
    5813                 :            :    where OP is CLZ or CTZ and VAL is the value from CLZ_DEFINED_VALUE_AT_ZERO
    5814                 :            :    or CTZ_DEFINED_VALUE_AT_ZERO respectively and return OP (X) if the expression
    5815                 :            :    can be simplified to that or NULL_RTX if not.
    5816                 :            :    Assume X is compared against zero with CMP_CODE and the true
    5817                 :            :    arm is TRUE_VAL and the false arm is FALSE_VAL.  */
    5818                 :            : 
    5819                 :            : static rtx
    5820                 :   18370000 : simplify_cond_clz_ctz (rtx x, rtx_code cmp_code, rtx true_val, rtx false_val)
    5821                 :            : {
    5822                 :   18370000 :   if (cmp_code != EQ && cmp_code != NE)
    5823                 :            :     return NULL_RTX;
    5824                 :            : 
    5825                 :            :   /* Result on X == 0 and X !=0 respectively.  */
    5826                 :   12218500 :   rtx on_zero, on_nonzero;
    5827                 :   12218500 :   if (cmp_code == EQ)
    5828                 :            :     {
    5829                 :            :       on_zero = true_val;
    5830                 :            :       on_nonzero = false_val;
    5831                 :            :     }
    5832                 :            :   else
    5833                 :            :     {
    5834                 :    6431500 :       on_zero = false_val;
    5835                 :    6431500 :       on_nonzero = true_val;
    5836                 :            :     }
    5837                 :            : 
    5838                 :   12218500 :   rtx_code op_code = GET_CODE (on_nonzero);
    5839                 :   12218500 :   if ((op_code != CLZ && op_code != CTZ)
    5840                 :        912 :       || !rtx_equal_p (XEXP (on_nonzero, 0), x)
    5841                 :   12219000 :       || !CONST_INT_P (on_zero))
    5842                 :   12218400 :     return NULL_RTX;
    5843                 :            : 
    5844                 :         90 :   HOST_WIDE_INT op_val;
    5845                 :         90 :   scalar_int_mode mode ATTRIBUTE_UNUSED
    5846                 :         90 :     = as_a <scalar_int_mode> (GET_MODE (XEXP (on_nonzero, 0)));
    5847                 :          0 :   if (((op_code == CLZ && CLZ_DEFINED_VALUE_AT_ZERO (mode, op_val))
    5848                 :        180 :        || (op_code == CTZ && CTZ_DEFINED_VALUE_AT_ZERO (mode, op_val)))
    5849                 :         90 :       && op_val == INTVAL (on_zero))
    5850                 :          0 :     return on_nonzero;
    5851                 :            : 
    5852                 :            :   return NULL_RTX;
    5853                 :            : }
    5854                 :            : 
    5855                 :            : /* Try to simplify X given that it appears within operand OP of a
    5856                 :            :    VEC_MERGE operation whose mask is MASK.  X need not use the same
    5857                 :            :    vector mode as the VEC_MERGE, but it must have the same number of
    5858                 :            :    elements.
    5859                 :            : 
    5860                 :            :    Return the simplified X on success, otherwise return NULL_RTX.  */
    5861                 :            : 
    5862                 :            : rtx
    5863                 :     731086 : simplify_merge_mask (rtx x, rtx mask, int op)
    5864                 :            : {
    5865                 :     731086 :   gcc_assert (VECTOR_MODE_P (GET_MODE (x)));
    5866                 :    1462170 :   poly_uint64 nunits = GET_MODE_NUNITS (GET_MODE (x));
    5867                 :     731086 :   if (GET_CODE (x) == VEC_MERGE && rtx_equal_p (XEXP (x, 2), mask))
    5868                 :            :     {
    5869                 :       1898 :       if (side_effects_p (XEXP (x, 1 - op)))
    5870                 :            :         return NULL_RTX;
    5871                 :            : 
    5872                 :       1804 :       return XEXP (x, op);
    5873                 :            :     }
    5874                 :     729188 :   if (UNARY_P (x)
    5875                 :     114907 :       && VECTOR_MODE_P (GET_MODE (XEXP (x, 0)))
    5876                 :     800206 :       && known_eq (GET_MODE_NUNITS (GET_MODE (XEXP (x, 0))), nunits))
    5877                 :            :     {
    5878                 :      32294 :       rtx top0 = simplify_merge_mask (XEXP (x, 0), mask, op);
    5879                 :      32294 :       if (top0)
    5880                 :        188 :         return simplify_gen_unary (GET_CODE (x), GET_MODE (x), top0,
    5881                 :        188 :                                    GET_MODE (XEXP (x, 0)));
    5882                 :            :     }
    5883                 :     729000 :   if (BINARY_P (x)
    5884                 :      83888 :       && VECTOR_MODE_P (GET_MODE (XEXP (x, 0)))
    5885                 :     167776 :       && known_eq (GET_MODE_NUNITS (GET_MODE (XEXP (x, 0))), nunits)
    5886                 :      58788 :       && VECTOR_MODE_P (GET_MODE (XEXP (x, 1)))
    5887                 :     811176 :       && known_eq (GET_MODE_NUNITS (GET_MODE (XEXP (x, 1))), nunits))
    5888                 :            :     {
    5889                 :      41088 :       rtx top0 = simplify_merge_mask (XEXP (x, 0), mask, op);
    5890                 :      41088 :       rtx top1 = simplify_merge_mask (XEXP (x, 1), mask, op);
    5891                 :      41088 :       if (top0 || top1)
    5892                 :            :         {
    5893                 :        188 :           if (COMPARISON_P (x))
    5894                 :          0 :             return simplify_gen_relational (GET_CODE (x), GET_MODE (x),
    5895                 :          0 :                                             GET_MODE (XEXP (x, 0)) != VOIDmode
    5896                 :            :                                             ? GET_MODE (XEXP (x, 0))
    5897                 :          0 :                                             : GET_MODE (XEXP (x, 1)),
    5898                 :            :                                             top0 ? top0 : XEXP (x, 0),
    5899                 :          0 :                                             top1 ? top1 : XEXP (x, 1));
    5900                 :            :           else
    5901                 :        188 :             return simplify_gen_binary (GET_CODE (x), GET_MODE (x),
    5902                 :            :                                         top0 ? top0 : XEXP (x, 0),
    5903                 :        188 :                                         top1 ? top1 : XEXP (x, 1));
    5904                 :            :         }
    5905                 :            :     }
    5906                 :     728812 :   if (GET_RTX_CLASS (GET_CODE (x)) == RTX_TERNARY
    5907                 :      10896 :       && VECTOR_MODE_P (GET_MODE (XEXP (x, 0)))
    5908                 :      21792 :       && known_eq (GET_MODE_NUNITS (GET_MODE (XEXP (x, 0))), nunits)
    5909                 :      10896 :       && VECTOR_MODE_P (GET_MODE (XEXP (x, 1)))
    5910                 :      21792 :       && known_eq (GET_MODE_NUNITS (GET_MODE (XEXP (x, 1))), nunits)
    5911                 :      10896 :       && VECTOR_MODE_P (GET_MODE (XEXP (x, 2)))
    5912                 :     739938 :       && known_eq (GET_MODE_NUNITS (GET_MODE (XEXP (x, 2))), nunits))
    5913                 :            :     {
    5914                 :       5563 :       rtx top0 = simplify_merge_mask (XEXP (x, 0), mask, op);
    5915                 :       5563 :       rtx top1 = simplify_merge_mask (XEXP (x, 1), mask, op);
    5916                 :       5563 :       rtx top2 = simplify_merge_mask (XEXP (x, 2), mask, op);
    5917                 :       5563 :       if (top0 || top1 || top2)
    5918                 :        188 :         return simplify_gen_ternary (GET_CODE (x), GET_MODE (x),
    5919                 :        188 :                                      GET_MODE (XEXP (x, 0)),
    5920                 :            :                                      top0 ? top0 : XEXP (x, 0),
    5921                 :            :                                      top1 ? top1 : XEXP (x, 1),
    5922                 :        188 :                                      top2 ? top2 : XEXP (x, 2));
    5923                 :            :     }
    5924                 :            :   return NULL_RTX;
    5925                 :            : }
    5926                 :            : 
    5927                 :            : 
    5928                 :            : /* Simplify CODE, an operation with result mode MODE and three operands,
    5929                 :            :    OP0, OP1, and OP2.  OP0_MODE was the mode of OP0 before it became
    5930                 :            :    a constant.  Return 0 if no simplifications is possible.  */
    5931                 :            : 
    5932                 :            : rtx
    5933                 :   23860500 : simplify_ternary_operation (enum rtx_code code, machine_mode mode,
    5934                 :            :                             machine_mode op0_mode, rtx op0, rtx op1,
    5935                 :            :                             rtx op2)
    5936                 :            : {
    5937                 :   23860500 :   bool any_change = false;
    5938                 :   23860500 :   rtx tem, trueop2;
    5939                 :   23860500 :   scalar_int_mode int_mode, int_op0_mode;
    5940                 :   23860500 :   unsigned int n_elts;
    5941                 :            : 
    5942                 :   23860500 :   switch (code)
    5943                 :            :     {
    5944                 :     264887 :     case FMA:
    5945                 :            :       /* Simplify negations around the multiplication.  */
    5946                 :            :       /* -a * -b + c  =>  a * b + c.  */
    5947                 :     264887 :       if (GET_CODE (op0) == NEG)
    5948                 :            :         {
    5949                 :      64017 :           tem = simplify_unary_operation (NEG, mode, op1, mode);
    5950                 :      64017 :           if (tem)
    5951                 :        181 :             op1 = tem, op0 = XEXP (op0, 0), any_change = true;
    5952                 :            :         }
    5953                 :     200870 :       else if (GET_CODE (op1) == NEG)
    5954                 :            :         {
    5955                 :        880 :           tem = simplify_unary_operation (NEG, mode, op0, mode);
    5956                 :        880 :           if (tem)
    5957                 :          0 :             op0 = tem, op1 = XEXP (op1, 0), any_change = true;
    5958                 :            :         }
    5959                 :            : 
    5960                 :            :       /* Canonicalize the two multiplication operands.  */
    5961                 :            :       /* a * -b + c  =>  -b * a + c.  */
    5962                 :     264887 :       if (swap_commutative_operands_p (op0, op1))
    5963                 :      17176 :         std::swap (op0, op1), any_change = true;
    5964                 :            : 
    5965                 :     264887 :       if (any_change)
    5966                 :      17357 :         return gen_rtx_FMA (mode, op0, op1, op2);
    5967                 :            :       return NULL_RTX;
    5968                 :            : 
    5969                 :     337611 :     case SIGN_EXTRACT:
    5970                 :     337611 :     case ZERO_EXTRACT:
    5971                 :     337611 :       if (CONST_INT_P (op0)
    5972                 :       1221 :           && CONST_INT_P (op1)
    5973                 :       1221 :           && CONST_INT_P (op2)
    5974                 :         27 :           && is_a <scalar_int_mode> (mode, &int_mode)
    5975                 :         27 :           && INTVAL (op1) + INTVAL (op2) <= GET_MODE_PRECISION (int_mode)
    5976                 :     337638 :           && HWI_COMPUTABLE_MODE_P (int_mode))
    5977                 :            :         {
    5978                 :            :           /* Extracting a bit-field from a constant */
    5979                 :         27 :           unsigned HOST_WIDE_INT val = UINTVAL (op0);
    5980                 :         27 :           HOST_WIDE_INT op1val = INTVAL (op1);
    5981                 :         27 :           HOST_WIDE_INT op2val = INTVAL (op2);
    5982                 :         27 :           if (!BITS_BIG_ENDIAN)
    5983                 :         27 :             val >>= op2val;
    5984                 :            :           else if (is_a <scalar_int_mode> (op0_mode, &int_op0_mode))
    5985                 :            :             val >>= GET_MODE_PRECISION (int_op0_mode) - op2val - op1val;
    5986                 :            :           else
    5987                 :            :             /* Not enough information to calculate the bit position.  */
    5988                 :            :             break;
    5989                 :            : 
    5990                 :         27 :           if (HOST_BITS_PER_WIDE_INT != op1val)
    5991                 :            :             {
    5992                 :            :               /* First zero-extend.  */
    5993                 :         26 :               val &= (HOST_WIDE_INT_1U << op1val) - 1;
    5994                 :            :               /* If desired, propagate sign bit.  */
    5995                 :         26 :               if (code == SIGN_EXTRACT
    5996                 :         12 :                   && (val & (HOST_WIDE_INT_1U << (op1val - 1)))
    5997                 :         12 :                      != 0)
    5998                 :          3 :                 val |= ~ ((HOST_WIDE_INT_1U << op1val) - 1);
    5999                 :            :             }
    6000                 :            : 
    6001                 :         27 :           return gen_int_mode (val, int_mode);
    6002                 :            :         }
    6003                 :            :       break;
    6004                 :            : 
    6005                 :   22912500 :     case IF_THEN_ELSE:
    6006                 :   22912500 :       if (CONST_INT_P (op0))
    6007                 :     187229 :         return op0 != const0_rtx ? op1 : op2;
    6008                 :            : 
    6009                 :            :       /* Convert c ? a : a into "a".  */
    6010                 :   22790200 :       if (rtx_equal_p (op1, op2) && ! side_effects_p (op0))
    6011                 :            :         return op1;
    6012                 :            : 
    6013                 :            :       /* Convert a != b ? a : b into "a".  */
    6014                 :   22789900 :       if (GET_CODE (op0) == NE
    6015                 :    7852590 :           && ! side_effects_p (op0)
    6016                 :    7818320 :           && ! HONOR_NANS (mode)
    6017                 :    7814860 :           && ! HONOR_SIGNED_ZEROS (mode)
    6018                 :   30604800 :           && ((rtx_equal_p (XEXP (op0, 0), op1)
    6019                 :      86335 :                && rtx_equal_p (XEXP (op0, 1), op2))
    6020                 :    7814780 :               || (rtx_equal_p (XEXP (op0, 0), op2)
    6021                 :        835 :                   && rtx_equal_p (XEXP (op0, 1), op1))))
    6022                 :         78 :         return op1;
    6023                 :            : 
    6024                 :            :       /* Convert a == b ? a : b into "b".  */
    6025                 :   22789900 :       if (GET_CODE (op0) == EQ
    6026                 :    6782010 :           && ! side_effects_p (op0)
    6027                 :    6772430 :           && ! HONOR_NANS (mode)
    6028                 :    6654770 :           && ! HONOR_SIGNED_ZEROS (mode)
    6029                 :   29444600 :           && ((rtx_equal_p (XEXP (op0, 0), op1)
    6030                 :      11639 :                && rtx_equal_p (XEXP (op0, 1), op2))
    6031                 :    6654760 :               || (rtx_equal_p (XEXP (op0, 0), op2)
    6032                 :      10541 :                   && rtx_equal_p (XEXP (op0, 1), op1))))
    6033                 :         48 :         return op2;
    6034                 :            : 
    6035                 :            :       /* Convert (!c) != {0,...,0} ? a : b into
    6036                 :            :          c != {0,...,0} ? b : a for vector modes.  */
    6037                 :   22789800 :       if (VECTOR_MODE_P (GET_MODE (op1))
    6038                 :       8278 :           && GET_CODE (op0) == NE
    6039                 :         60 :           && GET_CODE (XEXP (op0, 0)) == NOT
    6040                 :          0 :           && GET_CODE (XEXP (op0, 1)) == CONST_VECTOR)
    6041                 :            :         {
    6042                 :          0 :           rtx cv = XEXP (op0, 1);
    6043                 :          0 :           int nunits;
    6044                 :          0 :           bool ok = true;
    6045                 :          0 :           if (!CONST_VECTOR_NUNITS (cv).is_constant (&nunits))
    6046                 :            :             ok = false;
    6047                 :            :           else
    6048                 :          0 :             for (int i = 0; i < nunits; ++i)
    6049                 :          0 :               if (CONST_VECTOR_ELT (cv, i) != const0_rtx)
    6050                 :            :                 {
    6051                 :            :                   ok = false;
    6052                 :            :                   break;
    6053                 :            :                 }
    6054                 :          0 :           if (ok)
    6055                 :            :             {
    6056                 :          0 :               rtx new_op0 = gen_rtx_NE (GET_MODE (op0),
    6057                 :            :                                         XEXP (XEXP (op0, 0), 0),
    6058                 :            :                                         XEXP (op0, 1));
    6059                 :          0 :               rtx retval = gen_rtx_IF_THEN_ELSE (mode, new_op0, op2, op1);
    6060                 :          0 :               return retval;
    6061                 :            :             }
    6062                 :            :         }
    6063                 :            : 
    6064                 :            :       /* Convert x == 0 ? N : clz (x) into clz (x) when
    6065                 :            :          CLZ_DEFINED_VALUE_AT_ZERO is defined to N for the mode of x.
    6066                 :            :          Similarly for ctz (x).  */
    6067                 :   22789600 :       if (COMPARISON_P (op0) && !side_effects_p (op0)
    6068                 :   45492200 :           && XEXP (op0, 1) == const0_rtx)
    6069                 :            :         {
    6070                 :   18370000 :           rtx simplified
    6071                 :   18370000 :             = simplify_cond_clz_ctz (XEXP (op0, 0), GET_CODE (op0),
    6072                 :            :                                      op1, op2);
    6073                 :   18370000 :           if (simplified)
    6074                 :            :             return simplified;
    6075                 :            :         }
    6076                 :            : 
    6077                 :   22789800 :       if (COMPARISON_P (op0) && ! side_effects_p (op0))
    6078                 :            :         {
    6079                 :   45404800 :           machine_mode cmp_mode = (GET_MODE (XEXP (op0, 0)) == VOIDmode
    6080                 :   22702400 :                                         ? GET_MODE (XEXP (op0, 1))
    6081                 :            :                                         : GET_MODE (XEXP (op0, 0)));
    6082                 :   22702400 :           rtx temp;
    6083                 :            : 
    6084                 :            :           /* Look for happy constants in op1 and op2.  */
    6085                 :   22702400 :           if (CONST_INT_P (op1) && CONST_INT_P (op2))
    6086                 :            :             {
    6087                 :     144618 :               HOST_WIDE_INT t = INTVAL (op1);
    6088                 :     144618 :               HOST_WIDE_INT f = INTVAL (op2);
    6089                 :            : 
    6090                 :     144618 :               if (t == STORE_FLAG_VALUE && f == 0)
    6091                 :      24788 :                 code = GET_CODE (op0);
    6092                 :     119830 :               else if (t == 0 && f == STORE_FLAG_VALUE)
    6093                 :            :                 {
    6094                 :      25969 :                   enum rtx_code tmp;
    6095                 :      25969 :                   tmp = reversed_comparison_code (op0, NULL);
    6096                 :      25969 :                   if (tmp == UNKNOWN)
    6097                 :            :                     break;
    6098                 :            :                   code = tmp;
    6099                 :            :                 }
    6100                 :            :               else
    6101                 :            :                 break;
    6102                 :            : 
    6103                 :      45852 :               return simplify_gen_relational (code, mode, cmp_mode,
    6104                 :      45852 :                                               XEXP (op0, 0), XEXP (op0, 1));
    6105                 :            :             }
    6106                 :            : 
    6107                 :   22557800 :           temp = simplify_relational_operation (GET_CODE (op0), op0_mode,
    6108                 :            :                                                 cmp_mode, XEXP (op0, 0),
    6109                 :            :                                                 XEXP (op0, 1));
    6110                 :            : 
    6111                 :            :           /* See if any simplifications were possible.  */
    6112                 :   22557800 :           if (temp)
    6113                 :            :             {
    6114                 :       5163 :               if (CONST_INT_P (temp))
    6115                 :         25 :                 return temp == const0_rtx ? op2 : op1;
    6116                 :       5144 :               else if (temp)
    6117                 :       5144 :                 return gen_rtx_IF_THEN_ELSE (mode, temp, op1, op2);
    6118                 :            :             }
    6119                 :            :         }
    6120                 :            :       break;
    6121                 :            : 
    6122                 :     345462 :     case VEC_MERGE:
    6123                 :     345462 :       gcc_assert (GET_MODE (op0) == mode);
    6124                 :     345462 :       gcc_assert (GET_MODE (op1) == mode);
    6125                 :     345462 :       gcc_assert (VECTOR_MODE_P (mode));
    6126                 :     345462 :       trueop2 = avoid_constant_pool_reference (op2);
    6127                 :     345462 :       if (CONST_INT_P (trueop2)
    6128                 :     515250 :           && GET_MODE_NUNITS (mode).is_constant (&n_elts))
    6129                 :            :         {
    6130                 :     169788 :           unsigned HOST_WIDE_INT sel = UINTVAL (trueop2);
    6131                 :     169788 :           unsigned HOST_WIDE_INT mask;
    6132                 :     169788 :           if (n_elts == HOST_BITS_PER_WIDE_INT)
    6133                 :            :             mask = -1;
    6134                 :            :           else
    6135                 :     168736 :             mask = (HOST_WIDE_INT_1U << n_elts) - 1;
    6136                 :            : 
    6137                 :     169788 :           if (!(sel & mask) && !side_effects_p (op0))
    6138                 :            :             return op1;
    6139                 :     169474 :           if ((sel & mask) == mask && !side_effects_p (op1))
    6140                 :            :             return op0;
    6141                 :            : 
    6142                 :     162766 :           rtx trueop0 = avoid_constant_pool_reference (op0);
    6143                 :     162766 :           rtx trueop1 = avoid_constant_pool_reference (op1);
    6144                 :     162766 :           if (GET_CODE (trueop0) == CONST_VECTOR
    6145                 :       6905 :               && GET_CODE (trueop1) == CONST_VECTOR)
    6146                 :            :             {
    6147                 :       2620 :               rtvec v = rtvec_alloc (n_elts);
    6148                 :       2620 :               unsigned int i;
    6149                 :            : 
    6150                 :      18464 :               for (i = 0; i < n_elts; i++)
    6151                 :      15844 :                 RTVEC_ELT (v, i) = ((sel & (HOST_WIDE_INT_1U << i))
    6152                 :       4895 :                                     ? CONST_VECTOR_ELT (trueop0, i)
    6153                 :      15844 :                                     : CONST_VECTOR_ELT (trueop1, i));
    6154                 :       2620 :               return gen_rtx_CONST_VECTOR (mode, v);
    6155                 :            :             }
    6156                 :            : 
    6157                 :            :           /* Replace (vec_merge (vec_merge a b m) c n) with (vec_merge b c n)
    6158                 :            :              if no element from a appears in the result.  */
    6159                 :     160146 :           if (GET_CODE (op0) == VEC_MERGE)
    6160                 :            :             {
    6161                 :       9803 :               tem = avoid_constant_pool_reference (XEXP (op0, 2));
    6162                 :       9803 :               if (CONST_INT_P (tem))
    6163                 :            :                 {
    6164                 :        748 :                   unsigned HOST_WIDE_INT sel0 = UINTVAL (tem);
    6165                 :        748 :                   if (!(sel & sel0 & mask) && !side_effects_p (XEXP (op0, 0)))
    6166                 :          8 :                     return simplify_gen_ternary (code, mode, mode,
    6167                 :          8 :                                                  XEXP (op0, 1), op1, op2);
    6168                 :        740 :                   if (!(sel & ~sel0 & mask) && !side_effects_p (XEXP (op0, 1)))
    6169                 :        628 :                     return simplify_gen_ternary (code, mode, mode,
    6170                 :        628 :                                                  XEXP (op0, 0), op1, op2);
    6171                 :            :                 }
    6172                 :            :             }
    6173                 :     159510 :           if (GET_CODE (op1) == VEC_MERGE)
    6174                 :            :             {
    6175                 :        671 :               tem = avoid_constant_pool_reference (XEXP (op1, 2));
    6176                 :        671 :               if (CONST_INT_P (tem))
    6177                 :            :                 {
    6178                 :        527 :                   unsigned HOST_WIDE_INT sel1 = UINTVAL (tem);
    6179                 :        527 :                   if (!(~sel & sel1 & mask) && !side_effects_p (XEXP (op1, 0)))
    6180                 :         93 :                     return simplify_gen_ternary (code, mode, mode,
    6181                 :         93 :                                                  op0, XEXP (op1, 1), op2);
    6182                 :        434 :                   if (!(~sel & ~sel1 & mask) && !side_effects_p (XEXP (op1, 1)))
    6183                 :          0 :                     return simplify_gen_ternary (code, mode, mode,
    6184                 :          0 :                                                  op0, XEXP (op1, 0), op2);
    6185                 :            :                 }
    6186                 :            :             }
    6187                 :            : 
    6188                 :            :           /* Replace (vec_merge (vec_duplicate (vec_select a parallel (i))) a 1 << i)
    6189                 :            :              with a.  */
    6190                 :     159417 :           if (GET_CODE (op0) == VEC_DUPLICATE
    6191                 :      86250 :               && GET_CODE (XEXP (op0, 0)) == VEC_SELECT
    6192                 :        859 :               && GET_CODE (XEXP (XEXP (op0, 0), 1)) == PARALLEL
    6193                 :     161135 :               && known_eq (GET_MODE_NUNITS (GET_MODE (XEXP (op0, 0))), 1))
    6194                 :            :             {
    6195                 :        751 :               tem = XVECEXP ((XEXP (XEXP (op0, 0), 1)), 0, 0);
    6196                 :        751 :               if (CONST_INT_P (tem) && CONST_INT_P (op2))
    6197                 :            :                 {
    6198                 :        751 :                   if (XEXP (XEXP (op0, 0), 0) == op1
    6199                 :          2 :                       && UINTVAL (op2) == HOST_WIDE_INT_1U << UINTVAL (tem))
    6200                 :            :                     return op1;
    6201                 :            :                 }
    6202                 :            :             }
    6203                 :            :           /* Replace (vec_merge (vec_duplicate (X)) (const_vector [A, B])
    6204                 :            :              (const_int N))
    6205                 :            :              with (vec_concat (X) (B)) if N == 1 or
    6206                 :            :              (vec_concat (A) (X)) if N == 2.  */
    6207                 :     159415 :           if (GET_CODE (op0) == VEC_DUPLICATE
    6208                 :      86248 :               && GET_CODE (op1) == CONST_VECTOR
    6209                 :      68034 :               && known_eq (CONST_VECTOR_NUNITS (op1), 2)
    6210                 :        224 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op0)), 2)
    6211                 :     159527 :               && IN_RANGE (sel, 1, 2))
    6212                 :            :             {
    6213                 :        110 :               rtx newop0 = XEXP (op0, 0);
    6214                 :        110 :               rtx newop1 = CONST_VECTOR_ELT (op1, 2 - sel);
    6215                 :        110 :               if (sel == 2)
    6216                 :         20 :                 std::swap (newop0, newop1);
    6217                 :        110 :               return simplify_gen_binary (VEC_CONCAT, mode, newop0, newop1);
    6218                 :            :             }
    6219                 :            :           /* Replace (vec_merge (vec_duplicate x) (vec_concat (y) (z)) (const_int N))
    6220                 :            :              with (vec_concat x z) if N == 1, or (vec_concat y x) if N == 2.
    6221                 :            :              Only applies for vectors of two elements.  */
    6222                 :     159305 :           if (GET_CODE (op0) == VEC_DUPLICATE
    6223                 :      86138 :               && GET_CODE (op1) == VEC_CONCAT
    6224                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op0)), 2)
    6225                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op1)), 2)
    6226                 :     159305 :               && IN_RANGE (sel, 1, 2))
    6227                 :            :             {
    6228                 :          0 :               rtx newop0 = XEXP (op0, 0);
    6229                 :          0 :               rtx newop1 = XEXP (op1, 2 - sel);
    6230                 :          0 :               rtx otherop = XEXP (op1, sel - 1);
    6231                 :          0 :               if (sel == 2)
    6232                 :          0 :                 std::swap (newop0, newop1);
    6233                 :            :               /* Don't want to throw away the other part of the vec_concat if
    6234                 :            :                  it has side-effects.  */
    6235                 :          0 :               if (!side_effects_p (otherop))
    6236                 :          0 :                 return simplify_gen_binary (VEC_CONCAT, mode, newop0, newop1);
    6237                 :            :             }
    6238                 :            : 
    6239                 :            :           /* Replace:
    6240                 :            : 
    6241                 :            :               (vec_merge:outer (vec_duplicate:outer x:inner)
    6242                 :            :                                (subreg:outer y:inner 0)
    6243                 :            :                                (const_int N))
    6244                 :            : 
    6245                 :            :              with (vec_concat:outer x:inner y:inner) if N == 1,
    6246                 :            :              or (vec_concat:outer y:inner x:inner) if N == 2.
    6247                 :            : 
    6248                 :            :              Implicitly, this means we have a paradoxical subreg, but such
    6249                 :            :              a check is cheap, so make it anyway.
    6250                 :            : 
    6251                 :            :              Only applies for vectors of two elements.  */
    6252                 :     159305 :           if (GET_CODE (op0) == VEC_DUPLICATE
    6253                 :      86138 :               && GET_CODE (op1) == SUBREG
    6254                 :      41410 :               && GET_MODE (op1) == GET_MODE (op0)
    6255                 :      41410 :               && GET_MODE (SUBREG_REG (op1)) == GET_MODE (XEXP (op0, 0))
    6256                 :          0 :               && paradoxical_subreg_p (op1)
    6257                 :          0 :               && subreg_lowpart_p (op1)
    6258                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op0)), 2)
    6259                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op1)), 2)
    6260                 :     159305 :               && IN_RANGE (sel, 1, 2))
    6261                 :            :             {
    6262                 :          0 :               rtx newop0 = XEXP (op0, 0);
    6263                 :          0 :               rtx newop1 = SUBREG_REG (op1);
    6264                 :          0 :               if (sel == 2)
    6265                 :          0 :                 std::swap (newop0, newop1);
    6266                 :          0 :               return simplify_gen_binary (VEC_CONCAT, mode, newop0, newop1);
    6267                 :            :             }
    6268                 :            : 
    6269                 :            :           /* Same as above but with switched operands:
    6270                 :            :                 Replace (vec_merge:outer (subreg:outer x:inner 0)
    6271                 :            :                                          (vec_duplicate:outer y:inner)
    6272                 :            :                                (const_int N))
    6273                 :            : 
    6274                 :            :              with (vec_concat:outer x:inner y:inner) if N == 1,
    6275                 :            :              or (vec_concat:outer y:inner x:inner) if N == 2.  */
    6276                 :     159305 :           if (GET_CODE (op1) == VEC_DUPLICATE
    6277                 :       1047 :               && GET_CODE (op0) == SUBREG
    6278                 :        238 :               && GET_MODE (op0) == GET_MODE (op1)
    6279                 :        238 :               && GET_MODE (SUBREG_REG (op0)) == GET_MODE (XEXP (op1, 0))
    6280                 :          0 :               && paradoxical_subreg_p (op0)
    6281                 :          0 :               && subreg_lowpart_p (op0)
    6282                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op1)), 2)
    6283                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op0)), 2)
    6284                 :     159305 :               && IN_RANGE (sel, 1, 2))
    6285                 :            :             {
    6286                 :          0 :               rtx newop0 = SUBREG_REG (op0);
    6287                 :          0 :               rtx newop1 = XEXP (op1, 0);
    6288                 :          0 :               if (sel == 2)
    6289                 :          0 :                 std::swap (newop0, newop1);
    6290                 :          0 :               return simplify_gen_binary (VEC_CONCAT, mode, newop0, newop1);
    6291                 :            :             }
    6292                 :            : 
    6293                 :            :           /* Replace (vec_merge (vec_duplicate x) (vec_duplicate y)
    6294                 :            :                                  (const_int n))
    6295                 :            :              with (vec_concat x y) or (vec_concat y x) depending on value
    6296                 :            :              of N.  */
    6297                 :     159305 :           if (GET_CODE (op0) == VEC_DUPLICATE
    6298                 :      86138 :               && GET_CODE (op1) == VEC_DUPLICATE
    6299                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op0)), 2)
    6300                 :          0 :               && known_eq (GET_MODE_NUNITS (GET_MODE (op1)), 2)
    6301                 :     159305 :               && IN_RANGE (sel, 1, 2))
    6302                 :            :             {
    6303                 :          0 :               rtx newop0 = XEXP (op0, 0);
    6304                 :          0 :               rtx newop1 = XEXP (op1, 0);
    6305                 :          0 :               if (sel == 2)
    6306                 :          0 :                 std::swap (newop0, newop1);
    6307                 :            : 
    6308                 :          0 :               return simplify_gen_binary (VEC_CONCAT, mode, newop0, newop1);
    6309                 :            :             }
    6310                 :            :         }
    6311                 :            : 
    6312                 :     334979 :       if (rtx_equal_p (op0, op1)
    6313                 :     334979 :           && !side_effects_p (op2) && !side_effects_p (op1))
    6314                 :            :         return op0;
    6315                 :            : 
    6316                 :     334979 :       if (!side_effects_p (op2))
    6317                 :            :         {
    6318                 :     330455 :           rtx top0
    6319                 :     330455 :             = may_trap_p (op0) ? NULL_RTX : simplify_merge_mask (op0, op2, 0);
    6320                 :     330455 :           rtx top1
    6321                 :     330455 :             = may_trap_p (op1) ? NULL_RTX : simplify_merge_mask (op1, op2, 1);
    6322                 :     330455 :           if (top0 || top1)
    6323                 :        130 :             return simplify_gen_ternary (code, mode, mode,
    6324                 :            :                                          top0 ? top0 : op0,
    6325                 :        112 :                                          top1 ? top1 : op1, op2);
    6326                 :            :         }
    6327                 :            : 
    6328                 :            :       break;
    6329                 :            : 
    6330                 :          0 :     default:
    6331                 :          0 :       gcc_unreachable ();
    6332                 :            :     }
    6333                 :            : 
    6334                 :            :   return 0;
    6335                 :            : }
    6336                 :            : 
    6337                 :            : /* Try to calculate NUM_BYTES bytes of the target memory image of X,
    6338                 :            :    starting at byte FIRST_BYTE.  Return true on success and add the
    6339                 :            :    bytes to BYTES, such that each byte has BITS_PER_UNIT bits and such
    6340                 :            :    that the bytes follow target memory order.  Leave BYTES unmodified
    6341                 :            :    on failure.
    6342                 :            : 
    6343                 :            :    MODE is the mode of X.  The caller must reserve NUM_BYTES bytes in
    6344                 :            :    BYTES before calling this function.  */
    6345                 :            : 
    6346                 :            : bool
    6347                 :    6471200 : native_encode_rtx (machine_mode mode, rtx x, vec<target_unit> &bytes,
    6348                 :            :                    unsigned int first_byte, unsigned int num_bytes)
    6349                 :            : {
    6350                 :            :   /* Check the mode is sensible.  */
    6351                 :    6471200 :   gcc_assert (GET_MODE (x) == VOIDmode
    6352                 :            :               ? is_a <scalar_int_mode> (mode)
    6353                 :            :               : mode == GET_MODE (x));
    6354                 :            : 
    6355                 :    6471200 :   if (GET_CODE (x) == CONST_VECTOR)
    6356                 :            :     {
    6357                 :            :       /* CONST_VECTOR_ELT follows target memory order, so no shuffling
    6358                 :            :          is necessary.  The only complication is that MODE_VECTOR_BOOL
    6359                 :            :          vectors can have several elements per byte.  */
    6360                 :      98046 :       unsigned int elt_bits = vector_element_size (GET_MODE_BITSIZE (mode),
    6361                 :            :                                                    GET_MODE_NUNITS (mode));
    6362                 :      32682 :       unsigned int elt = first_byte * BITS_PER_UNIT / elt_bits;
    6363                 :      32682 :       if (elt_bits < BITS_PER_UNIT)
    6364                 :            :         {
    6365                 :            :           /* This is the only case in which elements can be smaller than
    6366                 :            :              a byte.  */
    6367                 :          0 :           gcc_assert (GET_MODE_CLASS (mode) == MODE_VECTOR_BOOL);
    6368                 :          0 :           for (unsigned int i = 0; i < num_bytes; ++i)
    6369                 :            :             {
    6370                 :            :               target_unit value = 0;
    6371                 :          0 :               for (unsigned int j = 0; j < BITS_PER_UNIT; j += elt_bits)
    6372                 :            :                 {
    6373                 :          0 :                   value |= (INTVAL (CONST_VECTOR_ELT (x, elt)) & 1) << j;
    6374                 :          0 :                   elt += 1;
    6375                 :            :                 }
    6376                 :          0 :               bytes.quick_push (value);
    6377                 :            :             }
    6378                 :            :           return true;
    6379                 :            :         }
    6380                 :            : 
    6381                 :      32682 :       unsigned int start = bytes.length ();
    6382                 :      32682 :       unsigned int elt_bytes = GET_MODE_UNIT_SIZE (mode);
    6383                 :            :       /* Make FIRST_BYTE relative to ELT.  */
    6384                 :      32682 :       first_byte %= elt_bytes;
    6385                 :     151627 :       while (num_bytes > 0)
    6386                 :            :         {
    6387                 :            :           /* Work out how many bytes we want from element ELT.  */
    6388                 :     118945 :           unsigned int chunk_bytes = MIN (num_bytes, elt_bytes - first_byte);
    6389                 :     237890 :           if (!native_encode_rtx (GET_MODE_INNER (mode),
    6390                 :            :                                   CONST_VECTOR_ELT (x, elt), bytes,
    6391                 :            :                                   first_byte, chunk_bytes))
    6392                 :            :             {
    6393                 :          0 :               bytes.truncate (start);
    6394                 :          0 :               return false;
    6395                 :            :             }
    6396                 :     118945 :           elt += 1;
    6397                 :     118945 :           first_byte = 0;
    6398                 :     118945 :           num_bytes -= chunk_bytes;
    6399                 :            :         }
    6400                 :            :       return true;
    6401                 :            :     }
    6402                 :            : 
    6403                 :            :   /* All subsequent cases are limited to scalars.  */
    6404                 :    6438510 :   scalar_mode smode;
    6405                 :    6438510 :   if (!is_a <scalar_mode> (mode, &smode))
    6406                 :            :     return false;
    6407                 :            : 
    6408                 :            :   /* Make sure that the region is in range.  */
    6409                 :    6438510 :   unsigned int end_byte = first_byte + num_bytes;
    6410                 :    6438510 :   unsigned int mode_bytes = GET_MODE_SIZE (smode);
    6411                 :    6438510 :   gcc_assert (end_byte <= mode_bytes);
    6412                 :            : 
    6413                 :    6438510 :   if (CONST_SCALAR_INT_P (x))
    6414                 :            :     {
    6415                 :            :       /* The target memory layout is affected by both BYTES_BIG_ENDIAN
    6416                 :            :          and WORDS_BIG_ENDIAN.  Use the subreg machinery to get the lsb
    6417                 :            :          position of each byte.  */
    6418                 :    6404810 :       rtx_mode_t value (x, smode);
    6419                 :    6404810 :       wide_int_ref value_wi (value);
    6420                 :   28658100 :       for (unsigned int byte = first_byte; byte < end_byte; ++byte)
    6421                 :            :         {
    6422                 :            :           /* Always constant because the inputs are.  */
    6423                 :   22253300 :           unsigned int lsb
    6424                 :   22253300 :             = subreg_size_lsb (1, mode_bytes, byte).to_constant ();
    6425                 :            :           /* Operate directly on the encoding rather than using
    6426                 :            :              wi::extract_uhwi, so that we preserve the sign or zero
    6427                 :            :              extension for modes that are not a whole number of bits in
    6428                 :            :              size.  (Zero extension is only used for the combination of
    6429                 :            :              innermode == BImode && STORE_FLAG_VALUE == 1).  */
    6430                 :   22253300 :           unsigned int elt = lsb / HOST_BITS_PER_WIDE_INT;
    6431                 :   22253300 :           unsigned int shift = lsb % HOST_BITS_PER_WIDE_INT;
    6432                 :   22253300 :           unsigned HOST_WIDE_INT uhwi = value_wi.elt (elt);
    6433                 :   22253300 :           bytes.quick_push (uhwi >> shift);
    6434                 :            :         }
    6435                 :    6404810 :       return true;
    6436                 :            :     }
    6437                 :            : 
    6438                 :      33701 :   if (CONST_DOUBLE_P (x))
    6439                 :            :     {
    6440                 :            :       /* real_to_target produces an array of integers in target memory order.
    6441                 :            :          All integers before the last one have 32 bits; the last one may
    6442                 :            :          have 32 bits or fewer, depending on whether the mode bitsize
    6443                 :            :          is divisible by 32.  Each of these integers is then laid out
    6444                 :            :          in target memory as any other integer would be.  */
    6445                 :      33701 :       long el32[MAX_BITSIZE_MODE_ANY_MODE / 32];
    6446                 :      33701 :       real_to_target (el32, CONST_DOUBLE_REAL_VALUE (x), smode);
    6447                 :            : 
    6448                 :            :       /* The (maximum) number of target bytes per element of el32.  */
    6449                 :      33701 :       unsigned int bytes_per_el32 = 32 / BITS_PER_UNIT;
    6450                 :      33701 :       gcc_assert (bytes_per_el32 != 0);
    6451                 :            : 
    6452                 :            :       /* Build up the integers in a similar way to the CONST_SCALAR_INT_P
    6453                 :            :          handling above.  */
    6454                 :     319573 :       for (unsigned int byte = first_byte; byte < end_byte; ++byte)
    6455                 :            :         {
    6456                 :     285872 :           unsigned int index = byte / bytes_per_el32;
    6457                 :     285872 :           unsigned int subbyte = byte % bytes_per_el32;
    6458                 :     285872 :           unsigned int int_bytes = MIN (bytes_per_el32,
    6459                 :            :                                         mode_bytes - index * bytes_per_el32);
    6460                 :            :           /* Always constant because the inputs are.  */
    6461                 :     285872 :           unsigned int lsb
    6462                 :     285872 :             = subreg_size_lsb (1, int_bytes, subbyte).to_constant ();
    6463                 :     285872 :           bytes.quick_push ((unsigned long) el32[index] >> lsb);
    6464                 :            :         }
    6465                 :      33701 :       return true;
    6466                 :            :     }
    6467                 :            : 
    6468                 :          0 :   if (GET_CODE (x) == CONST_FIXED)
    6469                 :            :     {
    6470                 :          0 :       for (unsigned int byte = first_byte; byte < end_byte; ++byte)
    6471                 :            :         {
    6472                 :            :           /* Always constant because the inputs are.  */
    6473                 :          0 :           unsigned int lsb
    6474                 :          0 :             = subreg_size_lsb (1, mode_bytes, byte).to_constant ();
    6475                 :          0 :           unsigned HOST_WIDE_INT piece = CONST_FIXED_VALUE_LOW (x);
    6476                 :          0 :           if (lsb >= HOST_BITS_PER_WIDE_INT)
    6477                 :            :             {
    6478                 :          0 :               lsb -= HOST_BITS_PER_WIDE_INT;
    6479                 :          0 :               piece = CONST_FIXED_VALUE_HIGH (x);
    6480                 :            :             }
    6481                 :          0 :           bytes.quick_push (piece >> lsb);
    6482                 :            :         }
    6483                 :            :       return true;
    6484                 :            :     }
    6485                 :            : 
    6486                 :            :   return false;
    6487                 :            : }
    6488                 :            : 
    6489                 :            : /* Read a vector of mode MODE from the target memory image given by BYTES,
    6490                 :            :    starting at byte FIRST_BYTE.  The vector is known to be encodable using
    6491                 :            :    NPATTERNS interleaved patterns with NELTS_PER_PATTERN elements each,
    6492                 :            :    and BYTES is known to have enough bytes to supply NPATTERNS *
    6493                 :            :    NELTS_PER_PATTERN vector elements.  Each element of BYTES contains
    6494                 :            :    BITS_PER_UNIT bits and the bytes are in target memory order.
    6495                 :            : 
    6496                 :            :    Return the vector on success, otherwise return NULL_RTX.  */
    6497                 :            : 
    6498                 :            : rtx
    6499                 :      19842 : native_decode_vector_rtx (machine_mode mode, vec<target_unit> bytes,
    6500                 :            :                           unsigned int first_byte, unsigned int npatterns,
    6501                 :            :                           unsigned int nelts_per_pattern)
    6502                 :            : {
    6503                 :      19842 :   rtx_vector_builder builder (mode, npatterns, nelts_per_pattern);
    6504                 :            : 
    6505                 :      59526 :   unsigned int elt_bits = vector_element_size (GET_MODE_BITSIZE (mode),
    6506                 :            :                                                GET_MODE_NUNITS (mode));
    6507                 :      19842 :   if (elt_bits < BITS_PER_UNIT)
    6508                 :            :     {
    6509                 :            :       /* This is the only case in which elements can be smaller than a byte.
    6510                 :            :          Element 0 is always in the lsb of the containing byte.  */
    6511                 :          0 :       gcc_assert (GET_MODE_CLASS (mode) == MODE_VECTOR_BOOL);
    6512                 :          0 :       for (unsigned int i = 0; i < builder.encoded_nelts (); ++i)
    6513                 :            :         {
    6514                 :          0 :           unsigned int bit_index = first_byte * BITS_PER_UNIT + i * elt_bits;
    6515                 :          0 :           unsigned int byte_index = bit_index / BITS_PER_UNIT;
    6516                 :          0 :           unsigned int lsb = bit_index % BITS_PER_UNIT;
    6517                 :          0 :           builder.quick_push (bytes[byte_index] & (1 << lsb)
    6518                 :            :                               ? CONST1_RTX (BImode)
    6519                 :          0 :                               : CONST0_RTX (BImode));
    6520                 :            :         }
    6521                 :            :     }
    6522                 :            :   else
    6523                 :            :     {
    6524                 :     168346 :       for (unsigned int i = 0; i < builder.encoded_nelts (); ++i)
    6525                 :            :         {
    6526                 :     297008 :           rtx x = native_decode_rtx (GET_MODE_INNER (mode), bytes, first_byte);
    6527                 :     148504 :           if (!x)
    6528                 :      19842 :             return NULL_RTX;
    6529                 :     148504 :           builder.quick_push (x);
    6530                 :     148504 :           first_byte += elt_bits / BITS_PER_UNIT;
    6531                 :            :         }
    6532                 :            :     }
    6533                 :      19842 :   return builder.build ();
    6534                 :            : }
    6535                 :            : 
    6536                 :            : /* Read an rtx of mode MODE from the target memory image given by BYTES,
    6537                 :            :    starting at byte FIRST_BYTE.  Each element of BYTES contains BITS_PER_UNIT
    6538                 :            :    bits and the bytes are in target memory order.  The image has enough
    6539                 :            :    values to specify all bytes of MODE.
    6540                 :            : 
    6541                 :            :    Return the rtx on success, otherwise return NULL_RTX.  */
    6542                 :            : 
    6543                 :            : rtx
    6544                 :    6486830 : native_decode_rtx (machine_mode mode, vec<target_unit> bytes,
    6545                 :            :                    unsigned int first_byte)
    6546                 :            : {
    6547                 :    6486830 :   if (VECTOR_MODE_P (mode))
    6548                 :            :     {
    6549                 :            :       /* If we know at compile time how many elements there are,
    6550                 :            :          pull each element directly from BYTES.  */
    6551                 :       5919 :       unsigned int nelts;
    6552                 :      11838 :       if (GET_MODE_NUNITS (mode).is_constant (&nelts))
    6553                 :       5919 :         return native_decode_vector_rtx (mode, bytes, first_byte, nelts, 1);
    6554                 :            :       return NULL_RTX;
    6555                 :            :     }
    6556                 :            : 
    6557                 :    6480910 :   scalar_int_mode imode;
    6558                 :    6480910 :   if (is_a <scalar_int_mode> (mode, &imode)
    6559                 :   12895400 :       && GET_MODE_PRECISION (imode) <= MAX_BITSIZE_MODE_ANY_INT)
    6560                 :            :     {
    6561                 :            :       /* Pull the bytes msb first, so that we can use simple
    6562                 :            :          shift-and-insert wide_int operations.  */
    6563                 :    6414460 :       unsigned int size = GET_MODE_SIZE (imode);
    6564                 :    6414460 :       wide_int result (wi::zero (GET_MODE_PRECISION (imode)));
    6565                 :   28720300 :       for (unsigned int i = 0; i < size; ++i)
    6566                 :            :         {
    6567                 :   22305800 :           unsigned int lsb = (size - i - 1) * BITS_PER_UNIT;
    6568                 :            :           /* Always constant because the inputs are.  */
    6569                 :   22305800 :           unsigned int subbyte
    6570                 :   22305800 :             = subreg_size_offset_from_lsb (1, size, lsb).to_constant ();
    6571                 :   22305800 :           result <<= BITS_PER_UNIT;
    6572                 :   22305800 :           result |= bytes[first_byte + subbyte];
    6573                 :            :         }
    6574                 :    6414460 :       return immed_wide_int_const (result, imode);
    6575                 :            :     }
    6576                 :            : 
    6577                 :      66449 :   scalar_float_mode fmode;
    6578                 :      66449 :   if (is_a <scalar_float_mode> (mode, &fmode))
    6579                 :            :     {
    6580                 :            :       /* We need to build an array of integers in target memory order.
    6581                 :            :          All integers before the last one have 32 bits; the last one may
    6582                 :            :          have 32 bits or fewer, depending on whether the mode bitsize
    6583                 :            :          is divisible by 32.  */
    6584                 :      66410 :       long el32[MAX_BITSIZE_MODE_ANY_MODE / 32];
    6585                 :      66410 :       unsigned int num_el32 = CEIL (GET_MODE_BITSIZE (fmode), 32);
    6586                 :      66410 :       memset (el32, 0, num_el32 * sizeof (long));
    6587                 :            : 
    6588                 :            :       /* The (maximum) number of target bytes per element of el32.  */
    6589                 :      66410 :       unsigned int bytes_per_el32 = 32 / BITS_PER_UNIT;
    6590                 :      66410 :       gcc_assert (bytes_per_el32 != 0);
    6591                 :            : 
    6592                 :      66410 :       unsigned int mode_bytes = GET_MODE_SIZE (fmode);
    6593                 :     524138 :       for (unsigned int byte = 0; byte < mode_bytes; ++byte)
    6594                 :            :         {
    6595                 :     457728 :           unsigned int index = byte / bytes_per_el32;
    6596                 :     457728 :           unsigned int subbyte = byte % bytes_per_el32;
    6597                 :     457728 :           unsigned int int_bytes = MIN (bytes_per_el32,
    6598                 :            :                                         mode_bytes - index * bytes_per_el32);
    6599                 :            :           /* Always constant because the inputs are.  */
    6600                 :     457728 :           unsigned int lsb
    6601                 :     457728 :             = subreg_size_lsb (1, int_bytes, subbyte).to_constant ();
    6602                 :     457728 :           el32[index] |= (unsigned long) bytes[first_byte + byte] << lsb;
    6603                 :            :         }
    6604                 :      66410 :       REAL_VALUE_TYPE r;
    6605                 :      66410 :       real_from_target (&r, el32, fmode);
    6606                 :      66410 :       return const_double_from_real_value (r, fmode);
    6607                 :            :     }
    6608                 :            : 
    6609                 :         39 :   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
    6610                 :            :     {
    6611                 :          0 :       scalar_mode smode = as_a <scalar_mode> (mode);
    6612                 :          0 :       FIXED_VALUE_TYPE f;
    6613                 :          0 :       f.data.low = 0;
    6614                 :          0 :       f.data.high = 0;
    6615                 :          0 :       f.mode = smode;
    6616                 :            : 
    6617                 :          0 :       unsigned int mode_bytes = GET_MODE_SIZE (smode);
    6618                 :          0 :       for (unsigned int byte = 0; byte < mode_bytes; ++byte)
    6619                 :            :         {
    6620                 :            :           /* Always constant because the inputs are.  */
    6621                 :          0 :           unsigned int lsb
    6622                 :          0 :             = subreg_size_lsb (1, mode_bytes, byte).to_constant ();
    6623                 :          0 :           unsigned HOST_WIDE_INT unit = bytes[first_byte + byte];
    6624                 :          0 :           if (lsb >= HOST_BITS_PER_WIDE_INT)
    6625                 :          0 :             f.data.high |= unit << (lsb - HOST_BITS_PER_WIDE_INT);
    6626                 :            :           else
    6627                 :          0 :             f.data.low |= unit << lsb;
    6628                 :            :         }
    6629                 :          0 :       return CONST_FIXED_FROM_FIXED_VALUE (f, mode);
    6630                 :            :     }
    6631                 :            : 
    6632                 :            :   return NULL_RTX;
    6633                 :            : }
    6634                 :            : 
    6635                 :            : /* Simplify a byte offset BYTE into CONST_VECTOR X.  The main purpose
    6636                 :            :    is to convert a runtime BYTE value into a constant one.  */
    6637                 :            : 
    6638                 :            : static poly_uint64
    6639                 :      33317 : simplify_const_vector_byte_offset (rtx x, poly_uint64 byte)
    6640                 :            : {
    6641                 :            :   /* Cope with MODE_VECTOR_BOOL by operating on bits rather than bytes.  */
    6642                 :      33317 :   machine_mode mode = GET_MODE (x);
    6643                 :      99951 :   unsigned int elt_bits = vector_element_size (GET_MODE_BITSIZE (mode),
    6644                 :            :                                                GET_MODE_NUNITS (mode));
    6645                 :            :   /* The number of bits needed to encode one element from each pattern.  */
    6646                 :      33317 :   unsigned int sequence_bits = CONST_VECTOR_NPATTERNS (x) * elt_bits;
    6647                 :            : 
    6648                 :            :   /* Identify the start point in terms of a sequence number and a byte offset
    6649                 :            :      within that sequence.  */
    6650                 :      33317 :   poly_uint64 first_sequence;
    6651                 :      33317 :   unsigned HOST_WIDE_INT subbit;
    6652                 :      33317 :   if (can_div_trunc_p (byte * BITS_PER_UNIT, sequence_bits,
    6653                 :            :                        &first_sequence, &subbit))
    6654                 :            :     {
    6655                 :      33317 :       unsigned int nelts_per_pattern = CONST_VECTOR_NELTS_PER_PATTERN (x);
    6656                 :      33317 :       if (nelts_per_pattern == 1)
    6657                 :            :         /* This is a duplicated vector, so the value of FIRST_SEQUENCE
    6658                 :            :            doesn't matter.  */
    6659                 :      10007 :         byte = subbit / BITS_PER_UNIT;
    6660                 :      23310 :       else if (nelts_per_pattern == 2 && known_gt (first_sequence, 0U))
    6661                 :            :         {
    6662                 :            :           /* The subreg drops the first element from each pattern and
    6663                 :            :              only uses the second element.  Find the first sequence
    6664                 :            :              that starts on a byte boundary.  */
    6665                 :       3336 :           subbit += least_common_multiple (sequence_bits, BITS_PER_UNIT);
    6666                 :       3336 :           byte = subbit / BITS_PER_UNIT;
    6667                 :            :         }
    6668                 :            :     }
    6669                 :      33317 :   return byte;
    6670                 :            : }
    6671                 :            : 
    6672                 :            : /* Subroutine of simplify_subreg in which:
    6673                 :            : 
    6674                 :            :    - X is known to be a CONST_VECTOR
    6675                 :            :    - OUTERMODE is known to be a vector mode
    6676                 :            : 
    6677                 :            :    Try to handle the subreg by operating on the CONST_VECTOR encoding
    6678                 :            :    rather than on each individual element of the CONST_VECTOR.
    6679                 :            : 
    6680                 :            :    Return the simplified subreg on success, otherwise return NULL_RTX.  */
    6681                 :            : 
    6682                 :            : static rtx
    6683                 :      18657 : simplify_const_vector_subreg (machine_mode outermode, rtx x,
    6684                 :            :                               machine_mode innermode, unsigned int first_byte)
    6685                 :            : {
    6686                 :            :   /* Paradoxical subregs of vectors have dubious semantics.  */
    6687                 :      18657 :   if (paradoxical_subreg_p (outermode, innermode))
    6688                 :            :     return NULL_RTX;
    6689                 :            : 
    6690                 :            :   /* We can only preserve the semantics of a stepped pattern if the new
    6691                 :            :      vector element is the same as the original one.  */
    6692                 :      18657 :   if (CONST_VECTOR_STEPPED_P (x)
    6693                 :      31241 :       && GET_MODE_INNER (outermode) != GET_MODE_INNER (innermode))
    6694                 :            :     return NULL_RTX;
    6695                 :            : 
    6696                 :            :   /* Cope with MODE_VECTOR_BOOL by operating on bits rather than bytes.  */
    6697                 :      13923 :   unsigned int x_elt_bits
    6698                 :      27846 :     = vector_element_size (GET_MODE_BITSIZE (innermode),
    6699                 :            :                            GET_MODE_NUNITS (innermode));
    6700                 :      13923 :   unsigned int out_elt_bits
    6701                 :      27846 :     = vector_element_size (GET_MODE_BITSIZE (outermode),
    6702                 :            :                            GET_MODE_NUNITS (outermode));
    6703                 :            : 
    6704                 :            :   /* The number of bits needed to encode one element from every pattern
    6705                 :            :      of the original vector.  */
    6706                 :      13923 :   unsigned int x_sequence_bits = CONST_VECTOR_NPATTERNS (x) * x_elt_bits;
    6707                 :            : 
    6708                 :            :   /* The number of bits needed to encode one element from every pattern
    6709                 :            :      of the result.  */
    6710                 :      13923 :   unsigned int out_sequence_bits
    6711                 :      13923 :     = least_common_multiple (x_sequence_bits, out_elt_bits);
    6712                 :            : 
    6713                 :            :   /* Work out the number of interleaved patterns in the output vector
    6714                 :            :      and the number of encoded elements per pattern.  */
    6715                 :      13923 :   unsigned int out_npatterns = out_sequence_bits / out_elt_bits;
    6716                 :      13923 :   unsigned int nelts_per_pattern = CONST_VECTOR_NELTS_PER_PATTERN (x);
    6717                 :            : 
    6718                 :            :   /* The encoding scheme requires the number of elements to be a multiple
    6719                 :            :      of the number of patterns, so that each pattern appears at least once
    6720                 :            :      and so that the same number of elements appear from each pattern.  */
    6721                 :      27846 :   bool ok_p = multiple_p (GET_MODE_NUNITS (outermode), out_npatterns);
    6722                 :      13923 :   unsigned int const_nunits;
    6723                 :      27846 :   if (GET_MODE_NUNITS (outermode).is_constant (&const_nunits)
    6724                 :      13923 :       && (!ok_p || out_npatterns * nelts_per_pattern > const_nunits))
    6725                 :            :     {
    6726                 :            :       /* Either the encoding is invalid, or applying it would give us
    6727                 :            :          more elements than we need.  Just encode each element directly.  */
    6728                 :            :       out_npatterns = const_nunits;
    6729                 :            :       nelts_per_pattern = 1;
    6730                 :            :     }
    6731                 :            :   else if (!ok_p)
    6732                 :            :     return NULL_RTX;
    6733                 :            : 
    6734                 :            :   /* Get enough bytes of X to form the new encoding.  */
    6735                 :      13923 :   unsigned int buffer_bits = out_npatterns * nelts_per_pattern * out_elt_bits;
    6736                 :      13923 :   unsigned int buffer_bytes = CEIL (buffer_bits, BITS_PER_UNIT);
    6737                 :      27846 :   auto_vec<target_unit, 128> buffer (buffer_bytes);
    6738                 :      13923 :   if (!native_encode_rtx (innermode, x, buffer, first_byte, buffer_bytes))
    6739                 :            :     return NULL_RTX;
    6740                 :            : 
    6741                 :            :   /* Reencode the bytes as OUTERMODE.  */
    6742                 :      13923 :   return native_decode_vector_rtx (outermode, buffer, 0, out_npatterns,
    6743                 :      13923 :                                    nelts_per_pattern);
    6744                 :            : }
    6745                 :            : 
    6746                 :            : /* Try to simplify a subreg of a constant by encoding the subreg region
    6747                 :            :    as a sequence of target bytes and reading them back in the new mode.
    6748                 :            :    Return the new value on success, otherwise return null.
    6749                 :            : 
    6750                 :            :    The subreg has outer mode OUTERMODE, inner mode INNERMODE, inner value X
    6751                 :            :    and byte offset FIRST_BYTE.  */
    6752                 :            : 
    6753                 :            : static rtx
    6754                 :    6338860 : simplify_immed_subreg (fixed_size_mode outermode, rtx x,
    6755                 :            :                        machine_mode innermode, unsigned int first_byte)
    6756                 :            : {
    6757                 :    6338860 :   unsigned int buffer_bytes = GET_MODE_SIZE (outermode);
    6758                 :    6338860 :   auto_vec<target_unit, 128> buffer (buffer_bytes);
    6759                 :            : 
    6760                 :            :   /* Some ports misuse CCmode.  */
    6761                 :    6338860 :   if (GET_MODE_CLASS (outermode) == MODE_CC && CONST_INT_P (x))
    6762                 :            :     return x;
    6763                 :            : 
    6764                 :            :   /* Paradoxical subregs read undefined values for bytes outside of the
    6765                 :            :      inner value.  However, we have traditionally always sign-extended
    6766                 :            :      integer constants and zero-extended others.  */
    6767                 :    6338330 :   unsigned int inner_bytes = buffer_bytes;
    6768                 :    6338330 :   if (paradoxical_subreg_p (outermode, innermode))
    6769                 :            :     {
    6770                 :     138358 :       if (!GET_MODE_SIZE (innermode).is_constant (&inner_bytes))
    6771                 :    6338860 :         return NULL_RTX;
    6772                 :            : 
    6773                 :      69179 :       target_unit filler = 0;
    6774                 :     138356 :       if (CONST_SCALAR_INT_P (x) && wi::neg_p (rtx_mode_t (x, innermode)))
    6775                 :            :         filler = -1;
    6776                 :            : 
    6777                 :            :       /* Add any leading bytes due to big-endian layout.  The number of
    6778                 :            :          bytes must be constant because both modes have constant size.  */
    6779                 :      69179 :       unsigned int leading_bytes
    6780                 :      69179 :         = -byte_lowpart_offset (outermode, innermode).to_constant ();
    6781                 :      69179 :       for (unsigned int i = 0; i < leading_bytes; ++i)
    6782                 :          0 :         buffer.quick_push (filler);
    6783                 :            : 
    6784                 :      69179 :       if (!native_encode_rtx (innermode, x, buffer, first_byte, inner_bytes))
    6785                 :            :         return NULL_RTX;
    6786                 :            : 
    6787                 :            :       /* Add any trailing bytes due to little-endian layout.  */
    6788                 :     293876 :       while (buffer.length () < buffer_bytes)
    6789                 :     518573 :         buffer.quick_push (filler);
    6790                 :            :     }
    6791                 :            :   else
    6792                 :            :     {
    6793                 :    6269150 :       if (!native_encode_rtx (innermode, x, buffer, first_byte, inner_bytes))
    6794                 :            :         return NULL_RTX;
    6795                 :            :       }
    6796                 :    6338330 :   return native_decode_rtx (outermode, buffer, 0);
    6797                 :            : }
    6798                 :            : 
    6799                 :            : /* Simplify SUBREG:OUTERMODE(OP:INNERMODE, BYTE)
    6800                 :            :    Return 0 if no simplifications are possible.  */
    6801                 :            : rtx
    6802                 :   38088800 : simplify_subreg (machine_mode outermode, rtx op,
    6803                 :            :                  machine_mode innermode, poly_uint64 byte)
    6804                 :            : {
    6805                 :            :   /* Little bit of sanity checking.  */
    6806                 :   38088800 :   gcc_assert (innermode != VOIDmode);
    6807                 :   38088800 :   gcc_assert (outermode != VOIDmode);
    6808                 :   38088800 :   gcc_assert (innermode != BLKmode);
    6809                 :   38088800 :   gcc_assert (outermode != BLKmode);
    6810                 :            : 
    6811                 :   38088800 :   gcc_assert (GET_MODE (op) == innermode
    6812                 :            :               || GET_MODE (op) == VOIDmode);
    6813                 :            : 
    6814                 :   76177700 :   poly_uint64 outersize = GET_MODE_SIZE (outermode);
    6815                 :   38088800 :   if (!multiple_p (byte, outersize))
    6816                 :            :     return NULL_RTX;
    6817                 :            : 
    6818                 :   76177700 :   poly_uint64 innersize = GET_MODE_SIZE (innermode);
    6819                 :   38088800 :   if (maybe_ge (byte, innersize))
    6820                 :            :     return NULL_RTX;
    6821                 :            : 
    6822                 :   38088800 :   if (outermode == innermode && known_eq (byte, 0U))
    6823                 :            :     return op;
    6824                 :            : 
    6825                 :   35337000 :   if (GET_CODE (op) == CONST_VECTOR)
    6826                 :      33317 :     byte = simplify_const_vector_byte_offset (op, byte);
    6827                 :            : 
    6828                 :   70674100 :   if (multiple_p (byte, GET_MODE_UNIT_SIZE (innermode)))
    6829                 :            :     {
    6830                 :   31404500 :       rtx elt;
    6831                 :            : 
    6832                 :   28753700 :       if (VECTOR_MODE_P (outermode)
    6833                 :    5788500 :           && GET_MODE_INNER (outermode) == GET_MODE_INNER (innermode)
    6834                 :   31742000 :           && vec_duplicate_p (op, &elt))
    6835                 :       2288 :         return gen_vec_duplicate (outermode, elt);
    6836                 :            : 
    6837                 :   62807800 :       if (outermode == GET_MODE_INNER (innermode)
    6838                 :   31403900 :           && vec_duplicate_p (op, &elt))
    6839                 :       1638 :         return elt;
    6840                 :            :     }
    6841                 :            : 
    6842                 :   35334700 :   if (CONST_SCALAR_INT_P (op)
    6843                 :   29040100 :       || CONST_DOUBLE_AS_FLOAT_P (op)
    6844                 :   29014600 :       || CONST_FIXED_P (op)
    6845                 :   29014600 :       || GET_CODE (op) == CONST_VECTOR)
    6846                 :            :     {
    6847                 :    6352780 :       unsigned HOST_WIDE_INT cbyte;
    6848                 :    6352780 :       if (byte.is_constant (&cbyte))
    6849                 :            :         {
    6850                 :    6352780 :           if (GET_CODE (op) == CONST_VECTOR && VECTOR_MODE_P (outermode))
    6851                 :            :             {
    6852                 :      18657 :               rtx tmp = simplify_const_vector_subreg (outermode, op,
    6853                 :            :                                                       innermode, cbyte);
    6854                 :      18657 :               if (tmp)
    6855                 :    6352780 :                 return tmp;
    6856                 :            :             }
    6857                 :            : 
    6858                 :    6338860 :           fixed_size_mode fs_outermode;
    6859                 :    6338860 :           if (is_a <fixed_size_mode> (outermode, &fs_outermode))
    6860                 :    6338860 :             return simplify_immed_subreg (fs_outermode, op, innermode, cbyte);
    6861                 :            :         }
    6862                 :            :     }
    6863                 :            : 
    6864                 :            :   /* Changing mode twice with SUBREG => just change it once,
    6865                 :            :      or not at all if changing back op starting mode.  */
    6866                 :   28982000 :   if (GET_CODE (op) == SUBREG)
    6867                 :            :     {
    6868                 :     797004 :       machine_mode innermostmode = GET_MODE (SUBREG_REG (op));
    6869                 :    1594010 :       poly_uint64 innermostsize = GET_MODE_SIZE (innermostmode);
    6870                 :     797004 :       rtx newx;
    6871                 :            : 
    6872                 :     797004 :       if (outermode == innermostmode
    6873                 :     415221 :           && known_eq (byte, 0U)
    6874                 :    1187140 :           && known_eq (SUBREG_BYTE (op), 0))
    6875                 :     390137 :         return SUBREG_REG (op);
    6876                 :            : 
    6877                 :            :       /* Work out the memory offset of the final OUTERMODE value relative
    6878                 :            :          to the inner value of OP.  */
    6879                 :     406867 :       poly_int64 mem_offset = subreg_memory_offset (outermode,
    6880                 :     406867 :                                                     innermode, byte);
    6881                 :     406867 :       poly_int64 op_mem_offset = subreg_memory_offset (op);
    6882                 :     406867 :       poly_int64 final_offset = mem_offset + op_mem_offset;
    6883                 :            : 
    6884                 :            :       /* See whether resulting subreg will be paradoxical.  */
    6885                 :     406867 :       if (!paradoxical_subreg_p (outermode, innermostmode))
    6886                 :            :         {
    6887                 :            :           /* Bail out in case resulting subreg would be incorrect.  */
    6888                 :     338783 :           if (maybe_lt (final_offset, 0)
    6889                 :     652482 :               || maybe_ge (poly_uint64 (final_offset), innermostsize)
    6890                 :     652482 :               || !multiple_p (final_offset, outersize))
    6891                 :      25084 :             return NULL_RTX;
    6892                 :            :         }
    6893                 :            :       else
    6894                 :            :         {
    6895                 :      68084 :           poly_int64 required_offset = subreg_memory_offset (outermode,
    6896                 :      68084 :                                                              innermostmode, 0);
    6897                 :      68084 :           if (maybe_ne (final_offset, required_offset))
    6898                 :       1604 :             return NULL_RTX;
    6899                 :            :           /* Paradoxical subregs always have byte offset 0.  */
    6900                 :      66480 :           final_offset = 0;
    6901                 :            :         }
    6902                 :            : 
    6903                 :            :       /* Recurse for further possible simplifications.  */
    6904                 :     380179 :       newx = simplify_subreg (outermode, SUBREG_REG (op), innermostmode,
    6905                 :            :                               final_offset);
    6906                 :     380179 :       if (newx)
    6907                 :            :         return newx;
    6908                 :     760180 :       if (validate_subreg (outermode, innermostmode,
    6909                 :     380090 :                            SUBREG_REG (op), final_offset))
    6910                 :            :         {
    6911                 :     365941 :           newx = gen_rtx_SUBREG (outermode, SUBREG_REG (op), final_offset);
    6912                 :     365941 :           if (SUBREG_PROMOTED_VAR_P (op)
    6913                 :          0 :               && SUBREG_PROMOTED_SIGN (op) >= 0
    6914                 :          0 :               && GET_MODE_CLASS (outermode) == MODE_INT
    6915                 :          0 :               && known_ge (outersize, innersize)
    6916                 :          0 :               && known_le (outersize, innermostsize)
    6917                 :     365941 :               && subreg_lowpart_p (newx))
    6918                 :            :             {
    6919                 :          0 :               SUBREG_PROMOTED_VAR_P (newx) = 1;
    6920                 :          0 :               SUBREG_PROMOTED_SET (newx, SUBREG_PROMOTED_GET (op));
    6921                 :            :             }
    6922                 :     365941 :           return newx;
    6923                 :            :         }
    6924                 :            :       return NULL_RTX;
    6925                 :            :     }
    6926                 :            : 
    6927                 :            :   /* SUBREG of a hard register => just change the register number
    6928                 :            :      and/or mode.  If the hard register is not valid in that mode,
    6929                 :            :      suppress this simplification.  If the hard register is the stack,
    6930                 :            :      frame, or argument pointer, leave this as a SUBREG.  */
    6931                 :            : 
    6932                 :   28185000 :   if (REG_P (op) && HARD_REGISTER_P (op))
    6933                 :            :     {
    6934                 :    4954620 :       unsigned int regno, final_regno;
    6935                 :            : 
    6936                 :    4954620 :       regno = REGNO (op);
    6937                 :    4954620 :       final_regno = simplify_subreg_regno (regno, innermode, byte, outermode);
    6938                 :    4954620 :       if (HARD_REGISTER_NUM_P (final_regno))
    6939                 :            :         {
    6940                 :    4941830 :           rtx x = gen_rtx_REG_offset (op, outermode, final_regno,
    6941                 :            :                                       subreg_memory_offset (outermode,
    6942                 :            :                                                             innermode, byte));
    6943                 :            : 
    6944                 :            :           /* Propagate original regno.  We don't have any way to specify
    6945                 :            :              the offset inside original regno, so do so only for lowpart.
    6946                 :            :              The information is used only by alias analysis that cannot
    6947                 :            :              grog partial register anyway.  */
    6948                 :            : 
    6949                 :    4941830 :           if (known_eq (subreg_lowpart_offset (outermode, innermode), byte))
    6950                 :    3845540 :             ORIGINAL_REGNO (x) = ORIGINAL_REGNO (op);
    6951                 :    4941830 :           return x;
    6952                 :            :         }
    6953                 :            :     }
    6954                 :            : 
    6955                 :            :   /* If we have a SUBREG of a register that we are replacing and we are
    6956                 :            :      replacing it with a MEM, make a new MEM and try replacing the
    6957                 :            :      SUBREG with it.  Don't do this if the MEM has a mode-dependent address
    6958                 :            :      or if we would be widening it.  */
    6959                 :            : 
    6960                 :   23243100 :   if (MEM_P (op)
    6961                 :    1000600 :       && ! mode_dependent_address_p (XEXP (op, 0), MEM_ADDR_SPACE (op))
    6962                 :            :       /* Allow splitting of volatile memory references in case we don't
    6963                 :            :          have instruction to move the whole thing.  */
    6964                 :    1000590 :       && (! MEM_VOLATILE_P (op)
    6965                 :      53577 :           || ! have_insn_for (SET, innermode))
    6966                 :   24190100 :       && known_le (outersize, innersize))
    6967                 :     452828 :     return adjust_address_nv (op, outermode, byte);
    6968                 :            : 
    6969                 :            :   /* Handle complex or vector values represented as CONCAT or VEC_CONCAT
    6970                 :            :      of two parts.  */
    6971                 :   22790300 :   if (GET_CODE (op) == CONCAT
    6972                 :   22787100 :       || GET_CODE (op) == VEC_CONCAT)
    6973                 :            :     {
    6974                 :     141652 :       poly_uint64 final_offset;
    6975                 :     141652 :       rtx part, res;
    6976                 :            : 
    6977                 :     141652 :       machine_mode part_mode = GET_MODE (XEXP (op, 0));
    6978                 :     141652 :       if (part_mode == VOIDmode)
    6979                 :          0 :         part_mode = GET_MODE_INNER (GET_MODE (op));
    6980                 :     283304 :       poly_uint64 part_size = GET_MODE_SIZE (part_mode);
    6981                 :     141652 :       if (known_lt (byte, part_size))
    6982                 :            :         {
    6983                 :     140156 :           part = XEXP (op, 0);
    6984                 :     140156 :           final_offset = byte;
    6985                 :            :         }
    6986                 :       1496 :       else if (known_ge (byte, part_size))
    6987                 :            :         {
    6988                 :       1496 :           part = XEXP (op, 1);
    6989                 :       1496 :           final_offset = byte - part_size;
    6990                 :            :         }
    6991                 :            :       else
    6992                 :            :         return NULL_RTX;
    6993                 :            : 
    6994                 :     141652 :       if (maybe_gt (final_offset + outersize, part_size))
    6995                 :            :         return NULL_RTX;
    6996                 :            : 
    6997                 :       4039 :       part_mode = GET_MODE (part);
    6998                 :       4039 :       if (part_mode == VOIDmode)
    6999                 :          0 :         part_mode = GET_MODE_INNER (GET_MODE (op));
    7000                 :       4039 :       res = simplify_subreg (outermode, part, part_mode, final_offset);
    7001                 :       4039 :       if (res)
    7002                 :            :         return res;
    7003                 :        540 :       if (validate_subreg (outermode, part_mode, part, final_offset))
    7004                 :        540 :         return gen_rtx_SUBREG (outermode, part, final_offset);
    7005                 :            :       return NULL_RTX;
    7006                 :            :     }
    7007                 :            : 
    7008                 :            :   /* Simplify
    7009                 :            :         (subreg (vec_merge (X)
    7010                 :            :                            (vector)
    7011                 :            :                            (const_int ((1 << N) | M)))
    7012                 :            :                 (N * sizeof (outermode)))
    7013                 :            :      to
    7014                 :            :         (subreg (X) (N * sizeof (outermode)))
    7015                 :            :    */
    7016                 :   22648700 :   unsigned int idx;
    7017                 :   45297300 :   if (constant_multiple_p (byte, GET_MODE_SIZE (outermode), &idx)
    7018                 :   22648700 :       && idx < HOST_BITS_PER_WIDE_INT
    7019                 :   22648700 :       && GET_CODE (op) == VEC_MERGE
    7020                 :     131819 :       && GET_MODE_INNER (innermode) == outermode
    7021                 :       1710 :       && CONST_INT_P (XEXP (op, 2))
    7022                 :   22650100 :       && (UINTVAL (XEXP (op, 2)) & (HOST_WIDE_INT_1U << idx)) != 0)
    7023                 :       1478 :     return simplify_gen_subreg (outermode, XEXP (op, 0), innermode, byte);
    7024                 :            : 
    7025                 :            :   /* A SUBREG resulting from a zero extension may fold to zero if
    7026                 :            :      it extracts higher bits that the ZERO_EXTEND's source bits.  */
    7027                 :   22647200 :   if (GET_CODE (op) == ZERO_EXTEND && SCALAR_INT_MODE_P (innermode))
    7028                 :            :     {
    7029                 :      83073 :       poly_uint64 bitpos = subreg_lsb_1 (outermode, innermode, byte);
    7030                 :      83073 :       if (known_ge (bitpos, GET_MODE_PRECISION (GET_MODE (XEXP (op, 0)))))
    7031                 :       7477 :         return CONST0_RTX (outermode);
    7032                 :            :     }
    7033                 :            : 
    7034                 :   22639700 :   scalar_int_mode int_outermode, int_innermode;
    7035                 :   22639700 :   if (is_a <scalar_int_mode> (outermode, &int_outermode)
    7036                 :   20445200 :       && is_a <scalar_int_mode> (innermode, &int_innermode)
    7037                 :   43084800 :       && known_eq (byte, subreg_lowpart_offset (int_outermode, int_innermode)))
    7038                 :            :     {
    7039                 :            :       /* Handle polynomial integers.  The upper bits of a paradoxical
    7040                 :            :          subreg are undefined, so this is safe regardless of whether
    7041                 :            :          we're truncating or extending.  */
    7042                 :   17842900 :       if (CONST_POLY_INT_P (op))
    7043                 :            :         {
    7044                 :            :           poly_wide_int val
    7045                 :            :             = poly_wide_int::from (const_poly_int_value (op),
    7046                 :            :                                    GET_MODE_PRECISION (int_outermode),
    7047                 :            :                                    SIGNED);
    7048                 :            :           return immed_wide_int_const (val, int_outermode);
    7049                 :            :         }
    7050                 :            : 
    7051                 :   17842900 :       if (GET_MODE_PRECISION (int_outermode)
    7052                 :   17842900 :           < GET_MODE_PRECISION (int_innermode))
    7053                 :            :         {
    7054                 :   11068800 :           rtx tem = simplify_truncation (int_outermode, op, int_innermode);
    7055                 :   11068800 :           if (tem)
    7056                 :            :             return tem;
    7057                 :            :         }
    7058                 :            :     }
    7059                 :            : 
    7060                 :            :   /* If OP is a vector comparison and the subreg is not changing the
    7061                 :            :      number of elements or the size of the elements, change the result
    7062                 :            :      of the comparison to the new mode.  */
    7063                 :   22140600 :   if (COMPARISON_P (op)
    7064                 :     146220 :       && VECTOR_MODE_P (outermode)
    7065                 :     112291 :       && VECTOR_MODE_P (innermode)
    7066                 :     224568 :       && known_eq (GET_MODE_NUNITS (outermode), GET_MODE_NUNITS (innermode))
    7067                 :   22200000 :       && known_eq (GET_MODE_UNIT_SIZE (outermode),
    7068                 :            :                     GET_MODE_UNIT_SIZE (innermode)))
    7069                 :      29714 :     return simplify_gen_relational (GET_CODE (op), outermode, innermode,
    7070                 :      29714 :                                     XEXP (op, 0), XEXP (op, 1));
    7071                 :            :   return NULL_RTX;
    7072                 :            : }
    7073                 :            : 
    7074                 :            : /* Make a SUBREG operation or equivalent if it folds.  */
    7075                 :            : 
    7076                 :            : rtx
    7077                 :   24557700 : simplify_gen_subreg (machine_mode outermode, rtx op,
    7078                 :            :                      machine_mode innermode, poly_uint64 byte)
    7079                 :            : {
    7080                 :   24557700 :   rtx newx;
    7081                 :            : 
    7082                 :   24557700 :   newx = simplify_subreg (outermode, op, innermode, byte);
    7083                 :   24557700 :   if (newx)
    7084                 :            :     return newx;
    7085                 :            : 
    7086                 :   11271400 :   if (GET_CODE (op) == SUBREG
    7087                 :   11271400 :       || GET_CODE (op) == CONCAT
    7088                 :   11233400 :       || GET_MODE (op) == VOIDmode)
    7089                 :            :     return NULL_RTX;
    7090                 :            : 
    7091                 :   11233400 :   if (validate_subreg (outermode, innermode, op, byte))
    7092                 :   11229100 :     return gen_rtx_SUBREG (outermode, op, byte);
    7093                 :            : 
    7094                 :            :   return NULL_RTX;
    7095                 :            : }
    7096                 :            : 
    7097                 :            : /* Generates a subreg to get the least significant part of EXPR (in mode
    7098                 :            :    INNER_MODE) to OUTER_MODE.  */
    7099                 :            : 
    7100                 :            : rtx
    7101                 :   16373400 : lowpart_subreg (machine_mode outer_mode, rtx expr,
    7102                 :            :                              machine_mode inner_mode)
    7103                 :            : {
    7104                 :   16373400 :   return simplify_gen_subreg (outer_mode, expr, inner_mode,
    7105                 :   16373400 :                               subreg_lowpart_offset (outer_mode, inner_mode));
    7106                 :            : }
    7107                 :            : 
    7108                 :            : /* Simplify X, an rtx expression.
    7109                 :            : 
    7110                 :            :    Return the simplified expression or NULL if no simplifications
    7111                 :            :    were possible.
    7112                 :            : 
    7113                 :            :    This is the preferred entry point into the simplification routines;
    7114                 :            :    however, we still allow passes to call the more specific routines.
    7115                 :            : 
    7116                 :            :    Right now GCC has three (yes, three) major bodies of RTL simplification
    7117                 :            :    code that need to be unified.
    7118                 :            : 
    7119                 :            :         1. fold_rtx in cse.c.  This code uses various CSE specific
    7120                 :            :            information to aid in RTL simplification.
    7121                 :            : 
    7122                 :            :         2. simplify_rtx in combine.c.  Similar to fold_rtx, except that
    7123                 :            :            it uses combine specific information to aid in RTL
    7124                 :            :            simplification.
    7125                 :            : 
    7126                 :            :         3. The routines in this file.
    7127                 :            : 
    7128                 :            : 
    7129                 :            :    Long term we want to only have one body of simplification code; to
    7130                 :            :    get to that state I recommend the following steps:
    7131                 :            : 
    7132                 :            :         1. Pour over fold_rtx & simplify_rtx and move any simplifications
    7133                 :            :            which are not pass dependent state into these routines.
    7134                 :            : 
    7135                 :            :         2. As code is moved by #1, change fold_rtx & simplify_rtx to
    7136                 :            :            use this routine whenever possible.
    7137                 :            : 
    7138                 :            :         3. Allow for pass dependent state to be provided to these
    7139                 :            :            routines and add simplifications based on the pass dependent
    7140                 :            :            state.  Remove code from cse.c & combine.c that becomes
    7141                 :            :            redundant/dead.
    7142                 :            : 
    7143                 :            :     It will take time, but ultimately the compiler will be easier to
    7144                 :            :     maintain and improve.  It's totally silly that when we add a
    7145                 :            :     simplification that it needs to be added to 4 places (3 for RTL
    7146                 :            :     simplification and 1 for tree simplification.  */
    7147                 :            : 
    7148                 :            : rtx
    7149                 :   39956600 : simplify_rtx (const_rtx x)
    7150                 :            : {
    7151                 :   39956600 :   const enum rtx_code code = GET_CODE (x);
    7152                 :   39956600 :   const machine_mode mode = GET_MODE (x);
    7153                 :            : 
    7154                 :   39956600 :   switch (GET_RTX_CLASS (code))
    7155                 :            :     {
    7156                 :     409662 :     case RTX_UNARY:
    7157                 :     409662 :       return simplify_unary_operation (code, mode,
    7158                 :     409662 :                                        XEXP (x, 0), GET_MODE (XEXP (x, 0)));
    7159                 :   17694400 :     case RTX_COMM_ARITH:
    7160                 :   17694400 :       if (swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
    7161                 :     251922 :         return simplify_gen_binary (code, mode, XEXP (x, 1), XEXP (x, 0));
    7162                 :            : 
    7163                 :            :       /* Fall through.  */
    7164                 :            : 
    7165                 :   28939600 :     case RTX_BIN_ARITH:
    7166                 :   28939600 :       return simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
    7167                 :            : 
    7168                 :      39742 :     case RTX_TERNARY:
    7169                 :      39742 :     case RTX_BITFIELD_OPS:
    7170                 :      39742 :       return simplify_ternary_operation (code, mode, GET_MODE (XEXP (x, 0)),
    7171                 :      39742 :                                          XEXP (x, 0), XEXP (x, 1),
    7172                 :      39742 :                                          XEXP (x, 2));
    7173                 :            : 
    7174                 :     106510 :     case RTX_COMPARE:
    7175                 :     106510 :     case RTX_COMM_COMPARE:
    7176                 :     106510 :       return simplify_relational_operation (code, mode,
    7177                 :     106510 :                                             ((GET_MODE (XEXP (x, 0))
    7178                 :            :                                              != VOIDmode)
    7179                 :            :                                             ? GET_MODE (XEXP (x, 0))
    7180                 :         81 :                                             : GET_MODE (XEXP (x, 1))),
    7181                 :     106510 :                                             XEXP (x, 0),
    7182                 :     213020 :                                             XEXP (x, 1));
    7183                 :            : 
    7184                 :     156820 :     case RTX_EXTRA:
    7185                 :     156820 :       if (code == SUBREG)
    7186                 :       1526 :         return simplify_subreg (mode, SUBREG_REG (x),
    7187                 :       1526 :                                 GET_MODE (SUBREG_REG (x)),
    7188                 :       1526 :                                 SUBREG_BYTE (x));
    7189                 :            :       break;
    7190                 :            : 
    7191                 :    4576510 :     case RTX_OBJ:
    7192                 :    4576510 :       if (code == LO_SUM)
    7193                 :            :         {
    7194                 :            :           /* Convert (lo_sum (high FOO) FOO) to FOO.  */
    7195                 :          0 :           if (GET_CODE (XEXP (x, 0)) == HIGH
    7196                 :          0 :               && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
    7197                 :          0 :           return XEXP (x, 1);
    7198                 :            :         }
    7199                 :            :       break;
    7200                 :            : 
    7201                 :            :     default:
    7202                 :            :       break;
    7203                 :            :     }
    7204                 :            :   return NULL;
    7205                 :            : }
    7206                 :            : 
    7207                 :            : #if CHECKING_P
    7208                 :            : 
    7209                 :            : namespace selftest {
    7210                 :            : 
    7211                 :            : /* Make a unique pseudo REG of mode MODE for use by selftests.  */
    7212                 :            : 
    7213                 :            : static rtx
    7214                 :        940 : make_test_reg (machine_mode mode)
    7215                 :            : {
    7216                 :        940 :   static int test_reg_num = LAST_VIRTUAL_REGISTER + 1;
    7217                 :            : 
    7218                 :         94 :   return gen_rtx_REG (mode, test_reg_num++);
    7219                 :            : }
    7220                 :            : 
    7221                 :            : /* Test vector simplifications involving VEC_DUPLICATE in which the
    7222                 :            :    operands and result have vector mode MODE.  SCALAR_REG is a pseudo
    7223                 :            :    register that holds one element of MODE.  */
    7224                 :            : 
    7225                 :            : static void
    7226                 :         94 : test_vector_ops_duplicate (machine_mode mode, rtx scalar_reg)
    7227                 :            : {
    7228                 :         94 :   scalar_mode inner_mode = GET_MODE_INNER (mode);
    7229                 :         94 :   rtx duplicate = gen_rtx_VEC_DUPLICATE (mode, scalar_reg);
    7230                 :        188 :   poly_uint64 nunits = GET_MODE_NUNITS (mode);
    7231                 :         94 :   if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
    7232                 :            :     {
    7233                 :            :       /* Test some simple unary cases with VEC_DUPLICATE arguments.  */
    7234                 :         64 :       rtx not_scalar_reg = gen_rtx_NOT (inner_mode, scalar_reg);
    7235                 :         64 :       rtx duplicate_not = gen_rtx_VEC_DUPLICATE (mode, not_scalar_reg);
    7236                 :         64 :       ASSERT_RTX_EQ (duplicate,
    7237                 :            :                      simplify_unary_operation (NOT, mode,
    7238                 :            :                                                duplicate_not, mode));
    7239                 :            : 
    7240                 :         64 :       rtx neg_scalar_reg = gen_rtx_NEG (inner_mode, scalar_reg);
    7241                 :         64 :       rtx duplicate_neg = gen_rtx_VEC_DUPLICATE (mode, neg_scalar_reg);
    7242                 :         64 :       ASSERT_RTX_EQ (duplicate,
    7243                 :            :                      simplify_unary_operation (NEG, mode,
    7244                 :            :                                                duplicate_neg, mode));
    7245                 :            : 
    7246                 :            :       /* Test some simple binary cases with VEC_DUPLICATE arguments.  */
    7247                 :         64 :       ASSERT_RTX_EQ (duplicate,
    7248                 :            :                      simplify_binary_operation (PLUS, mode, duplicate,
    7249                 :            :                                                 CONST0_RTX (mode)));
    7250                 :            : 
    7251                 :         64 :       ASSERT_RTX_EQ (duplicate,
    7252                 :            :                      simplify_binary_operation (MINUS, mode, duplicate,
    7253                 :            :                                                 CONST0_RTX (mode)));
    7254                 :            : 
    7255                 :         64 :       ASSERT_RTX_PTR_EQ (CONST0_RTX (mode),
    7256                 :            :                          simplify_binary_operation (MINUS, mode, duplicate,
    7257                 :            :                                                     duplicate));
    7258                 :            :     }
    7259                 :            : 
    7260                 :            :   /* Test a scalar VEC_SELECT of a VEC_DUPLICATE.  */
    7261                 :         94 :   rtx zero_par = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, const0_rtx));
    7262                 :         94 :   ASSERT_RTX_PTR_EQ (scalar_reg,
    7263                 :            :                      simplify_binary_operation (VEC_SELECT, inner_mode,
    7264                 :            :                                                 duplicate, zero_par));
    7265                 :            : 
    7266                 :         94 :   unsigned HOST_WIDE_INT const_nunits;
    7267                 :         94 :   if (nunits.is_constant (&const_nunits))
    7268                 :            :     {
    7269                 :            :       /* And again with the final element.  */
    7270                 :         94 :       rtx last_index = gen_int_mode (const_nunits - 1, word_mode);
    7271                 :         94 :       rtx last_par = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, last_index));
    7272                 :         94 :       ASSERT_RTX_PTR_EQ (scalar_reg,
    7273                 :            :                          simplify_binary_operation (VEC_SELECT, inner_mode,
    7274                 :            :                                                     duplicate, last_par));
    7275                 :            : 
    7276                 :            :       /* Test a scalar subreg of a VEC_MERGE of a VEC_DUPLICATE.  */
    7277                 :         94 :       rtx vector_reg = make_test_reg (mode);
    7278                 :       1572 :       for (unsigned HOST_WIDE_INT i = 0; i < const_nunits; i++)
    7279                 :            :         {
    7280                 :       1480 :           if (i >= HOST_BITS_PER_WIDE_INT)
    7281                 :            :             break;
    7282                 :       1478 :           rtx mask = GEN_INT ((HOST_WIDE_INT_1U << i) | (i + 1));
    7283                 :       1478 :           rtx vm = gen_rtx_VEC_MERGE (mode, duplicate, vector_reg, mask);
    7284                 :       2956 :           poly_uint64 offset = i * GET_MODE_SIZE (inner_mode);
    7285                 :       1478 :           ASSERT_RTX_EQ (scalar_reg,
    7286                 :            :                          simplify_gen_subreg (inner_mode, vm,
    7287                 :            :                                               mode, offset));
    7288                 :            :         }
    7289                 :            :     }
    7290                 :            : 
    7291                 :            :   /* Test a scalar subreg of a VEC_DUPLICATE.  */
    7292                 :         94 :   poly_uint64 offset = subreg_lowpart_offset (inner_mode, mode);
    7293                 :         94 :   ASSERT_RTX_EQ (scalar_reg,
    7294                 :            :                  simplify_gen_subreg (inner_mode, duplicate,
    7295                 :            :                                       mode, offset));
    7296                 :            : 
    7297                 :         94 :   machine_mode narrower_mode;
    7298                 :         94 :   if (maybe_ne (nunits, 2U)
    7299                 :         78 :       && multiple_p (nunits, 2)
    7300                 :        166 :       && mode_for_vector (inner_mode, 2).exists (&narrower_mode)
    7301                 :        166 :       && VECTOR_MODE_P (narrower_mode))
    7302                 :            :     {
    7303                 :            :       /* Test VEC_DUPLICATE of a vector.  */
    7304                 :        144 :       rtx_vector_builder nbuilder (narrower_mode, 2, 1);
    7305                 :         72 :       nbuilder.quick_push (const0_rtx);
    7306                 :         72 :       nbuilder.quick_push (const1_rtx);
    7307                 :        144 :       rtx_vector_builder builder (mode, 2, 1);
    7308                 :         72 :       builder.quick_push (const0_rtx);
    7309                 :         72 :       builder.quick_push (const1_rtx);
    7310                 :         72 :       ASSERT_RTX_EQ (builder.build (),
    7311                 :            :                      simplify_unary_operation (VEC_DUPLICATE, mode,
    7312                 :            :                                                nbuilder.build (),
    7313                 :            :                                                narrower_mode));
    7314                 :            : 
    7315                 :            :       /* Test VEC_SELECT of a vector.  */
    7316                 :         72 :       rtx vec_par
    7317                 :         72 :         = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, const1_rtx, const0_rtx));
    7318                 :         72 :       rtx narrower_duplicate
    7319                 :         72 :         = gen_rtx_VEC_DUPLICATE (narrower_mode, scalar_reg);
    7320                 :         72 :       ASSERT_RTX_EQ (narrower_duplicate,
    7321                 :            :                      simplify_binary_operation (VEC_SELECT, narrower_mode,
    7322                 :            :                                                 duplicate, vec_par));
    7323                 :            : 
    7324                 :            :       /* Test a vector subreg of a VEC_DUPLICATE.  */
    7325                 :         72 :       poly_uint64 offset = subreg_lowpart_offset (narrower_mode, mode);
    7326                 :         72 :       ASSERT_RTX_EQ (narrower_duplicate,
    7327                 :            :                      simplify_gen_subreg (narrower_mode, duplicate,
    7328                 :            :                                           mode, offset));
    7329                 :            :     }
    7330                 :         94 : }
    7331                 :            : 
    7332                 :            : /* Test vector simplifications involving VEC_SERIES in which the
    7333                 :            :    operands and result have vector mode MODE.  SCALAR_REG is a pseudo
    7334                 :            :    register that holds one element of MODE.  */
    7335                 :            : 
    7336                 :            : static void
    7337                 :         48 : test_vector_ops_series (machine_mode mode, rtx scalar_reg)
    7338                 :            : {
    7339                 :            :   /* Test unary cases with VEC_SERIES arguments.  */
    7340                 :         48 :   scalar_mode inner_mode = GET_MODE_INNER (mode);
    7341                 :         48 :   rtx duplicate = gen_rtx_VEC_DUPLICATE (mode, scalar_reg);
    7342                 :         48 :   rtx neg_scalar_reg = gen_rtx_NEG (inner_mode, scalar_reg);
    7343                 :         48 :   rtx series_0_r = gen_rtx_VEC_SERIES (mode, const0_rtx, scalar_reg);
    7344                 :         48 :   rtx series_0_nr = gen_rtx_VEC_SERIES (mode, const0_rtx, neg_scalar_reg);
    7345                 :         48 :   rtx series_nr_1 = gen_rtx_VEC_SERIES (mode, neg_scalar_reg, const1_rtx);
    7346                 :         48 :   rtx series_r_m1 = gen_rtx_VEC_SERIES (mode, scalar_reg, constm1_rtx);
    7347                 :         48 :   rtx series_r_r = gen_rtx_VEC_SERIES (mode, scalar_reg, scalar_reg);
    7348                 :         48 :   rtx series_nr_nr = gen_rtx_VEC_SERIES (mode, neg_scalar_reg,
    7349                 :            :                                          neg_scalar_reg);
    7350                 :         48 :   ASSERT_RTX_EQ (series_0_r,
    7351                 :            :                  simplify_unary_operation (NEG, mode, series_0_nr, mode));
    7352                 :         48 :   ASSERT_RTX_EQ (series_r_m1,
    7353                 :            :                  simplify_unary_operation (NEG, mode, series_nr_1, mode));
    7354                 :         48 :   ASSERT_RTX_EQ (series_r_r,
    7355                 :            :                  simplify_unary_operation (NEG, mode, series_nr_nr, mode));
    7356                 :            : 
    7357                 :            :   /* Test that a VEC_SERIES with a zero step is simplified away.  */
    7358                 :         48 :   ASSERT_RTX_EQ (duplicate,
    7359                 :            :                  simplify_binary_operation (VEC_SERIES, mode,
    7360                 :            :                                             scalar_reg, const0_rtx));
    7361                 :            : 
    7362                 :            :   /* Test PLUS and MINUS with VEC_SERIES.  */
    7363                 :         48 :   rtx series_0_1 = gen_const_vec_series (mode, const0_rtx, const1_rtx);
    7364                 :         48 :   rtx series_0_m1 = gen_const_vec_series (mode, const0_rtx, constm1_rtx);
    7365                 :         48 :   rtx series_r_1 = gen_rtx_VEC_SERIES (mode, scalar_reg, const1_rtx);
    7366                 :         48 :   ASSERT_RTX_EQ (series_r_r,
    7367                 :            :                  simplify_binary_operation (PLUS, mode, series_0_r,
    7368                 :            :                                             duplicate));
    7369                 :         48 :   ASSERT_RTX_EQ (series_r_1,
    7370                 :            :                  simplify_binary_operation (PLUS, mode, duplicate,
    7371                 :            :                                             series_0_1));
    7372                 :         48 :   ASSERT_RTX_EQ (series_r_m1,
    7373                 :            :                  simplify_binary_operation (PLUS, mode, duplicate,
    7374                 :            :                                             series_0_m1));
    7375                 :         48 :   ASSERT_RTX_EQ (series_0_r,
    7376                 :            :                  simplify_binary_operation (MINUS, mode, series_r_r,
    7377                 :            :                                             duplicate));
    7378                 :         48 :   ASSERT_RTX_EQ (series_r_m1,
    7379                 :            :                  simplify_binary_operation (MINUS, mode, duplicate,
    7380                 :            :                                             series_0_1));
    7381                 :         48 :   ASSERT_RTX_EQ (series_r_1,
    7382                 :            :                  simplify_binary_operation (MINUS, mode, duplicate,
    7383                 :            :                                             series_0_m1));
    7384                 :         48 :   ASSERT_RTX_EQ (series_0_m1,
    7385                 :            :                  simplify_binary_operation (VEC_SERIES, mode, const0_rtx,
    7386                 :            :                                             constm1_rtx));
    7387                 :            : 
    7388                 :            :   /* Test NEG on constant vector series.  */
    7389                 :         48 :   ASSERT_RTX_EQ (series_0_m1,
    7390                 :            :                  simplify_unary_operation (NEG, mode, series_0_1, mode));
    7391                 :         48 :   ASSERT_RTX_EQ (series_0_1,
    7392                 :            :                  simplify_unary_operation (NEG, mode, series_0_m1, mode));
    7393                 :            : 
    7394                 :            :   /* Test PLUS and MINUS on constant vector series.  */
    7395                 :         48 :   rtx scalar2 = gen_int_mode (2, inner_mode);
    7396                 :         48 :   rtx scalar3 = gen_int_mode (3, inner_mode);
    7397                 :         48 :   rtx series_1_1 = gen_const_vec_series (mode, const1_rtx, const1_rtx);
    7398                 :         48 :   rtx series_0_2 = gen_const_vec_series (mode, const0_rtx, scalar2);
    7399                 :         48 :   rtx series_1_3 = gen_const_vec_series (mode, const1_rtx, scalar3);
    7400                 :         48 :   ASSERT_RTX_EQ (series_1_1,
    7401                 :            :                  simplify_binary_operation (PLUS, mode, series_0_1,
    7402                 :            :                                             CONST1_RTX (mode)));
    7403                 :         48 :   ASSERT_RTX_EQ (series_0_m1,
    7404                 :            :                  simplify_binary_operation (PLUS, mode, CONST0_RTX (mode),
    7405                 :            :                                             series_0_m1));
    7406                 :         48 :   ASSERT_RTX_EQ (series_1_3,
    7407                 :            :                  simplify_binary_operation (PLUS, mode, series_1_1,
    7408                 :            :                                             series_0_2));
    7409                 :         48 :   ASSERT_RTX_EQ (series_0_1,
    7410                 :            :                  simplify_binary_operation (MINUS, mode, series_1_1,
    7411                 :            :                                             CONST1_RTX (mode)));
    7412                 :         48 :   ASSERT_RTX_EQ (series_1_1,
    7413                 :            :                  simplify_binary_operation (MINUS, mode, CONST1_RTX (mode),
    7414                 :            :                                             series_0_m1));
    7415                 :         48 :   ASSERT_RTX_EQ (series_1_1,
    7416                 :            :                  simplify_binary_operation (MINUS, mode, series_1_3,
    7417                 :            :                                             series_0_2));
    7418                 :            : 
    7419                 :            :   /* Test MULT between constant vectors.  */
    7420                 :         48 :   rtx vec2 = gen_const_vec_duplicate (mode, scalar2);
    7421                 :         48 :   rtx vec3 = gen_const_vec_duplicate (mode, scalar3);
    7422                 :         48 :   rtx scalar9 = gen_int_mode (9, inner_mode);
    7423                 :         48 :   rtx series_3_9 = gen_const_vec_series (mode, scalar3, scalar9);
    7424                 :         48 :   ASSERT_RTX_EQ (series_0_2,
    7425                 :            :                  simplify_binary_operation (MULT, mode, series_0_1, vec2));
    7426                 :         48 :   ASSERT_RTX_EQ (series_3_9,
    7427                 :            :                  simplify_binary_operation (MULT, mode, vec3, series_1_3));
    7428                 :         48 :   if (!GET_MODE_NUNITS (mode).is_constant ())
    7429                 :            :     ASSERT_FALSE (simplify_binary_operation (MULT, mode, series_0_1,
    7430                 :            :                                              series_0_1));
    7431                 :            : 
    7432                 :            :   /* Test ASHIFT between constant vectors.  */
    7433                 :         48 :   ASSERT_RTX_EQ (series_0_2,
    7434                 :            :                  simplify_binary_operation (ASHIFT, mode, series_0_1,
    7435                 :            :                                             CONST1_RTX (mode)));
    7436                 :         48 :   if (!GET_MODE_NUNITS (mode).is_constant ())
    7437                 :            :     ASSERT_FALSE (simplify_binary_operation (ASHIFT, mode, CONST1_RTX (mode),
    7438                 :            :                                              series_0_1));
    7439                 :         48 : }
    7440                 :            : 
    7441                 :            : /* Verify simplify_merge_mask works correctly.  */
    7442                 :            : 
    7443                 :            : static void
    7444                 :         94 : test_vec_merge (machine_mode mode)
    7445                 :            : {
    7446                 :         94 :   rtx op0 = make_test_reg (mode);
    7447                 :         94 :   rtx op1 = make_test_reg (mode);
    7448                 :         94 :   rtx op2 = make_test_reg (mode);
    7449                 :         94 :   rtx op3 = make_test_reg (mode);
    7450                 :         94 :   rtx op4 = make_test_reg (mode);
    7451                 :         94 :   rtx op5 = make_test_reg (mode);
    7452                 :         94 :   rtx mask1 = make_test_reg (SImode);
    7453                 :         94 :   rtx mask2 = make_test_reg (SImode);
    7454                 :         94 :   rtx vm1 = gen_rtx_VEC_MERGE (mode, op0, op1, mask1);
    7455                 :         94 :   rtx vm2 = gen_rtx_VEC_MERGE (mode, op2, op3, mask1);
    7456                 :         94 :   rtx vm3 = gen_rtx_VEC_MERGE (mode, op4, op5, mask1);
    7457                 :            : 
    7458                 :            :   /* Simple vec_merge.  */
    7459                 :         94 :   ASSERT_EQ (op0, simplify_merge_mask (vm1, mask1, 0));
    7460                 :         94 :   ASSERT_EQ (op1, simplify_merge_mask (vm1, mask1, 1));
    7461                 :         94 :   ASSERT_EQ (NULL_RTX, simplify_merge_mask (vm1, mask2, 0));
    7462                 :         94 :   ASSERT_EQ (NULL_RTX, simplify_merge_mask (vm1, mask2, 1));
    7463                 :            : 
    7464                 :            :   /* Nested vec_merge.
    7465                 :            :      It's tempting to make this simplify right down to opN, but we don't
    7466                 :            :      because all the simplify_* functions assume that the operands have
    7467                 :            :      already been simplified.  */
    7468                 :         94 :   rtx nvm = gen_rtx_VEC_MERGE (mode, vm1, vm2, mask1);
    7469                 :         94 :   ASSERT_EQ (vm1, simplify_merge_mask (nvm, mask1, 0));
    7470                 :         94 :   ASSERT_EQ (vm2, simplify_merge_mask (nvm, mask1, 1));
    7471                 :            : 
    7472                 :            :   /* Intermediate unary op. */
    7473                 :         94 :   rtx unop = gen_rtx_NOT (mode, vm1);
    7474                 :         94 :   ASSERT_RTX_EQ (gen_rtx_NOT (mode, op0),
    7475                 :            :                  simplify_merge_mask (unop, mask1, 0));
    7476                 :         94 :   ASSERT_RTX_EQ (gen_rtx_NOT (mode, op1),
    7477                 :            :                  simplify_merge_mask (unop, mask1, 1));
    7478                 :            : 
    7479                 :            :   /* Intermediate binary op. */
    7480                 :         94 :   rtx binop = gen_rtx_PLUS (mode, vm1, vm2);
    7481                 :         94 :   ASSERT_RTX_EQ (gen_rtx_PLUS (mode, op0, op2), 
    7482                 :            :                  simplify_merge_mask (binop, mask1, 0));
    7483                 :         94 :   ASSERT_RTX_EQ (gen_rtx_PLUS (mode, op1, op3),
    7484                 :            :                  simplify_merge_mask (binop, mask1, 1));
    7485                 :            : 
    7486                 :            :   /* Intermediate ternary op. */
    7487                 :         94 :   rtx tenop = gen_rtx_FMA (mode, vm1, vm2, vm3);
    7488                 :         94 :   ASSERT_RTX_EQ (gen_rtx_FMA (mode, op0, op2, op4),
    7489                 :            :                  simplify_merge_mask (tenop, mask1