LCOV - code coverage report
Current view: top level - gcc/config/i386 - predicates.md (source / functions) Hit Total Coverage
Test: gcc.info Lines: 744 869 85.6 %
Date: 2020-03-28 11:57:23 Functions: 151 158 95.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : ;; Predicate definitions for IA-32 and x86-64.
       2                 :            : ;; Copyright (C) 2004-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
       7                 :            : ;; it under the terms of the GNU General Public License as published by
       8                 :            : ;; the Free Software Foundation; either version 3, or (at your option)
       9                 :            : ;; any later version.
      10                 :            : ;;
      11                 :            : ;; GCC is distributed in the hope that it will be useful,
      12                 :            : ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : ;; GNU General Public License for more details.
      15                 :            : ;;
      16                 :            : ;; You should have received a copy of the GNU General Public License
      17                 :            : ;; along with GCC; see the file COPYING3.  If not see
      18                 :            : ;; <http://www.gnu.org/licenses/>.
      19                 :            : 
      20                 :            : ;; Return true if OP is either a i387 or SSE fp register.
      21                 :            : (define_predicate "any_fp_register_operand"
      22                 :            :   (and (match_code "reg")
      23                 :   79882000 :        (match_test "ANY_FP_REGNO_P (REGNO (op))")))
      24                 :      88028 : 
      25                 :            : ;; Return true if OP is an i387 fp register.
      26                 :            : (define_predicate "fp_register_operand"
      27                 :            :   (and (match_code "reg")
      28                 :  143065000 :        (match_test "STACK_REGNO_P (REGNO (op))")))
      29                 :    1382870 : 
      30                 :  239170000 : ;; True if the operand is a GENERAL class register.
      31                 :            : (define_predicate "general_reg_operand"
      32                 :            :   (and (match_code "reg")
      33                 :   53272400 :        (match_test "GENERAL_REGNO_P (REGNO (op))")))
      34                 :   23513000 : 
      35                 :   55181800 : ;; True if the operand is a nonimmediate operand with GENERAL class register.
      36                 :            : (define_predicate "nonimmediate_gr_operand"
      37                 :            :   (if_then_else (match_code "reg")
      38                 :   30595100 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      39                 :   34309000 :     (match_operand 0 "nonimmediate_operand")))
      40                 :   74089500 : 
      41                 :            : ;; True if the operand is a general operand with GENERAL class register.
      42                 :            : (define_predicate "general_gr_operand"
      43                 :   41038400 :   (if_then_else (match_code "reg")
      44                 :   18180000 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      45                 :   59218400 :     (match_operand 0 "general_operand")))
      46                 :            : 
      47                 :            : ;; True if the operand is an MMX register.
      48                 :            : (define_predicate "mmx_reg_operand"
      49                 :      11235 :   (and (match_code "reg")
      50                 :      11235 :        (match_test "MMX_REGNO_P (REGNO (op))")))
      51                 :      11235 : 
      52                 :            : ;; Match register operands, but include memory operands for
      53                 :            : ;; !TARGET_MMX_WITH_SSE.
      54                 :            : (define_predicate "register_mmxmem_operand"
      55                 :      42717 :   (ior (match_operand 0 "register_operand")
      56                 :         11 :        (and (not (match_test "TARGET_MMX_WITH_SSE"))
      57                 :      42717 :             (match_operand 0 "memory_operand"))))
      58                 :            : 
      59                 :            : ;; True if the operand is an SSE register.
      60                 :   60821700 : (define_predicate "sse_reg_operand"
      61                 :            :   (and (match_code "reg")
      62                 :   60821700 :        (match_test "SSE_REGNO_P (REGNO (op))")))
      63                 :     621128 : 
      64                 :            : ;; Return true if op is a QImode register.
      65                 :            : (define_predicate "any_QIreg_operand"
      66                 :            :   (and (match_code "reg")
      67                 :     705546 :        (match_test "ANY_QI_REGNO_P (REGNO (op))")))
      68                 :     446893 : 
      69                 :    1369240 : ;; Return true if op is one of QImode registers: %[abcd][hl].
      70                 :            : (define_predicate "QIreg_operand"
      71                 :            :   (and (match_code "reg")
      72                 :     844172 :        (match_test "QI_REGNO_P (REGNO (op))")))
      73                 :     384344 : 
      74                 :     933495 : ;; Return true if op is a QImode register operand other than %[abcd][hl].
      75                 :            : (define_predicate "ext_QIreg_operand"
      76                 :    1554320 :   (and (match_test "TARGET_64BIT")
      77                 :    1554320 :        (match_code "reg")
      78                 :     416580 :        (not (match_test "QI_REGNO_P (REGNO (op))"))))
      79                 :    1677740 : 
      80                 :            : ;; Return true if op is the AX register.
      81                 :            : (define_predicate "ax_reg_operand"
      82                 :            :   (and (match_code "reg")
      83                 :   49565100 :        (match_test "REGNO (op) == AX_REG")))
      84                 :          0 : 
      85                 :   84022200 : ;; Return true if op is the flags register.
      86                 :            : (define_predicate "flags_reg_operand"
      87                 :            :   (and (match_code "reg")
      88                 :   63508700 :        (match_test "REGNO (op) == FLAGS_REG")))
      89                 :       1085 : 
      90                 :   83088300 : ;; Match a DI, SI or HImode register for a zero_extract.
      91                 :            : (define_special_predicate "ext_register_operand"
      92                 :            :   (and (match_operand 0 "register_operand")
      93                 :     101283 :        (ior (and (match_test "TARGET_64BIT")
      94                 :      31262 :                  (match_test "GET_MODE (op) == DImode"))
      95                 :      64953 :             (match_test "GET_MODE (op) == SImode")
      96                 :      35136 :             (match_test "GET_MODE (op) == HImode"))))
      97                 :            : 
      98                 :            : ;; Match a DI, SI, HI or QImode nonimmediate_operand.
      99                 :            : (define_special_predicate "int_nonimmediate_operand"
     100                 :      35117 :   (and (match_operand 0 "nonimmediate_operand")
     101                 :      14800 :        (ior (and (match_test "TARGET_64BIT")
     102                 :      35117 :                  (match_test "GET_MODE (op) == DImode"))
     103                 :       6421 :             (match_test "GET_MODE (op) == SImode")
     104                 :            :             (match_test "GET_MODE (op) == HImode")
     105                 :      35117 :             (match_test "GET_MODE (op) == QImode"))))
     106                 :            : 
     107                 :            : ;; Match register operands, but include memory operands for TARGET_SSE_MATH.
     108                 :            : (define_predicate "register_ssemem_operand"
     109                 :    1187840 :   (if_then_else
     110                 :    1187840 :     (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     111                 :    1187840 :     (match_operand 0 "nonimmediate_operand")
     112                 :            :     (match_operand 0 "register_operand")))
     113                 :            : 
     114                 :     104190 : ;; Match nonimmediate operands, but exclude memory operands
     115                 :            : ;; for TARGET_SSE_MATH if TARGET_MIX_SSE_I387 is not enabled.
     116                 :     104190 : (define_predicate "nonimm_ssenomem_operand"
     117                 :            :   (if_then_else
     118                 :     104190 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     119                 :     208380 :          (not (match_test "TARGET_MIX_SSE_I387")))
     120                 :            :     (match_operand 0 "register_operand")
     121                 :            :     (match_operand 0 "nonimmediate_operand")))
     122                 :            : 
     123                 :     259443 : ;; The above predicate, suitable for x87 arithmetic operators.
     124                 :            : (define_predicate "x87nonimm_ssenomem_operand"
     125                 :     259443 :   (if_then_else
     126                 :     259443 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     127                 :     518886 :          (not (match_test "TARGET_MIX_SSE_I387 && X87_ENABLE_ARITH (mode)")))
     128                 :            :     (match_operand 0 "register_operand")
     129                 :            :     (match_operand 0 "nonimmediate_operand")))
     130                 :            : 
     131                 :      49639 : ;; Match register operands, include memory operand for TARGET_SSE4_1.
     132                 :            : (define_predicate "register_sse4nonimm_operand"
     133                 :      49639 :   (if_then_else (match_test "TARGET_SSE4_1")
     134                 :            :     (match_operand 0 "nonimmediate_operand")
     135                 :            :     (match_operand 0 "register_operand")))
     136                 :            : 
     137                 :      14186 : ;; Return true if VALUE is symbol reference
     138                 :            : (define_predicate "symbol_operand"
     139                 :      14186 :   (match_code "symbol_ref"))
     140                 :      14186 : 
     141                 :            : ;; Return true if VALUE can be stored in a sign extended immediate field.
     142                 :            : (define_predicate "x86_64_immediate_operand"
     143                 :            :   (match_code "const_int,symbol_ref,label_ref,const")
     144                 : 3146750000 : {
     145                 : 3146750000 :   if (!TARGET_64BIT)
     146                 :  155585000 :     return immediate_operand (op, mode);
     147                 :            : 
     148                 : 2991170000 :   switch (GET_CODE (op))
     149                 :            :     {
     150                 : 2493170000 :     case CONST_INT:
     151                 : 2493170000 :       {
     152                 : 2493170000 :         HOST_WIDE_INT val = INTVAL (op);
     153                 : 2493170000 :         return trunc_int_for_mode (val, SImode) == val;
     154                 :            :       }
     155                 :  397882000 :     case SYMBOL_REF:
     156                 :            :       /* TLS symbols are not constant.  */
     157                 :  397882000 :       if (SYMBOL_REF_TLS_MODEL (op))
     158                 :            :         return false;
     159                 :            : 
     160                 :            :       /* Load the external function address via the GOT slot.  */
     161                 :  397846000 :       if (ix86_force_load_from_GOT_p (op))
     162                 :            :         return false;
     163                 :            : 
     164                 :            :       /* For certain code models, the symbolic references are known to fit.
     165                 :            :          in CM_SMALL_PIC model we know it fits if it is local to the shared
     166                 :            :          library.  Don't count TLS SYMBOL_REFs here, since they should fit
     167                 :            :          only if inside of UNSPEC handled below.  */
     168                 :  397846000 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
     169                 :  400242000 :               || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
     170                 :            : 
     171                 :   12584300 :     case LABEL_REF:
     172                 :            :       /* For certain code models, the code is near as well.  */
     173                 :    1296700 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
     174                 :   15177700 :               || ix86_cmodel == CM_KERNEL);
     175                 :            : 
     176                 :   87528000 :     case CONST:
     177                 :            :       /* We also may accept the offsetted memory references in certain
     178                 :            :          special cases.  */
     179                 :   87528000 :       if (GET_CODE (XEXP (op, 0)) == UNSPEC)
     180                 :     633817 :         switch (XINT (XEXP (op, 0), 1))
     181                 :            :           {
     182                 :            :           case UNSPEC_GOTPCREL:
     183                 :            :           case UNSPEC_DTPOFF:
     184                 :            :           case UNSPEC_GOTNTPOFF:
     185                 :            :           case UNSPEC_NTPOFF:
     186                 :            :             return true;
     187                 :            :           default:
     188                 :            :             break;
     189                 :            :           }
     190                 :            : 
     191                 :   86894700 :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     192                 :            :         {
     193                 :   86894200 :           rtx op1 = XEXP (XEXP (op, 0), 0);
     194                 :   86894200 :           rtx op2 = XEXP (XEXP (op, 0), 1);
     195                 :            : 
     196                 :   86894200 :           if (ix86_cmodel == CM_LARGE && GET_CODE (op1) != UNSPEC)
     197                 :            :             return false;
     198                 :   86894200 :           if (!CONST_INT_P (op2))
     199                 :            :             return false;
     200                 :            : 
     201                 :   86894200 :           HOST_WIDE_INT offset = INTVAL (op2);
     202                 :   86894200 :           if (trunc_int_for_mode (offset, SImode) != offset)
     203                 :            :             return false;
     204                 :            : 
     205                 :   86888000 :           switch (GET_CODE (op1))
     206                 :            :             {
     207                 :   86660500 :             case SYMBOL_REF:
     208                 :            :               /* TLS symbols are not constant.  */
     209                 :   86660500 :               if (SYMBOL_REF_TLS_MODEL (op1))
     210                 :            :                 return false;
     211                 :            : 
     212                 :            :               /* Load the external function address via the GOT slot.  */
     213                 :   86647700 :               if (ix86_force_load_from_GOT_p (op1))
     214                 :            :                 return false;
     215                 :            : 
     216                 :            :               /* For CM_SMALL assume that latest object is 16MB before
     217                 :            :                  end of 31bits boundary.  We may also accept pretty
     218                 :            :                  large negative constants knowing that all objects are
     219                 :            :                  in the positive half of address space.  */
     220                 :   86647700 :               if ((ix86_cmodel == CM_SMALL
     221                 :     133177 :                    || (ix86_cmodel == CM_MEDIUM
     222                 :          0 :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     223                 :   86647700 :                   && offset < 16*1024*1024)
     224                 :            :                 return true;
     225                 :            :               /* For CM_KERNEL we know that all object resist in the
     226                 :            :                  negative half of 32bits address space.  We may not
     227                 :            :                  accept negative offsets, since they may be just off
     228                 :            :                  and we may accept pretty large positive ones.  */
     229                 :     134255 :               if (ix86_cmodel == CM_KERNEL
     230                 :          0 :                   && offset > 0)
     231                 :          0 :                 return true;
     232                 :            :               break;
     233                 :            : 
     234                 :       3741 :             case LABEL_REF:
     235                 :            :               /* These conditions are similar to SYMBOL_REF ones, just the
     236                 :            :                  constraints for code models differ.  */
     237                 :       3741 :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     238                 :       3741 :                   && offset < 16*1024*1024)
     239                 :            :                 return true;
     240                 :          0 :               if (ix86_cmodel == CM_KERNEL
     241                 :          0 :                   && offset > 0)
     242                 :          0 :                 return true;
     243                 :            :               break;
     244                 :            : 
     245                 :     223805 :             case UNSPEC:
     246                 :     223805 :               switch (XINT (op1, 1))
     247                 :            :                 {
     248                 :     223805 :                 case UNSPEC_DTPOFF:
     249                 :     223805 :                 case UNSPEC_NTPOFF:
     250                 :     223805 :                   return true;
     251                 :            :                 }
     252                 :            :               break;
     253                 :            : 
     254                 :            :             default:
     255                 :            :               break;
     256                 :            :             }
     257                 :            :         }
     258                 :            :       break;
     259                 :            : 
     260                 :          0 :       default:
     261                 :          0 :         gcc_unreachable ();
     262                 :            :     }
     263                 :            : 
     264                 :            :   return false;
     265                 :            : })
     266                 :            : 
     267                 :            : ;; Return true if VALUE can be stored in the zero extended immediate field.
     268                 : 3431980000 : (define_predicate "x86_64_zext_immediate_operand"
     269                 :            :   (match_code "const_int,symbol_ref,label_ref,const")
     270                 : 3431980000 : {
     271                 :            :   switch (GET_CODE (op))
     272                 : 3146750000 :     {
     273                 : 3146750000 :     case CONST_INT:
     274                 : 3146750000 :       return !(INTVAL (op) & ~(HOST_WIDE_INT) 0xffffffff);
     275                 : 3146750000 : 
     276                 : 3146750000 :     case SYMBOL_REF:
     277                 :            :       /* TLS symbols are not constant.  */
     278                 :            :       if (SYMBOL_REF_TLS_MODEL (op))
     279                 :            :         return false;
     280                 : 3146750000 : 
     281                 : 3146750000 :       /* Load the external function address via the GOT slot.  */
     282                 : 3146750000 :       if (ix86_force_load_from_GOT_p (op))
     283                 :            :         return false;
     284                 :            : 
     285                 :            :      /* For certain code models, the symbolic references are known to fit.  */
     286                 :            :       return (ix86_cmodel == CM_SMALL
     287                 :            :               || (ix86_cmodel == CM_MEDIUM
     288                 :            :                   && !SYMBOL_REF_FAR_ADDR_P (op)));
     289                 :            : 
     290                 :            :     case LABEL_REF:
     291                 :            :       /* For certain code models, the code is near as well.  */
     292                 :            :       return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
     293                 :            : 
     294                 :            :     case CONST:
     295                 :            :       /* We also may accept the offsetted memory references in certain
     296                 :            :          special cases.  */
     297                 :            :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     298                 :            :         {
     299                 :            :           rtx op1 = XEXP (XEXP (op, 0), 0);
     300                 :            :           rtx op2 = XEXP (XEXP (op, 0), 1);
     301                 :            : 
     302                 :            :           if (ix86_cmodel == CM_LARGE)
     303                 :            :             return false;
     304                 :            :           if (!CONST_INT_P (op2))
     305                 :            :             return false;
     306                 :            : 
     307                 :            :           HOST_WIDE_INT offset = INTVAL (op2);
     308                 :            :           if (trunc_int_for_mode (offset, SImode) != offset)
     309                 :            :             return false;
     310                 :            : 
     311                 :            :           switch (GET_CODE (op1))
     312                 :            :             {
     313                 :            :             case SYMBOL_REF:
     314                 :            :               /* TLS symbols are not constant.  */
     315                 :            :               if (SYMBOL_REF_TLS_MODEL (op1))
     316                 :            :                 return false;
     317                 :            : 
     318                 :            :               /* Load the external function address via the GOT slot.  */
     319                 :            :               if (ix86_force_load_from_GOT_p (op1))
     320                 :            :                 return false;
     321                 :            : 
     322                 :            :               /* For small code model we may accept pretty large positive
     323                 :            :                  offsets, since one bit is available for free.  Negative
     324                 :            :                  offsets are limited by the size of NULL pointer area
     325                 :            :                  specified by the ABI.  */
     326                 :            :               if ((ix86_cmodel == CM_SMALL
     327                 :            :                    || (ix86_cmodel == CM_MEDIUM
     328                 :            :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     329                 :            :                   && offset > -0x10000)
     330                 :            :                 return true;
     331                 :            :               /* ??? For the kernel, we may accept adjustment of
     332                 :            :                  -0x10000000, since we know that it will just convert
     333                 :            :                  negative address space to positive, but perhaps this
     334                 :            :                  is not worthwhile.  */
     335                 :            :               break;
     336                 :            : 
     337                 :            :             case LABEL_REF:
     338                 :            :               /* These conditions are similar to SYMBOL_REF ones, just the
     339                 :            :                  constraints for code models differ.  */
     340                 :            :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     341                 :            :                   && offset > -0x10000)
     342                 :            :                 return true;
     343                 :            :               break;
     344                 :            : 
     345                 :            :             default:
     346                 :            :               return false;
     347                 :            :             }
     348                 :            :         }
     349                 :            :       break;
     350                 :            : 
     351                 :            :     default:
     352                 :            :       gcc_unreachable ();
     353                 :            :     }
     354                 :            :   return false;
     355                 :            : })
     356                 :            : 
     357                 :            : ;; Return true if VALUE is a constant integer whose low and high words satisfy
     358                 :  231095000 : ;; x86_64_immediate_operand.
     359                 :            : (define_predicate "x86_64_hilo_int_operand"
     360                 :  231095000 :   (match_code "const_int,const_wide_int")
     361                 :            : {
     362                 :  103277000 :   switch (GET_CODE (op))
     363                 :   92249300 :     {
     364                 :  103259000 :     case CONST_INT:
     365                 :   11009800 :       return x86_64_immediate_operand (op, mode);
     366                 :   92249300 : 
     367                 :      17989 :     case CONST_WIDE_INT:
     368                 :      17989 :       gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
     369                 :      17989 :       return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
     370                 :   92249300 :                                         DImode)
     371                 :   92267300 :               && x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op,
     372                 :   92249300 :                                                                         1)),
     373                 :      17989 :                                            DImode));
     374                 :            : 
     375                 :          0 :     default:
     376                 :   11027800 :       gcc_unreachable ();
     377                 :            :     }
     378                 :            : })
     379                 :            : 
     380                 :            : ;; Return true if VALUE is a constant integer whose value is
     381                 :   11228400 : ;; x86_64_immediate_operand value zero extended from word mode to mode.
     382                 :            : (define_predicate "x86_64_dwzext_immediate_operand"
     383                 :   11228400 :   (match_code "const_int,const_wide_int")
     384                 :            : {
     385                 :   11027800 :   switch (GET_CODE (op))
     386                 :   11027800 :     {
     387                 :   11027800 :     case CONST_INT:
     388                 :            :       if (!TARGET_64BIT)
     389                 :            :         return UINTVAL (op) <= HOST_WIDE_INT_UC (0xffffffff);
     390                 :            :       return UINTVAL (op) <= HOST_WIDE_INT_UC (0x7fffffff);
     391                 :   11027800 : 
     392                 :   11027800 :     case CONST_WIDE_INT:
     393                 :            :       if (!TARGET_64BIT)
     394                 :            :         return false;
     395                 :            :       return (CONST_WIDE_INT_NUNITS (op) == 2
     396                 :            :               && CONST_WIDE_INT_ELT (op, 1) == 0
     397                 :            :               && (trunc_int_for_mode (CONST_WIDE_INT_ELT (op, 0), SImode)
     398                 :            :                   == (HOST_WIDE_INT) CONST_WIDE_INT_ELT (op, 0)));
     399                 :            : 
     400                 :            :     default:
     401                 :            :       gcc_unreachable ();
     402                 :            :     }
     403                 :            : })
     404                 :            : 
     405                 :            : ;; Return true if size of VALUE can be stored in a sign
     406                 :       5862 : ;; extended immediate field.
     407                 :            : (define_predicate "x86_64_immediate_size_operand"
     408                 :       5862 :   (and (match_code "symbol_ref")
     409                 :          0 :        (ior (not (match_test "TARGET_64BIT"))
     410                 :          0 :             (match_test "ix86_cmodel == CM_SMALL")
     411                 :          0 :             (match_test "ix86_cmodel == CM_KERNEL"))))
     412                 :          0 : 
     413                 :            : ;; Return true if OP is general operand representable on x86_64.
     414                 :            : (define_predicate "x86_64_general_operand"
     415                 :   52434300 :   (if_then_else (match_test "TARGET_64BIT")
     416                 :   34138900 :     (ior (match_operand 0 "nonimmediate_operand")
     417                 :       5862 :          (match_operand 0 "x86_64_immediate_operand"))
     418                 :   34133000 :     (match_operand 0 "general_operand")))
     419                 :   14568900 : 
     420                 :            : ;; Return true if OP's both words are general operands representable
     421                 :   14568900 : ;; on x86_64.
     422                 :            : (define_predicate "x86_64_hilo_general_operand"
     423                 :   25485400 :   (if_then_else (match_test "TARGET_64BIT")
     424                 :            :     (ior (match_operand 0 "nonimmediate_operand")
     425                 :            :          (match_operand 0 "x86_64_hilo_int_operand"))
     426                 :            :     (match_operand 0 "general_operand")))
     427                 :      44273 : 
     428                 :            : ;; Return true if OP is non-VOIDmode general operand representable
     429                 :      44273 : ;; on x86_64.  This predicate is used in sign-extending conversion
     430                 :            : ;; operations that require non-VOIDmode immediate operands.
     431                 :            : (define_predicate "x86_64_sext_operand"
     432                 :      44273 :   (and (match_test "GET_MODE (op) != VOIDmode")
     433                 :            :        (match_operand 0 "x86_64_general_operand")))
     434                 :            : 
     435                 :            : ;; Return true if OP is non-VOIDmode general operand.  This predicate
     436                 :       3430 : ;; is used in sign-extending conversion operations that require
     437                 :            : ;; non-VOIDmode immediate operands.
     438                 :       3430 : (define_predicate "sext_operand"
     439                 :       3430 :   (and (match_test "GET_MODE (op) != VOIDmode")
     440                 :            :        (match_operand 0 "general_operand")))
     441                 :            : 
     442                 :            : ;; Return true if OP is representable on x86_64 as zero-extended operand.
     443                 :     413119 : ;; This predicate is used in zero-extending conversion operations that
     444                 :            : ;; require non-VOIDmode immediate operands.
     445                 :     413119 : (define_predicate "x86_64_zext_operand"
     446                 :     413119 :   (if_then_else (match_test "TARGET_64BIT")
     447                 :            :     (ior (match_operand 0 "nonimmediate_operand")
     448                 :            :          (and (match_operand 0 "x86_64_zext_immediate_operand")
     449                 :      26209 :               (match_test "GET_MODE (op) != VOIDmode")))
     450                 :            :     (match_operand 0 "nonimmediate_operand")))
     451                 :            : 
     452                 :            : ;; Return true if OP is general operand representable on x86_64
     453                 :    1688030 : ;; as either sign extended or zero extended constant.
     454                 :            : (define_predicate "x86_64_szext_general_operand"
     455                 :    1704630 :   (if_then_else (match_test "TARGET_64BIT")
     456                 :            :     (ior (match_operand 0 "nonimmediate_operand")
     457                 :            :          (match_operand 0 "x86_64_immediate_operand")
     458                 :            :          (match_operand 0 "x86_64_zext_immediate_operand"))
     459                 :   14944000 :     (match_operand 0 "general_operand")))
     460                 :            : 
     461                 :   14944000 : ;; Return true if OP is nonmemory operand representable on x86_64.
     462                 :            : (define_predicate "x86_64_nonmemory_operand"
     463                 :   22279300 :   (if_then_else (match_test "TARGET_64BIT")
     464                 :            :     (ior (match_operand 0 "register_operand")
     465                 :            :          (match_operand 0 "x86_64_immediate_operand"))
     466                 :            :     (match_operand 0 "nonmemory_operand")))
     467                 :      58847 : 
     468                 :            : ;; Return true if OP is nonmemory operand representable on x86_64.
     469                 :      58847 : (define_predicate "x86_64_szext_nonmemory_operand"
     470                 :      59075 :   (if_then_else (match_test "TARGET_64BIT")
     471                 :            :     (ior (match_operand 0 "register_operand")
     472                 :            :          (match_operand 0 "x86_64_immediate_operand")
     473                 :            :          (match_operand 0 "x86_64_zext_immediate_operand"))
     474                 :   86566500 :     (match_operand 0 "nonmemory_operand")))
     475                 :            : 
     476                 :            : ;; Return true when operand is PIC expression that can be computed by lea
     477                 :            : ;; operation.
     478                 :            : (define_predicate "pic_32bit_operand"
     479                 :            :   (match_code "const,symbol_ref,label_ref")
     480                 :            : {
     481                 :   86566500 :   if (!flag_pic)
     482                 :            :     return false;
     483                 :            : 
     484                 :            :   /* Rule out relocations that translate into 64bit constants.  */
     485                 :    6020030 :   if (TARGET_64BIT && GET_CODE (op) == CONST)
     486                 :            :     {
     487                 :     100879 :       op = XEXP (op, 0);
     488                 :     100879 :       if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
     489                 :     100330 :         op = XEXP (op, 0);
     490                 :     100879 :       if (GET_CODE (op) == UNSPEC
     491                 :        549 :           && (XINT (op, 1) == UNSPEC_GOTOFF
     492                 :        549 :               || XINT (op, 1) == UNSPEC_GOT))
     493                 :            :         return false;
     494                 :            :     }
     495                 :            : 
     496                 :    6019600 :   return symbolic_operand (op, mode);
     497                 :            : })
     498                 :            : 
     499                 :            : ;; Return true if OP is nonmemory operand acceptable by movabs patterns.
     500                 :  636520000 : (define_predicate "x86_64_movabs_operand"
     501                 :            :   (and (match_operand 0 "nonmemory_operand")
     502                 :  636520000 :        (not (match_operand 0 "pic_32bit_operand"))))
     503                 :            : 
     504                 :   86566500 : ;; Return true if OP is either a symbol reference or a sum of a symbol
     505                 :   86566500 : ;; reference and a constant.
     506                 :   86566500 : (define_predicate "symbolic_operand"
     507                 :   86566500 :   (match_code "symbol_ref,label_ref,const")
     508                 :            : {
     509                 :            :   switch (GET_CODE (op))
     510                 :            :     {
     511                 :   86566500 :     case SYMBOL_REF:
     512                 :   86566500 :     case LABEL_REF:
     513                 :   86566500 :       return true;
     514                 :            : 
     515                 :            :     case CONST:
     516                 :            :       op = XEXP (op, 0);
     517                 :  174060000 :       if (GET_CODE (op) == SYMBOL_REF
     518                 :            :           || GET_CODE (op) == LABEL_REF
     519                 :  174060000 :           || (GET_CODE (op) == UNSPEC
     520                 :            :               && (XINT (op, 1) == UNSPEC_GOT
     521                 :            :                   || XINT (op, 1) == UNSPEC_GOTOFF
     522                 :            :                   || XINT (op, 1) == UNSPEC_PCREL
     523                 :            :                   || XINT (op, 1) == UNSPEC_GOTPCREL)))
     524                 :            :         return true;
     525                 :            :       if (GET_CODE (op) != PLUS
     526                 :            :           || !CONST_INT_P (XEXP (op, 1)))
     527                 :            :         return false;
     528                 :            : 
     529                 :            :       op = XEXP (op, 0);
     530                 :            :       if (GET_CODE (op) == SYMBOL_REF
     531                 :            :           || GET_CODE (op) == LABEL_REF)
     532                 :            :         return true;
     533                 :            :       /* Only @GOTOFF gets offsets.  */
     534                 :            :       if (GET_CODE (op) != UNSPEC
     535                 :            :           || XINT (op, 1) != UNSPEC_GOTOFF)
     536                 :            :         return false;
     537                 :            : 
     538                 :            :       op = XVECEXP (op, 0, 0);
     539                 :            :       if (GET_CODE (op) == SYMBOL_REF
     540                 :            :           || GET_CODE (op) == LABEL_REF)
     541                 :            :         return true;
     542                 :            :       return false;
     543                 :            : 
     544                 :            :     default:
     545                 :            :       gcc_unreachable ();
     546                 :            :     }
     547                 :            : })
     548                 :            : 
     549                 :            : ;; Return true if OP is a symbolic operand that resolves locally.
     550                 :   12068700 : (define_predicate "local_symbolic_operand"
     551                 :            :   (match_code "const,label_ref,symbol_ref")
     552                 :   12068700 : {
     553                 :            :   if (GET_CODE (op) == CONST
     554                 :    6320540 :       && GET_CODE (XEXP (op, 0)) == PLUS
     555                 :    6320540 :       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
     556                 :    6320540 :     op = XEXP (XEXP (op, 0), 0);
     557                 :    6320540 : 
     558                 :            :   if (GET_CODE (op) == LABEL_REF)
     559                 :            :     return true;
     560                 :            : 
     561                 :    6320540 :   if (GET_CODE (op) != SYMBOL_REF)
     562                 :    6320540 :     return false;
     563                 :    6320540 : 
     564                 :            :   if (SYMBOL_REF_TLS_MODEL (op))
     565                 :            :     return false;
     566                 :            : 
     567                 :            :   /* Dll-imported symbols are always external.  */
     568                 :            :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     569                 :            :     return false;
     570                 :            :   if (SYMBOL_REF_LOCAL_P (op))
     571                 :            :     return true;
     572                 :            : 
     573                 :            :   /* There is, however, a not insubstantial body of code in the rest of
     574                 :            :      the compiler that assumes it can just stick the results of
     575                 :            :      ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done.  */
     576                 :            :   /* ??? This is a hack.  Should update the body of the compiler to
     577                 :            :      always create a DECL an invoke targetm.encode_section_info.  */
     578                 :            :   if (strncmp (XSTR (op, 0), internal_label_prefix,
     579                 :            :                internal_label_prefix_len) == 0)
     580                 :            :     return true;
     581                 :            : 
     582                 :            :   return false;
     583                 :            : })
     584                 :            : 
     585                 :            : ;; Test for a legitimate @GOTOFF operand.
     586                 :    1642670 : ;;
     587                 :            : ;; VxWorks does not impose a fixed gap between segments; the run-time
     588                 :    1642670 : ;; gap can be different from the object-file gap.  We therefore can't
     589                 :            : ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
     590                 :    1634950 : ;; same segment as the GOT.  Unfortunately, the flexibility of linker
     591                 :    1634950 : ;; scripts means that we can't be sure of that in general, so assume
     592                 :    1634950 : ;; that @GOTOFF is never valid on VxWorks.
     593                 :    1634950 : (define_predicate "gotoff_operand"
     594                 :    3285300 :   (and (not (match_test "TARGET_VXWORKS_RTP"))
     595                 :            :        (match_operand 0 "local_symbolic_operand")))
     596                 :            : 
     597                 :    1634950 : ;; Test for various thread-local symbols.
     598                 :    1634950 : (define_special_predicate "tls_symbolic_operand"
     599                 :    1634950 :   (and (match_code "symbol_ref")
     600                 :       7444 :        (match_test "SYMBOL_REF_TLS_MODEL (op)")))
     601                 :            : 
     602                 :            : (define_special_predicate "tls_modbase_operand"
     603                 :    1642650 :   (and (match_code "symbol_ref")
     604                 :          3 :        (match_test "op == ix86_tls_module_base ()")))
     605                 :    1642650 : 
     606                 :          6 : (define_predicate "tls_address_pattern"
     607                 :            :   (and (match_code "set,parallel,unspec,unspec_volatile")
     608                 :  140770000 :        (match_test "ix86_tls_address_pattern_p (op)")))
     609                 :  140770000 : 
     610                 :  140770000 : ;; Test for a pc-relative call operand
     611                 :            : (define_predicate "constant_call_address_operand"
     612                 :  140770000 :   (match_code "symbol_ref")
     613                 :  208510000 : {
     614                 :   67740000 :   if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
     615                 :   67740000 :       || flag_force_indirect_call)
     616                 :  140770000 :     return false;
     617                 :            :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     618                 :            :     return false;
     619                 :            :   return true;
     620                 :  140770000 : })
     621                 :            : 
     622                 :            : ;; P6 processors will jump to the address after the decrement when %esp
     623                 :   71226200 : ;; is used as a call operand, so they will execute return address as a code.
     624                 :            : ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
     625                 :   71226200 : 
     626                 :  138966000 : (define_predicate "call_register_no_elim_operand"
     627                 :   43841600 :   (match_operand 0 "register_operand")
     628                 :            : {
     629                 :     287781 :   if (SUBREG_P (op))
     630                 :          0 :     op = SUBREG_REG (op);
     631                 :     287781 : 
     632                 :     287781 :   if (!TARGET_64BIT && op == stack_pointer_rtx)
     633                 :            :     return false;
     634                 :            : 
     635                 :     287781 :   return register_no_elim_operand (op, mode);
     636                 :            : })
     637                 :            : 
     638                 :            : ;; True for any non-virtual or eliminable register.  Used in places where
     639                 :     598257 : ;; instantiation of such a register may cause the pattern to not be recognized.
     640                 :            : (define_predicate "register_no_elim_operand"
     641                 :     886038 :   (match_operand 0 "register_operand")
     642                 :     287781 : {
     643                 :    4329140 :   if (SUBREG_P (op))
     644                 :      12661 :     op = SUBREG_REG (op);
     645                 :    8638980 :   return !(op == arg_pointer_rtx
     646                 :    4310170 :            || op == frame_pointer_rtx
     647                 :    4309840 :            || IN_RANGE (REGNO (op),
     648                 :            :                         FIRST_PSEUDO_REGISTER, LAST_VIRTUAL_REGISTER));
     649                 :            : })
     650                 :            : 
     651                 :            : ;; Similarly, but include the stack pointer.  This is used to prevent esp
     652                 :    4499410 : ;; from being used as an index reg.
     653                 :            : (define_predicate "index_register_operand"
     654                 :    4499410 :   (match_operand 0 "register_operand")
     655                 :    4329140 : {
     656                 :            :   if (SUBREG_P (op))
     657                 :            :     op = SUBREG_REG (op);
     658                 :            :   if (reload_completed)
     659                 :            :     return REG_OK_FOR_INDEX_STRICT_P (op);
     660                 :            :   else
     661                 :            :     return REG_OK_FOR_INDEX_NONSTRICT_P (op);
     662                 :            : })
     663                 :            : 
     664                 :            : ;; Return false if this is any eliminable register.  Otherwise general_operand.
     665                 :     689308 : (define_predicate "general_no_elim_operand"
     666                 :            :   (if_then_else (match_code "reg,subreg")
     667                 :     689308 :     (match_operand 0 "register_no_elim_operand")
     668                 :     634451 :     (match_operand 0 "general_operand")))
     669                 :            : 
     670                 :            : ;; Return false if this is any eliminable register.  Otherwise
     671                 :            : ;; register_operand or a constant.
     672                 :   10067200 : (define_predicate "nonmemory_no_elim_operand"
     673                 :            :   (ior (match_operand 0 "register_no_elim_operand")
     674                 :   10067200 :        (match_operand 0 "immediate_operand")))
     675                 :            : 
     676                 :            : ;; Test for a valid operand for indirect branch.
     677                 :            : (define_predicate "indirect_branch_operand"
     678                 :     121645 :   (ior (match_operand 0 "register_operand")
     679                 :    1196300 :        (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
     680                 :     520394 :             (not (match_test "TARGET_X32"))
     681                 :            :             (match_operand 0 "memory_operand"))))
     682                 :            : 
     683                 :            : ;; Return true if OP is a memory operands that can be used in sibcalls.
     684                 :     411693 : ;; Since sibcall never returns, we can only use call-clobbered register
     685                 :            : ;; as GOT base.  Allow GOT slot here only with pseudo register as GOT
     686                 :     411693 : ;; base.  Properly handle sibcall over GOT slot with *sibcall_GOT_32
     687                 :            : ;; and *sibcall_value_GOT_32 patterns.
     688                 :            : (define_predicate "sibcall_memory_operand"
     689                 :            :   (match_operand 0 "memory_operand")
     690                 :            : {
     691                 :            :   op = XEXP (op, 0);
     692                 :            :   if (CONSTANT_P (op))
     693                 :            :     return true;
     694                 :            :   if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
     695                 :            :     {
     696                 :            :       int regno = REGNO (XEXP (op, 0));
     697                 :            :       if (!HARD_REGISTER_NUM_P (regno) || call_used_or_fixed_reg_p (regno))
     698                 :            :         {
     699                 :            :           op = XEXP (op, 1);
     700                 :            :           if (GOT32_symbol_operand (op, VOIDmode))
     701                 :            :             return true;
     702                 :            :         }
     703                 :            :     }
     704                 :            :   return false;
     705                 :            : })
     706                 :            : 
     707                 :            : ;; Return true if OP is a GOT memory operand.
     708                 :     949689 : (define_predicate "GOT_memory_operand"
     709                 :            :   (match_operand 0 "memory_operand")
     710                 :     962899 : {
     711                 :      13210 :   op = XEXP (op, 0);
     712                 :         40 :   return (GET_CODE (op) == CONST
     713                 :         40 :           && GET_CODE (XEXP (op, 0)) == UNSPEC
     714                 :         40 :           && XINT (XEXP (op, 0), 1) == UNSPEC_GOTPCREL);
     715                 :         40 : })
     716                 :            : 
     717                 :            : ;; Test for a valid operand for a call instruction.
     718                 :        351 : ;; Allow constant call address operands in Pmode only.
     719                 :            : (define_special_predicate "call_insn_operand"
     720                 :        351 :   (ior (match_test "constant_call_address_operand
     721                 :   13243700 :                      (op, mode == VOIDmode ? mode : Pmode)")
     722                 :            :        (match_operand 0 "call_register_no_elim_operand")
     723                 :     310476 :        (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
     724                 :     310291 :             (ior (and (not (match_test "TARGET_X32"))
     725                 :   11839000 :                       (match_operand 0 "memory_operand"))
     726                 :     246316 :                  (and (match_test "TARGET_X32 && Pmode == DImode")
     727                 :   11839000 :                       (match_operand 0 "GOT_memory_operand"))))))
     728                 :            : 
     729                 :            : ;; Similarly, but for tail calls, in which we cannot allow memory references.
     730                 :     359650 : (define_special_predicate "sibcall_insn_operand"
     731                 :            :   (ior (match_test "constant_call_address_operand
     732                 :     379165 :                      (op, mode == VOIDmode ? mode : Pmode)")
     733                 :            :        (match_operand 0 "register_no_elim_operand")
     734                 :      84799 :        (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
     735                 :      84634 :             (ior (and (not (match_test "TARGET_X32"))
     736                 :            :                       (match_operand 0 "sibcall_memory_operand"))
     737                 :      83663 :                  (and (match_test "TARGET_X32 && Pmode == DImode")
     738                 :            :                       (match_operand 0 "GOT_memory_operand"))))))
     739                 :            : 
     740                 :            : ;; Return true if OP is a 32-bit GOT symbol operand.
     741                 :       3586 : (define_predicate "GOT32_symbol_operand"
     742                 :       3586 :   (match_test "GET_CODE (op) == CONST
     743                 :       1476 :                && GET_CODE (XEXP (op, 0)) == UNSPEC
     744                 :       5062 :                && XINT (XEXP (op, 0), 1) == UNSPEC_GOT"))
     745                 :          0 : 
     746                 :            : ;; Match exactly zero.
     747                 :            : (define_predicate "const0_operand"
     748                 :            :   (match_code "const_int,const_double,const_vector")
     749                 :   29197100 : {
     750                 :   29197100 :   if (mode == VOIDmode)
     751                 :   10187300 :     mode = GET_MODE (op);
     752                 :   29197100 :   return op == CONST0_RTX (mode);
     753                 :            : })
     754                 :            : 
     755                 :            : ;; Match one or a vector with all elements equal to one.
     756                 :  311806000 : (define_predicate "const1_operand"
     757                 :            :   (match_code "const_int,const_double,const_vector")
     758                 :  311806000 : {
     759                 :    7924670 :   if (mode == VOIDmode)
     760                 :    7922790 :     mode = GET_MODE (op);
     761                 :   37121800 :   return op == CONST1_RTX (mode);
     762                 :   29197100 : })
     763                 :   29197100 : 
     764                 :            : ;; Match exactly -1.
     765                 :    8466870 : (define_predicate "constm1_operand"
     766                 :            :   (and (match_code "const_int")
     767                 :   37664000 :        (match_test "op == constm1_rtx")))
     768                 :   29197100 : 
     769                 :   29197100 : ;; Match exactly eight.
     770                 :    7924670 : (define_predicate "const8_operand"
     771                 :    7924670 :   (and (match_code "const_int")
     772                 :    7924670 :        (match_test "INTVAL (op) == 8")))
     773                 :          0 : 
     774                 :            : ;; Match exactly 128.
     775                 :            : (define_predicate "const128_operand"
     776                 :    7924670 :   (and (match_code "const_int")
     777                 :    7924670 :        (match_test "INTVAL (op) == 128")))
     778                 :   24434800 : 
     779                 :            : ;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation
     780                 :            : (define_predicate "const_32bit_mask"
     781                 :     393678 :   (and (match_code "const_int")
     782                 :     321704 :        (match_test "trunc_int_for_mode (INTVAL (op), DImode)
     783                 :     715382 :                     == (HOST_WIDE_INT) 0xffffffff")))
     784                 :    7974480 : 
     785                 :            : ;; Match 2, 4, or 8.  Used for leal multiplicands.
     786                 :            : (define_predicate "const248_operand"
     787                 :     127632 :   (match_code "const_int")
     788                 :            : {
     789                 :     127632 :   HOST_WIDE_INT i = INTVAL (op);
     790                 :     111474 :   return i == 2 || i == 4 || i == 8;
     791                 :            : })
     792                 :            : 
     793                 :            : ;; Match 1, 2, or 3.  Used for lea shift amounts.
     794                 :     563614 : (define_predicate "const123_operand"
     795                 :            :   (match_code "const_int")
     796                 :     563614 : {
     797                 :     127632 :   HOST_WIDE_INT i = INTVAL (op);
     798                 :    1256890 :   return i == 1 || i == 2 || i == 3;
     799                 :            : })
     800                 :            : 
     801                 :    1256890 : ;; Match 2, 3, 6, or 7
     802                 :    1274010 : (define_predicate "const2367_operand"
     803                 :            :   (match_code "const_int")
     804                 :    1274010 : {
     805                 :    1256890 :   HOST_WIDE_INT i = INTVAL (op);
     806                 :         20 :   return i == 2 || i == 3 || i == 6 || i == 7;
     807                 :            : })
     808                 :            : 
     809                 :        440 : ;; Match 1, 2, 4, or 8
     810                 :        440 : (define_predicate "const1248_operand"
     811                 :            :   (match_code "const_int")
     812                 :        440 : {
     813                 :        440 :   HOST_WIDE_INT i = INTVAL (op);
     814                 :       7301 :   return i == 1 || i == 2 || i == 4 || i == 8;
     815                 :            : })
     816                 :            : 
     817                 :      22535 : ;; Match 3, 5, or 9.  Used for leal multiplicands.
     818                 :      22535 : (define_predicate "const359_operand"
     819                 :            :   (match_code "const_int")
     820                 :      22535 : {
     821                 :      22535 :   HOST_WIDE_INT i = INTVAL (op);
     822                 :      32140 :   return i == 3 || i == 5 || i == 9;
     823                 :            : })
     824                 :            : 
     825                 :      33028 : ;; Match 4 or 8 to 11.  Used for embeded rounding.
     826                 :     142078 : (define_predicate "const_4_or_8_to_11_operand"
     827                 :            :   (match_code "const_int")
     828                 :     142078 : {
     829                 :      33028 :   HOST_WIDE_INT i = INTVAL (op);
     830                 :      26851 :   return i == 4 || (i >= 8 && i <= 11);
     831                 :            : })
     832                 :            : 
     833                 :      26851 : ;; Match 4 or 8. Used for SAE.
     834                 :      26853 : (define_predicate "const48_operand"
     835                 :            :   (match_code "const_int")
     836                 :      26853 : {
     837                 :      26851 :   HOST_WIDE_INT i = INTVAL (op);
     838                 :      20304 :   return i == 4 || i == 8;
     839                 :            : })
     840                 :            : 
     841                 :      20304 : ;; Match 0 or 1.
     842                 :      20304 : (define_predicate "const_0_to_1_operand"
     843                 :            :   (and (match_code "const_int")
     844                 :      20304 :        (ior (match_test "op == const0_rtx")
     845                 :      45589 :             (match_test "op == const1_rtx"))))
     846                 :            : 
     847                 :            : ;; Match 0 to 3.
     848                 :            : (define_predicate "const_0_to_3_operand"
     849                 :    2140124 :   (and (match_code "const_int")
     850                 :    4066470 :        (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
     851                 :    2140120 : 
     852                 :            : ;; Match 0 to 4.
     853                 :            : (define_predicate "const_0_to_4_operand"
     854                 :          0 :   (and (match_code "const_int")
     855                 :          0 :        (match_test "IN_RANGE (INTVAL (op), 0, 4)")))
     856                 :          0 : 
     857                 :            : ;; Match 0 to 5.
     858                 :            : (define_predicate "const_0_to_5_operand"
     859                 :          0 :   (and (match_code "const_int")
     860                 :          0 :        (match_test "IN_RANGE (INTVAL (op), 0, 5)")))
     861                 :          0 : 
     862                 :            : ;; Match 0 to 7.
     863                 :            : (define_predicate "const_0_to_7_operand"
     864                 :     224828 :   (and (match_code "const_int")
     865                 :     449605 :        (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
     866                 :     224828 : 
     867                 :            : ;; Match 0 to 15.
     868                 :            : (define_predicate "const_0_to_15_operand"
     869                 :      54609 :   (and (match_code "const_int")
     870                 :     109202 :        (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
     871                 :      54609 : 
     872                 :            : ;; Match 0 to 31.
     873                 :            : (define_predicate "const_0_to_31_operand"
     874                 :      11018 :   (and (match_code "const_int")
     875                 :      22019 :        (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
     876                 :      11018 : 
     877                 :            : ;; Match 0 to 63.
     878                 :            : (define_predicate "const_0_to_63_operand"
     879                 :       8025 :   (and (match_code "const_int")
     880                 :      15480 :        (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
     881                 :       8025 : 
     882                 :            : ;; Match 0 to 255.
     883                 :            : (define_predicate "const_0_to_255_operand"
     884                 :    1759400 :   (and (match_code "const_int")
     885                 :    3506390 :        (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
     886                 :    1759400 : 
     887                 :            : ;; Match (0 to 255) * 8
     888                 :            : (define_predicate "const_0_to_255_mul_8_operand"
     889                 :      75283 :   (match_code "const_int")
     890                 :            : {
     891                 :      75283 :   unsigned HOST_WIDE_INT val = INTVAL (op);
     892                 :      75276 :   return val <= 255*8 && val % 8 == 0;
     893                 :            : })
     894                 :            : 
     895                 :            : ;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand
     896                 :      75285 : ;; for shift & compare patterns, as shifting by 0 does not change flags).
     897                 :            : (define_predicate "const_1_to_31_operand"
     898                 :      75285 :   (and (match_code "const_int")
     899                 :      75283 :        (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
     900                 :            : 
     901                 :            : ;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand
     902                 :            : ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
     903                 :      21838 : (define_predicate "const_1_to_63_operand"
     904                 :            :   (and (match_code "const_int")
     905                 :      21838 :        (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
     906                 :            : 
     907                 :            : ;; Match 2 or 3.
     908                 :            : (define_predicate "const_2_to_3_operand"
     909                 :      13276 :   (and (match_code "const_int")
     910                 :      26552 :        (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
     911                 :      13276 : 
     912                 :            : ;; Match 4 to 5.
     913                 :            : (define_predicate "const_4_to_5_operand"
     914                 :       6138 :   (and (match_code "const_int")
     915                 :      12276 :        (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
     916                 :       6138 : 
     917                 :            : ;; Match 4 to 7.
     918                 :            : (define_predicate "const_4_to_7_operand"
     919                 :     216180 :   (and (match_code "const_int")
     920                 :     432360 :        (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
     921                 :     216180 : 
     922                 :            : ;; Match 6 to 7.
     923                 :            : (define_predicate "const_6_to_7_operand"
     924                 :       2540 :   (and (match_code "const_int")
     925                 :       5080 :        (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
     926                 :       2540 : 
     927                 :            : ;; Match 8 to 9.
     928                 :            : (define_predicate "const_8_to_9_operand"
     929                 :        959 :   (and (match_code "const_int")
     930                 :       1918 :        (match_test "IN_RANGE (INTVAL (op), 8, 9)")))
     931                 :        959 : 
     932                 :            : ;; Match 8 to 11.
     933                 :            : (define_predicate "const_8_to_11_operand"
     934                 :      24045 :   (and (match_code "const_int")
     935                 :      48090 :        (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
     936                 :      24045 : 
     937                 :            : ;; Match 8 to 15.
     938                 :            : (define_predicate "const_8_to_15_operand"
     939                 :      28724 :   (and (match_code "const_int")
     940                 :      57448 :        (match_test "IN_RANGE (INTVAL (op), 8, 15)")))
     941                 :      28724 : 
     942                 :            : ;; Match 10 to 11.
     943                 :            : (define_predicate "const_10_to_11_operand"
     944                 :        688 :   (and (match_code "const_int")
     945                 :       1376 :        (match_test "IN_RANGE (INTVAL (op), 10, 11)")))
     946                 :        688 : 
     947                 :            : ;; Match 12 to 13.
     948                 :            : (define_predicate "const_12_to_13_operand"
     949                 :        688 :   (and (match_code "const_int")
     950                 :       1376 :        (match_test "IN_RANGE (INTVAL (op), 12, 13)")))
     951                 :        688 : 
     952                 :            : ;; Match 12 to 15.
     953                 :            : (define_predicate "const_12_to_15_operand"
     954                 :      17268 :   (and (match_code "const_int")
     955                 :      34536 :        (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
     956                 :      17268 : 
     957                 :            : ;; Match 14 to 15.
     958                 :            : (define_predicate "const_14_to_15_operand"
     959                 :        688 :   (and (match_code "const_int")
     960                 :       1376 :        (match_test "IN_RANGE (INTVAL (op), 14, 15)")))
     961                 :        688 : 
     962                 :            : ;; Match 16 to 19.
     963                 :            : (define_predicate "const_16_to_19_operand"
     964                 :        534 :   (and (match_code "const_int")
     965                 :       1068 :        (match_test "IN_RANGE (INTVAL (op), 16, 19)")))
     966                 :        534 : 
     967                 :            : ;; Match 16 to 31.
     968                 :            : (define_predicate "const_16_to_31_operand"
     969                 :       5553 :   (and (match_code "const_int")
     970                 :      11106 :        (match_test "IN_RANGE (INTVAL (op), 16, 31)")))
     971                 :       5553 : 
     972                 :            : ;; Match 20 to 23.
     973                 :            : (define_predicate "const_20_to_23_operand"
     974                 :        304 :   (and (match_code "const_int")
     975                 :        608 :        (match_test "IN_RANGE (INTVAL (op), 20, 23)")))
     976                 :        304 : 
     977                 :            : ;; Match 24 to 27.
     978                 :            : (define_predicate "const_24_to_27_operand"
     979                 :        304 :   (and (match_code "const_int")
     980                 :        608 :        (match_test "IN_RANGE (INTVAL (op), 24, 27)")))
     981                 :        304 : 
     982                 :            : ;; Match 28 to 31.
     983                 :            : (define_predicate "const_28_to_31_operand"
     984                 :        304 :   (and (match_code "const_int")
     985                 :        608 :        (match_test "IN_RANGE (INTVAL (op), 28, 31)")))
     986                 :        304 : 
     987                 :            : ;; True if this is a constant appropriate for an increment or decrement.
     988                 :            : (define_predicate "incdec_operand"
     989                 :            :   (match_code "const_int")
     990                 :            : {
     991                 :            :   /* On Pentium4, the inc and dec operations causes extra dependency on flag
     992                 :            :      registers, since carry flag is not set.  */
     993                 :            :   if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
     994                 :            :     return false;
     995                 :            :   return op == const1_rtx || op == constm1_rtx;
     996                 :            : })
     997                 :            : 
     998                 :            : ;; True for registers, or 1 or -1.  Used to optimize double-word shifts.
     999                 :   79232200 : (define_predicate "reg_or_pm1_operand"
    1000                 :            :   (ior (match_operand 0 "register_operand")
    1001                 :  142548000 :        (and (match_code "const_int")
    1002                 :   63315800 :             (ior (match_test "op == const1_rtx")
    1003                 :     149436 :                  (match_test "op == constm1_rtx")))))
    1004                 :     141199 : 
    1005                 :            : ;; True if OP is acceptable as operand of DImode shift expander.
    1006                 :    1308240 : (define_predicate "shiftdi_operand"
    1007                 :     712836 :   (if_then_else (match_test "TARGET_64BIT")
    1008                 :    1308240 :     (match_operand 0 "nonimmediate_operand")
    1009                 :            :     (match_operand 0 "register_operand")))
    1010                 :     712836 : 
    1011                 :     355265 : (define_predicate "ashldi_input_operand"
    1012                 :     355265 :   (if_then_else (match_test "TARGET_64BIT")
    1013                 :     355265 :     (match_operand 0 "nonimmediate_operand")
    1014                 :            :     (match_operand 0 "reg_or_pm1_operand")))
    1015                 :            : 
    1016                 :            : ;; Return true if OP is a vector load from the constant pool with just
    1017                 :            : ;; the first element nonzero.
    1018                 :            : (define_predicate "zero_extended_scalar_load_operand"
    1019                 :            :   (match_code "mem")
    1020                 :            : {
    1021                 :            :   unsigned n_elts;
    1022                 :            :   op = avoid_constant_pool_reference (op);
    1023                 :            : 
    1024                 :            :   if (GET_CODE (op) != CONST_VECTOR)
    1025                 :            :     return false;
    1026                 :            : 
    1027                 :            :   n_elts = CONST_VECTOR_NUNITS (op);
    1028                 :            : 
    1029                 :            :   for (n_elts--; n_elts > 0; n_elts--)
    1030                 :            :     {
    1031                 :            :       rtx elt = CONST_VECTOR_ELT (op, n_elts);
    1032                 :            :       if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
    1033                 :            :         return false;
    1034                 :            :     }
    1035                 :            :   return true;
    1036                 :            : })
    1037                 :            : 
    1038                 :            : /* Return true if operand is a vector constant that is all ones. */
    1039                 :     275740 : (define_predicate "vector_all_ones_operand"
    1040                 :            :   (and (match_code "const_vector")
    1041                 :    3167290 :        (match_test "INTEGRAL_MODE_P (GET_MODE (op))")
    1042                 :    2311970 :        (match_test "op == CONSTM1_RTX (GET_MODE (op))")))
    1043                 :     121619 : 
    1044                 :            : ; Return true when OP is operand acceptable for vector memory operand.
    1045                 :            : ; Only AVX can have misaligned memory operand.
    1046                 :            : (define_predicate "vector_memory_operand"
    1047                 :   67931650 :   (and (match_operand 0 "memory_operand")
    1048                 :     475976 :        (ior (match_test "TARGET_AVX")
    1049                 :   68407700 :             (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)"))))
    1050                 :            : 
    1051                 :            : ; Return true when OP is register_operand or vector_memory_operand.
    1052                 :            : (define_predicate "vector_operand"
    1053                 :    2608850 :   (ior (match_operand 0 "register_operand")
    1054                 :            :        (match_operand 0 "vector_memory_operand")))
    1055                 :    2608850 : 
    1056                 :            : ;; Return true when OP is either nonimmediate operand, or any
    1057                 :            : ;; CONST_VECTOR.
    1058                 :            : (define_predicate "nonimmediate_or_const_vector_operand"
    1059                 :       9840 :   (ior (match_operand 0 "nonimmediate_operand")
    1060                 :            :        (match_code "const_vector")))
    1061                 :       9840 : 
    1062                 :       1280 : ;; Return true when OP is nonimmediate or standard SSE constant.
    1063                 :            : (define_predicate "nonimmediate_or_sse_const_operand"
    1064                 :            :   (ior (match_operand 0 "nonimmediate_operand")
    1065                 :    4144680 :        (match_test "standard_sse_constant_p (op, mode)")))
    1066                 :     183565 : 
    1067                 :            : ;; Return true if OP is a register or a zero.
    1068                 :   35791700 : (define_predicate "reg_or_0_operand"
    1069                 :            :   (ior (match_operand 0 "register_operand")
    1070                 :      39295 :        (match_operand 0 "const0_operand")))
    1071                 :            : 
    1072                 :      39295 : ; Return true when OP is a nonimmediate or zero.
    1073                 :            : (define_predicate "nonimm_or_0_operand"
    1074                 :            :   (ior (match_operand 0 "nonimmediate_operand")
    1075                 :            :        (match_operand 0 "const0_operand")))
    1076                 :   35248800 : 
    1077                 :            : (define_predicate "norex_memory_operand"
    1078                 :   35248800 :   (and (match_operand 0 "memory_operand")
    1079                 :     142735 :        (not (match_test "x86_extended_reg_mentioned_p (op)"))))
    1080                 :            : 
    1081                 :            : ;; Return true for RTX codes that force SImode address.
    1082                 :     144992 : (define_predicate "SImode_address_operand"
    1083                 :  159598000 :   (match_code "subreg,zero_extend,and"))
    1084                 :     287727 : 
    1085                 :  159598000 : ;; Return true if op is a valid address for LEA, and does not contain
    1086                 :            : ;; a segment override.  Defined as a special predicate to allow
    1087                 :     259640 : ;; mode-less const_int operands pass to address_operand.
    1088                 :     259640 : (define_special_predicate "address_no_seg_operand"
    1089                 :  146859000 :   (match_test "address_operand (op, VOIDmode)")
    1090                 :   56834100 : {
    1091                 :   56834100 :   struct ix86_address parts;
    1092                 :   56834100 :   int ok;
    1093                 :            : 
    1094                 :   57093800 :   if (!CONST_INT_P (op)
    1095                 :   51185800 :       && mode != VOIDmode
    1096                 :   50926100 :       && GET_MODE (op) != mode)
    1097                 :            :     return false;
    1098                 :            : 
    1099                 :  107760000 :   ok = ix86_decompose_address (op, &parts);
    1100                 :   56834100 :   gcc_assert (ok);
    1101                 :   56834100 :   return parts.seg == ADDR_SPACE_GENERIC;
    1102                 :            : })
    1103                 :            : 
    1104                 :            : ;; Return true if op if a valid base register, displacement or
    1105                 :   90025000 : ;; sum of base register and displacement for VSIB addressing.
    1106                 :            : (define_predicate "vsib_address_operand"
    1107                 :   90053400 :   (match_test "address_operand (op, VOIDmode)")
    1108                 :      57322 : {
    1109                 :      27093 :   struct ix86_address parts;
    1110                 :            :   int ok;
    1111                 :            :   rtx disp;
    1112                 :            : 
    1113                 :      14687 :   ok = ix86_decompose_address (op, &parts);
    1114                 :            :   gcc_assert (ok);
    1115                 :      14687 :   if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
    1116                 :      14687 :     return false;
    1117                 :            : 
    1118                 :            :   /* VSIB addressing doesn't support (%rip).  */
    1119                 :            :   if (parts.disp)
    1120                 :            :     {
    1121                 :            :       disp = parts.disp;
    1122                 :            :       if (GET_CODE (disp) == CONST)
    1123                 :            :         {
    1124                 :            :           disp = XEXP (disp, 0);
    1125                 :            :           if (GET_CODE (disp) == PLUS)
    1126                 :            :             disp = XEXP (disp, 0);
    1127                 :            :           if (GET_CODE (disp) == UNSPEC)
    1128                 :            :             switch (XINT (disp, 1))
    1129                 :            :               {
    1130                 :            :               case UNSPEC_GOTPCREL:
    1131                 :            :               case UNSPEC_PCREL:
    1132                 :            :               case UNSPEC_GOTNTPOFF:
    1133                 :            :                 return false;
    1134                 :            :               }
    1135                 :            :         }
    1136                 :            :       if (TARGET_64BIT
    1137                 :            :           && flag_pic
    1138                 :            :           && (GET_CODE (disp) == SYMBOL_REF
    1139                 :            :               || GET_CODE (disp) == LABEL_REF))
    1140                 :            :         return false;
    1141                 :            :     }
    1142                 :            : 
    1143                 :            :   return true;
    1144                 :            : })
    1145                 :            : 
    1146                 :            : (define_predicate "vsib_mem_operator"
    1147                 :      28898 :   (match_code "mem"))
    1148                 :            : 
    1149                 :      28898 : ;; Return true if the rtx is known to be at least 32 bits aligned.
    1150                 :            : (define_predicate "aligned_operand"
    1151                 :            :   (match_operand 0 "general_operand")
    1152                 :            : {
    1153                 :            :   struct ix86_address parts;
    1154                 :            :   int ok;
    1155                 :            : 
    1156                 :            :   /* Registers and immediate operands are always "aligned".  */
    1157                 :            :   if (!MEM_P (op))
    1158                 :            :     return true;
    1159                 :            : 
    1160                 :            :   /* All patterns using aligned_operand on memory operands ends up
    1161                 :            :      in promoting memory operand to 64bit and thus causing memory mismatch.  */
    1162                 :            :   if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
    1163                 :            :     return false;
    1164                 :            : 
    1165                 :            :   /* Don't even try to do any aligned optimizations with volatiles.  */
    1166                 :            :   if (MEM_VOLATILE_P (op))
    1167                 :            :     return false;
    1168                 :            : 
    1169                 :            :   if (MEM_ALIGN (op) >= 32)
    1170                 :            :     return true;
    1171                 :            : 
    1172                 :            :   op = XEXP (op, 0);
    1173                 :            : 
    1174                 :            :   /* Pushes and pops are only valid on the stack pointer.  */
    1175                 :            :   if (GET_CODE (op) == PRE_DEC
    1176                 :            :       || GET_CODE (op) == POST_INC)
    1177                 :            :     return true;
    1178                 :            : 
    1179                 :            :   /* Decode the address.  */
    1180                 :            :   ok = ix86_decompose_address (op, &parts);
    1181                 :            :   gcc_assert (ok);
    1182                 :            : 
    1183                 :            :   if (parts.base && SUBREG_P (parts.base))
    1184                 :            :     parts.base = SUBREG_REG (parts.base);
    1185                 :            :   if (parts.index && SUBREG_P (parts.index))
    1186                 :            :     parts.index = SUBREG_REG (parts.index);
    1187                 :            : 
    1188                 :            :   /* Look for some component that isn't known to be aligned.  */
    1189                 :            :   if (parts.index)
    1190                 :            :     {
    1191                 :            :       if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
    1192                 :            :         return false;
    1193                 :            :     }
    1194                 :            :   if (parts.base)
    1195                 :            :     {
    1196                 :            :       if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
    1197                 :            :         return false;
    1198                 :            :     }
    1199                 :            :   if (parts.disp)
    1200                 :            :     {
    1201                 :            :       if (!CONST_INT_P (parts.disp)
    1202                 :            :           || (INTVAL (parts.disp) & 3))
    1203                 :            :         return false;
    1204                 :            :     }
    1205                 :            : 
    1206                 :            :   /* Didn't find one -- this must be an aligned address.  */
    1207                 :            :   return true;
    1208                 :            : })
    1209                 :            : 
    1210                 :            : ;; Return true if OP is memory operand with a displacement.
    1211                 :   17032000 : (define_predicate "memory_displacement_operand"
    1212                 :            :   (match_operand 0 "memory_operand")
    1213                 :   33843700 : {
    1214                 :   16811700 :   struct ix86_address parts;
    1215                 :            :   int ok;
    1216                 :            : 
    1217                 :            :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1218                 :            :   gcc_assert (ok);
    1219                 :            :   return parts.disp != NULL_RTX;
    1220                 :            : })
    1221                 :            : 
    1222                 :            : ;; Return true if OP is memory operand with a displacement only.
    1223                 :          0 : (define_predicate "memory_displacement_only_operand"
    1224                 :            :   (match_operand 0 "memory_operand")
    1225                 :          0 : {
    1226                 :          0 :   struct ix86_address parts;
    1227                 :            :   int ok;
    1228                 :            : 
    1229                 :            :   if (TARGET_64BIT)
    1230                 :            :     return false;
    1231                 :            : 
    1232                 :            :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1233                 :            :   gcc_assert (ok);
    1234                 :            : 
    1235                 :            :   if (parts.base || parts.index)
    1236                 :            :     return false;
    1237                 :            : 
    1238                 :            :   return parts.disp != NULL_RTX;
    1239                 :            : })
    1240                 :            : 
    1241                 :            : ;; Return true if OP is memory operand that cannot be represented
    1242                 :   53097700 : ;; by the modRM array.
    1243                 :            : (define_predicate "long_memory_operand"
    1244                 :   89351800 :   (and (match_operand 0 "memory_operand")
    1245                 :   36254100 :        (match_test "memory_address_length (op, false)")))
    1246                 :            : 
    1247                 :            : ;; Return true if OP is a comparison operator that can be issued by fcmov.
    1248                 :            : (define_predicate "fcmov_comparison_operator"
    1249                 :      75496 :   (match_operand 0 "comparison_operator")
    1250                 :            : {
    1251                 :          0 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1252                 :      75496 :   enum rtx_code code = GET_CODE (op);
    1253                 :            : 
    1254                 :      75496 :   if (inmode == CCFPmode)
    1255                 :            :     {
    1256                 :       5649 :       if (!ix86_trivial_fp_comparison_operator (op, mode))
    1257                 :            :         return false;
    1258                 :       5511 :       code = ix86_fp_compare_code_to_integer (code);
    1259                 :            :     }
    1260                 :            :   /* i387 supports just limited amount of conditional codes.  */
    1261                 :      75358 :   switch (code)
    1262                 :            :     {
    1263                 :       4547 :     case LTU: case GTU: case LEU: case GEU:
    1264                 :       4547 :       if (inmode == CCmode || inmode == CCFPmode || inmode == CCCmode)
    1265                 :       4547 :         return true;
    1266                 :            :       return false;
    1267                 :            :     case ORDERED: case UNORDERED:
    1268                 :            :     case EQ: case NE:
    1269                 :            :       return true;
    1270                 :        139 :     default:
    1271                 :        139 :       return false;
    1272                 :            :     }
    1273                 :            : })
    1274                 :            : 
    1275                 :            : ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
    1276                 :      75496 : ;; The first set are supported directly; the second set can't be done with
    1277                 :            : ;; full IEEE support, i.e. NaNs.
    1278                 :     150992 : 
    1279                 :      75496 : (define_predicate "sse_comparison_operator"
    1280                 :            :   (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered")
    1281                 :     341484 :        (and (match_test "TARGET_AVX")
    1282                 :     341484 :             (match_code "ge,gt,uneq,unle,unlt,ltgt"))))
    1283                 :     436512 : 
    1284                 :            : (define_predicate "ix86_comparison_int_operator"
    1285                 :     436512 :   (match_code "ne,eq,ge,gt,le,lt"))
    1286                 :     441905 : 
    1287                 :            : (define_predicate "ix86_comparison_uns_operator"
    1288                 :     441905 :   (match_code "ne,eq,geu,gtu,leu,ltu"))
    1289                 :            : 
    1290                 :     441905 : (define_predicate "bt_comparison_operator"
    1291                 :     441905 :   (match_code "ne,eq"))
    1292                 :     441905 : 
    1293                 :     441905 : ;; Return true if OP is a valid comparison operator in valid mode.
    1294                 :     441905 : (define_predicate "ix86_comparison_operator"
    1295                 :     441905 :   (match_operand 0 "comparison_operator")
    1296                 :     441905 : {
    1297                 :   32719300 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1298                 :   32719300 :   enum rtx_code code = GET_CODE (op);
    1299                 :            : 
    1300                 :   33161200 :   if (inmode == CCFPmode)
    1301                 :    4216030 :     return ix86_trivial_fp_comparison_operator (op, mode);
    1302                 :            : 
    1303                 :   28969900 :   switch (code)
    1304                 :            :     {
    1305                 :   21638500 :     case EQ: case NE:
    1306                 :   21302600 :       if (inmode == CCGZmode)
    1307                 :     335847 :         return false;
    1308                 :            :       return true;
    1309                 :    2318420 :     case GE: case LT:
    1310                 :    1982580 :       if (inmode == CCmode || inmode == CCGCmode
    1311                 :    1224900 :           || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
    1312                 :    1673940 :         return true;
    1313                 :     335847 :       return false;
    1314                 :    2187380 :     case GEU: case LTU:
    1315                 :    1851530 :       if (inmode == CCGZmode)
    1316                 :            :         return true;
    1317                 :            :       /* FALLTHRU */
    1318                 :    3208610 :     case GTU: case LEU:
    1319                 :    3208610 :       if (inmode == CCmode || inmode == CCCmode || inmode == CCGZmode)
    1320                 :    3149040 :         return true;
    1321                 :            :       return false;
    1322                 :       1216 :     case ORDERED: case UNORDERED:
    1323                 :       1216 :       if (inmode == CCmode)
    1324                 :       1216 :         return true;
    1325                 :            :       return false;
    1326                 :   12438000 :     case GT: case LE:
    1327                 :    2362610 :       if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
    1328                 :    1945540 :         return true;
    1329                 :    9149010 :       return false;
    1330                 :    9149010 :     default:
    1331                 :            :       return false;
    1332                 :            :     }
    1333                 :            : })
    1334                 :    9149010 : 
    1335                 :    9149010 : ;; Return true if OP is a valid comparison operator
    1336                 :   42205700 : ;; testing carry flag to be set.
    1337                 :            : (define_predicate "ix86_carry_flag_operator"
    1338                 :   74925000 :   (match_code "ltu,lt,unlt,gtu,gt,ungt,le,unle,ge,unge,ltgt,uneq")
    1339                 :   65438700 : {
    1340                 :     837377 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1341                 :     837377 :   enum rtx_code code = GET_CODE (op);
    1342                 :            : 
    1343                 :     837377 :   if (inmode == CCFPmode)
    1344                 :            :     {
    1345                 :     109114 :       if (!ix86_trivial_fp_comparison_operator (op, mode))
    1346                 :            :         return false;
    1347                 :     109114 :       code = ix86_fp_compare_code_to_integer (code);
    1348                 :            :     }
    1349                 :     728263 :   else if (inmode == CCCmode)
    1350                 :       2743 :    return code == LTU || code == GTU;
    1351                 :     725520 :   else if (inmode != CCmode)
    1352                 :            :     return false;
    1353                 :            : 
    1354                 :     190579 :   return code == LTU;
    1355                 :            : })
    1356                 :            : 
    1357                 :            : ;; Return true if this comparison only requires testing one flag bit.
    1358                 :    1698530 : (define_predicate "ix86_trivial_fp_comparison_operator"
    1359                 :            :   (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered"))
    1360                 :    1698530 : 
    1361                 :            : ;; Return true if we know how to do this comparison.  Others require
    1362                 :     837377 : ;; testing more than one flag bit, and we let the generic middle-end
    1363                 :     837377 : ;; code do that.
    1364                 :     837377 : (define_predicate "ix86_fp_comparison_operator"
    1365                 :    3818590 :   (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
    1366                 :    2981210 :                              == IX86_FPCMP_ARITH")
    1367                 :     837377 :                (match_operand 0 "comparison_operator")
    1368                 :     837377 :                (match_operand 0 "ix86_trivial_fp_comparison_operator")))
    1369                 :     837377 : 
    1370                 :    2436810 : ;; Nearly general operand, but accept any const_double, since we wish
    1371                 :     837377 : ;; to be able to drop them into memory rather than have them get pulled
    1372                 :     451729 : ;; into registers.
    1373                 :    2051160 : (define_predicate "cmp_fp_expander_operand"
    1374                 :     837377 :   (ior (match_code "const_double")
    1375                 :            :        (match_operand 0 "general_operand")))
    1376                 :            : 
    1377                 :    1067460 : ;; Return true if this is a valid binary floating-point operation.
    1378                 :     837377 : (define_predicate "binary_fp_operator"
    1379                 :    1904840 :   (match_code "plus,minus,mult,div"))
    1380                 :     837377 : 
    1381                 :    1065360 : ;; Return true if this is a multiply operation.
    1382                 :    1065360 : (define_predicate "mult_operator"
    1383                 :    1065360 :   (match_code "mult"))
    1384                 :    7910800 : 
    1385                 :    1065360 : ;; Return true if this is a division operation.
    1386                 :    6845440 : (define_predicate "div_operator"
    1387                 :            :   (match_code "div"))
    1388                 :    5159720 : 
    1389                 :    6225080 : ;; Return true if this is a plus, minus, and, ior or xor operation.
    1390                 :    1065360 : (define_predicate "plusminuslogic_operator"
    1391                 :    5159720 :   (match_code "plus,minus,and,ior,xor"))
    1392                 :    5159720 : 
    1393                 :    5159720 : ;; Return true for ARITHMETIC_P.
    1394                 :   12709700 : (define_predicate "arith_or_logical_operator"
    1395                 :    5159720 :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
    1396                 :    7550020 :                mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
    1397                 :    3728570 : 
    1398                 :            : ;; Return true for COMMUTATIVE_P.
    1399                 :            : (define_predicate "commutative_operator"
    1400                 :    5159720 :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
    1401                 :    5159720 : 
    1402                 :            : ;; Return true if OP is a binary operator that can be promoted to wider mode.
    1403                 :    2241920 : (define_predicate "promotable_binary_operator"
    1404                 :     548796 :   (ior (match_code "plus,minus,and,ior,xor,ashift")
    1405                 :    2981210 :        (and (match_code "mult")
    1406                 :   15195100 :             (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
    1407                 :    2981210 : 
    1408                 :     277790 : (define_predicate "compare_operator"
    1409                 :            :   (match_code "compare"))
    1410                 :     277790 : 
    1411                 :   25920600 : ;; Return true if OP is a memory operand, aligned to
    1412                 :     240607 : ;; less than its natural alignment.
    1413                 :   25920600 : (define_predicate "misaligned_operand"
    1414                 :          0 :   (and (match_code "mem")
    1415                 :    3169970 :        (match_test "MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)")))
    1416                 :    1158340 : 
    1417                 :     240607 : ;; Return true if OP is a vzeroall operation, known to be a PARALLEL.
    1418                 :    3391550 : (define_predicate "vzeroall_operation"
    1419                 :            :   (match_code "parallel")
    1420                 :    5403180 : {
    1421                 :     240607 :   unsigned i, nregs = TARGET_64BIT ? 16 : 8;
    1422                 :     254892 : 
    1423                 :            :   if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
    1424                 :            :     return false;
    1425                 :            : 
    1426                 :    2834450 :   for (i = 0; i < nregs; i++)
    1427                 :            :     {
    1428                 :    2834450 :       rtx elt = XVECEXP (op, 0, i+1);
    1429                 :            : 
    1430                 :    2834450 :       if (GET_CODE (elt) != SET
    1431                 :    2834450 :           || GET_CODE (SET_DEST (elt)) != REG
    1432                 :    2834450 :           || GET_MODE (SET_DEST (elt)) != V8SImode
    1433                 :    2834450 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    1434                 :    2834450 :           || SET_SRC (elt) != CONST0_RTX (V8SImode))
    1435                 :    2834450 :         return false;
    1436                 :    2834450 :     }
    1437                 :    2834450 :   return true;
    1438                 :    2834450 : })
    1439                 :    2834450 : 
    1440                 :    2834450 : ;; return true if OP is a vzeroall pattern.
    1441                 :    2834520 : (define_predicate "vzeroall_pattern"
    1442                 :    2834450 :   (and (match_code "parallel")
    1443                 :    2834590 :        (match_code "unspec_volatile" "a")
    1444                 :        130 :        (match_test "XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROALL")))
    1445                 :          0 : 
    1446                 :    2834450 : ;; return true if OP is a vzeroupper pattern.
    1447                 :    2834450 : (define_predicate "vzeroupper_pattern"
    1448                 :    2834450 :   (and (match_code "parallel")
    1449                 :   29273810 :        (match_code "unspec_volatile" "a")
    1450                 :      32365 :        (match_test "XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROUPPER")))
    1451                 :   26439400 : 
    1452                 :            : ;; Return true if OP is an addsub vec_merge operation
    1453                 :            : (define_predicate "addsub_vm_operator"
    1454                 :    2834450 :   (match_code "vec_merge")
    1455                 :    2834450 : {
    1456                 :        992 :   rtx op0, op1;
    1457                 :        992 :   int swapped;
    1458                 :        992 :   HOST_WIDE_INT mask;
    1459                 :     213191 :   int nunits, elt;
    1460                 :            : 
    1461                 :     212199 :   op0 = XEXP (op, 0);
    1462                 :        992 :   op1 = XEXP (op, 1);
    1463                 :     141573 : 
    1464                 :     141573 :   /* Sanity check.  */
    1465                 :        992 :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1466                 :     141573 :     swapped = 0;
    1467                 :        111 :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1468                 :     141573 :     swapped = 1;
    1469                 :     141573 :   else
    1470                 :          0 :     gcc_unreachable ();
    1471                 :     141573 : 
    1472                 :     142565 :   mask = INTVAL (XEXP (op, 2));
    1473                 :        992 :   nunits = GET_MODE_NUNITS (mode);
    1474                 :            : 
    1475                 :       3226 :   for (elt = 0; elt < nunits; elt++)
    1476                 :     141573 :     {
    1477                 :     141573 :       /* bit clear: take from op0, set: take from op1  */
    1478                 :       2460 :       int bit = !(mask & (HOST_WIDE_INT_1U << elt));
    1479                 :            : 
    1480                 :       2460 :       if (bit != ((elt & 1) ^ swapped))
    1481                 :   15195100 :         return false;
    1482                 :            :     }
    1483                 :   15195100 : 
    1484                 :            :   return true;
    1485                 :            : })
    1486                 :            : 
    1487                 :            : ;; Return true if OP is an addsub vec_select/vec_concat operation
    1488                 :        992 : (define_predicate "addsub_vs_operator"
    1489                 :            :   (and (match_code "vec_select")
    1490                 :        992 :        (match_code "vec_concat" "0"))
    1491                 :       1758 : {
    1492                 :        766 :   rtx op0, op1;
    1493                 :            :   bool swapped;
    1494                 :            :   int nunits, elt;
    1495                 :            : 
    1496                 :            :   op0 = XEXP (XEXP (op, 0), 0);
    1497                 :            :   op1 = XEXP (XEXP (op, 0), 1);
    1498                 :            : 
    1499                 :            :   /* Sanity check.  */
    1500                 :            :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1501                 :            :     swapped = false;
    1502                 :            :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1503                 :            :     swapped = true;
    1504                 :            :   else
    1505                 :            :     gcc_unreachable ();
    1506                 :            : 
    1507                 :            :   nunits = GET_MODE_NUNITS (mode);
    1508                 :            :   if (XVECLEN (XEXP (op, 1), 0) != nunits)
    1509                 :            :     return false;
    1510                 :            : 
    1511                 :            :   /* We already checked that permutation is suitable for addsub,
    1512                 :            :      so only look at the first element of the parallel.  */
    1513                 :            :   elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
    1514                 :            : 
    1515                 :            :   return elt == (swapped ? nunits : 0);
    1516                 :            : })
    1517                 :            : 
    1518                 :            : ;; Return true if OP is a parallel for an addsub vec_select.
    1519                 :        158 : (define_predicate "addsub_vs_parallel"
    1520                 :            :   (and (match_code "parallel")
    1521                 :        316 :        (match_code "const_int" "a"))
    1522                 :        322 : {
    1523                 :          6 :   int nelt = XVECLEN (op, 0);
    1524                 :            :   int elt, i;
    1525                 :            :   
    1526                 :            :   if (nelt < 2)
    1527                 :            :     return false;
    1528                 :            : 
    1529                 :            :   /* Check that the permutation is suitable for addsub.
    1530                 :            :      For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }.  */
    1531                 :            :   elt = INTVAL (XVECEXP (op, 0, 0));
    1532                 :            :   if (elt == 0)
    1533                 :            :     {
    1534                 :            :       for (i = 1; i < nelt; ++i)
    1535                 :            :         if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
    1536                 :            :           return false;
    1537                 :            :     }
    1538                 :            :   else if (elt == nelt)
    1539                 :            :     {
    1540                 :            :       for (i = 1; i < nelt; ++i)
    1541                 :            :         if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
    1542                 :            :           return false;
    1543                 :            :     }
    1544                 :            :   else
    1545                 :            :     return false;
    1546                 :            : 
    1547                 :            :   return true;
    1548                 :            : })
    1549                 :            : 
    1550                 :            : ;; Return true if OP is a parallel for a vbroadcast permute.
    1551                 :        164 : (define_predicate "avx_vbroadcast_operand"
    1552                 :            :   (and (match_code "parallel")
    1553                 :        164 :        (match_code "const_int" "a"))
    1554                 :        328 : {
    1555                 :          0 :   rtx elt = XVECEXP (op, 0, 0);
    1556                 :     244683 :   int i, nelt = XVECLEN (op, 0);
    1557                 :            : 
    1558                 :            :   /* Don't bother checking there are the right number of operands,
    1559                 :     244683 :      merely that they're all identical.  */
    1560                 :     312228 :   for (i = 1; i < nelt; ++i)
    1561                 :     187669 :     if (XVECEXP (op, 0, i) != elt)
    1562                 :            :       return false;
    1563                 :            :   return true;
    1564                 :            : })
    1565                 :            : 
    1566                 :            : ;; Return true if OP is a parallel for a palignr permute.
    1567                 :     244683 : (define_predicate "palignr_operand"
    1568                 :            :   (and (match_code "parallel")
    1569                 :     244683 :        (match_code "const_int" "a"))
    1570                 :     734049 : {
    1571                 :          0 :   int elt = INTVAL (XVECEXP (op, 0, 0));
    1572                 :       3862 :   int i, nelt = XVECLEN (op, 0);
    1573                 :            : 
    1574                 :            :   /* Check that an order in the permutation is suitable for palignr.
    1575                 :       3862 :      For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm".  */
    1576                 :       5517 :   for (i = 1; i < nelt; ++i)
    1577                 :       5268 :     if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
    1578                 :            :       return false;
    1579                 :            :   return true;
    1580                 :            : })
    1581                 :            : 
    1582                 :            : ;; Return true if OP is a proper third operand to vpblendw256.
    1583                 :       3862 : (define_predicate "avx2_pblendw_operand"
    1584                 :            :   (match_code "const_int")
    1585                 :       3862 : {
    1586                 :      11586 :   HOST_WIDE_INT val = INTVAL (op);
    1587                 :          0 :   HOST_WIDE_INT low = val & 0xff;
    1588                 :         60 :   return val == ((low << 8) | low);
    1589                 :            : })
    1590                 :            : 
    1591                 :         60 : ;; Return true if OP is vector_operand or CONST_VECTOR.
    1592                 :         60 : (define_predicate "general_vector_operand"
    1593                 :            :   (ior (match_operand 0 "vector_operand")
    1594                 :         60 :        (match_code "const_vector")))
    1595                 :         60 : 
    1596                 :            : ;; Return true if OP is either -1 constant or stored in register.
    1597                 :            : (define_predicate "register_or_constm1_operand"
    1598                 :            :   (ior (match_operand 0 "register_operand")
    1599                 :       6998 :        (and (match_code "const_int")
    1600                 :          0 :             (match_test "op == constm1_rtx"))))
    1601                 :       6998 : 
    1602                 :       1179 : ;; Return true if the vector ends with between 12 and 18 register saves using
    1603                 :            : ;; RAX as the base address.
    1604                 :            : (define_predicate "save_multiple"
    1605                 :            :   (match_code "parallel")
    1606                 :          0 : {
    1607                 :            :   const unsigned len = XVECLEN (op, 0);
    1608                 :          0 :   unsigned i;
    1609                 :            : 
    1610                 :            :   /* Starting from end of vector, count register saves.  */
    1611                 :            :   for (i = 0; i < len; ++i)
    1612                 :            :     {
    1613                 :            :       rtx src, dest, addr;
    1614                 :            :       rtx e = XVECEXP (op, 0, len - 1 - i);
    1615                 :            : 
    1616                 :            :       if (GET_CODE (e) != SET)
    1617                 :            :         break;
    1618                 :            : 
    1619                 :            :       src  = SET_SRC (e);
    1620                 :            :       dest = SET_DEST (e);
    1621                 :            : 
    1622                 :            :       if (!REG_P (src) || !MEM_P (dest))
    1623                 :            :         break;
    1624                 :            : 
    1625                 :            :       addr = XEXP (dest, 0);
    1626                 :            : 
    1627                 :            :       /* Good if dest address is in RAX.  */
    1628                 :            :       if (REG_P (addr) && REGNO (addr) == AX_REG)
    1629                 :            :         continue;
    1630                 :            : 
    1631                 :            :       /* Good if dest address is offset of RAX.  */
    1632                 :            :       if (GET_CODE (addr) == PLUS
    1633                 :            :           && REG_P (XEXP (addr, 0))
    1634                 :            :           && REGNO (XEXP (addr, 0)) == AX_REG)
    1635                 :            :         continue;
    1636                 :            : 
    1637                 :            :       break;
    1638                 :            :     }
    1639                 :            :   return (i >= 12 && i <= 18);
    1640                 :            : })
    1641                 :            : 
    1642                 :            : 
    1643                 :     168668 : ;; Return true if the vector ends with between 12 and 18 register loads using
    1644                 :            : ;; RSI as the base address.
    1645                 :     337336 : (define_predicate "restore_multiple"
    1646                 :     168668 :   (match_code "parallel")
    1647                 :          0 : {
    1648                 :            :   const unsigned len = XVECLEN (op, 0);
    1649                 :            :   unsigned i;
    1650                 :            : 
    1651                 :            :   /* Starting from end of vector, count register restores.  */
    1652                 :            :   for (i = 0; i < len; ++i)
    1653                 :            :     {
    1654                 :            :       rtx src, dest, addr;
    1655                 :            :       rtx e = XVECEXP (op, 0, len - 1 - i);
    1656                 :            : 
    1657                 :            :       if (GET_CODE (e) != SET)
    1658                 :            :         break;
    1659                 :            : 
    1660                 :            :       src  = SET_SRC (e);
    1661                 :            :       dest = SET_DEST (e);
    1662                 :            : 
    1663                 :            :       if (!MEM_P (src) || !REG_P (dest))
    1664                 :            :         break;
    1665                 :            : 
    1666                 :            :       addr = XEXP (src, 0);
    1667                 :            : 
    1668                 :            :       /* Good if src address is in RSI.  */
    1669                 :            :       if (REG_P (addr) && REGNO (addr) == SI_REG)
    1670                 :            :         continue;
    1671                 :            : 
    1672                 :            :       /* Good if src address is offset of RSI.  */
    1673                 :            :       if (GET_CODE (addr) == PLUS
    1674                 :            :           && REG_P (XEXP (addr, 0))
    1675                 :            :           && REGNO (XEXP (addr, 0)) == SI_REG)
    1676                 :            :         continue;
    1677                 :            : 
    1678                 :            :       break;
    1679                 :            :     }
    1680                 :            :   return (i >= 12 && i <= 18);
    1681                 :            : })

Generated by: LCOV version 1.0

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