LCOV - code coverage report
Current view: top level - gcc/config/i386 - predicates.md (source / functions) Coverage Total Hit
Test: gcc.info Lines: 86.6 % 1427 1236
Test Date: 2025-06-21 16:26:05 Functions: 95.4 % 241 230
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-2025 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                 :   129545344 :        (match_test "ANY_FP_REGNO_P (REGNO (op))")))
      24                 :       40460 : 
      25                 :             : ;; Return true if OP is an i387 fp register.
      26                 :             : (define_predicate "fp_register_operand"
      27                 :             :   (and (match_code "reg")
      28                 :     1598355 :        (match_test "STACK_REGNO_P (REGNO (op))")))
      29                 :     1511991 : 
      30                 :   426366315 : ;; True if the operand is a GENERAL class register.
      31                 :             : (define_predicate "general_reg_operand"
      32                 :             :   (and (match_code "reg")
      33                 :   267393228 :        (match_test "GENERAL_REGNO_P (REGNO (op))")))
      34                 :   201017224 : 
      35                 :   444313887 : ;; True if the operand is an INDEX class register.
      36                 :             : (define_predicate "index_reg_operand"
      37                 :             :   (and (match_code "reg")
      38                 :      625874 :        (match_test "INDEX_REGNO_P (REGNO (op))")))
      39                 :      625791 : 
      40                 :      626347 : ;; True if the operand is a nonimmediate operand with GENERAL class register.
      41                 :             : (define_predicate "nonimmediate_gr_operand"
      42                 :             :   (if_then_else (match_code "reg")
      43                 :    55574542 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      44                 :    61388116 :     (match_operand 0 "nonimmediate_operand")))
      45                 :    76975072 : 
      46                 :             : ;; True if the operand is a general operand with GENERAL class register.
      47                 :             : (define_predicate "general_gr_operand"
      48                 :    89778065 :   (if_then_else (match_code "reg")
      49                 :    38859743 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      50                 :   113731983 :     (match_operand 0 "general_operand")))
      51                 :             : 
      52                 :             : ;; True if the operand is an MMX register.
      53                 :             : (define_predicate "mmx_reg_operand"
      54                 :    38645698 :   (and (match_code "reg")
      55                 :         189 :        (match_test "MMX_REGNO_P (REGNO (op))")))
      56                 :    38645698 : 
      57                 :             : ;; Match register operands, but include memory operands for
      58                 :             : ;; !TARGET_MMX_WITH_SSE.
      59                 :             : (define_predicate "register_mmxmem_operand"
      60                 :      514945 :   (ior (match_operand 0 "register_operand")
      61                 :          15 :        (and (not (match_test "TARGET_MMX_WITH_SSE"))
      62                 :      514945 :             (match_operand 0 "memory_operand"))))
      63                 :             : 
      64                 :             : ;; True if the operand is an SSE register.
      65                 :   155450085 : (define_predicate "sse_reg_operand"
      66                 :             :   (and (match_code "reg")
      67                 :   155450085 :        (match_test "SSE_REGNO_P (REGNO (op))")))
      68                 :     1773116 : 
      69                 :             : ;; Return true if op is a QImode register.
      70                 :             : (define_predicate "any_QIreg_operand"
      71                 :             :   (and (match_code "reg")
      72                 :     2471836 :        (match_test "ANY_QI_REGNO_P (REGNO (op))")))
      73                 :      847977 : 
      74                 :     2497157 : ;; Return true if op is one of QImode registers: %[abcd][hl].
      75                 :             : (define_predicate "QIreg_operand"
      76                 :             :   (and (match_code "reg")
      77                 :      866580 :        (match_test "QI_REGNO_P (REGNO (op))")))
      78                 :      683967 : 
      79                 :     1773961 : ;; Return true if op is a QImode register operand other than %[abcd][hl].
      80                 :             : (define_predicate "ext_QIreg_operand"
      81                 :     3398447 :   (and (match_test "TARGET_64BIT")
      82                 :     3398817 :        (match_code "reg")
      83                 :      941964 :        (not (match_test "QI_REGNO_P (REGNO (op))"))))
      84                 :     3648775 : 
      85                 :             : ;; Return true if op is the AX register.
      86                 :             : (define_predicate "ax_reg_operand"
      87                 :             :   (and (match_code "reg")
      88                 :    22346501 :        (match_test "REGNO (op) == AX_REG")))
      89                 :           0 : 
      90                 :   113396501 : ;; Return true if op is the flags register.
      91                 :             : (define_special_predicate "flags_reg_operand"
      92                 :             :   (and (match_code "reg")
      93                 :   112769746 :        (match_test "REGNO (op) == FLAGS_REG")))
      94                 :             : 
      95                 :    40558857 : ;; True if the operand is a MASK register.
      96                 :             : (define_predicate "mask_reg_operand"
      97                 :    10089437 :   (and (match_code "reg")
      98                 :        3589 :        (match_test "MASK_REGNO_P (REGNO (op))")))
      99                 :    10093026 : 
     100                 :             : ;; Match a DI, SI or HImode register operand.
     101                 :             : (define_special_predicate "int248_register_operand"
     102                 :             :   (and (match_operand 0 "register_operand")
     103                 :      605441 :        (ior (and (match_test "TARGET_64BIT")
     104                 :      181969 :                  (match_test "GET_MODE (op) == DImode"))
     105                 :      390111 :             (match_test "GET_MODE (op) == SImode")
     106                 :      221245 :             (match_test "GET_MODE (op) == HImode"))))
     107                 :             : 
     108                 :             : ;; Match a DI, SI, HI or QImode nonimmediate_operand.
     109                 :             : (define_special_predicate "int_nonimmediate_operand"
     110                 :      465447 :   (and (match_operand 0 "nonimmediate_operand")
     111                 :      625569 :        (ior (and (match_test "TARGET_64BIT")
     112                 :      465447 :                  (match_test "GET_MODE (op) == DImode"))
     113                 :      224157 :             (match_test "GET_MODE (op) == SImode")
     114                 :             :             (match_test "GET_MODE (op) == HImode")
     115                 :      465447 :             (match_test "GET_MODE (op) == QImode"))))
     116                 :             : 
     117                 :             : ;; Match register operands, but include memory operands for TARGET_SSE_MATH.
     118                 :             : (define_predicate "register_ssemem_operand"
     119                 :     2822904 :   (if_then_else
     120                 :     2822904 :     (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     121                 :     2822904 :     (match_operand 0 "nonimmediate_operand")
     122                 :             :     (match_operand 0 "register_operand")))
     123                 :             : 
     124                 :     1078375 : ;; Match nonimmediate operands, but exclude memory operands
     125                 :             : ;; for TARGET_SSE_MATH if TARGET_MIX_SSE_I387 is not enabled.
     126                 :     1078375 : (define_predicate "nonimm_ssenomem_operand"
     127                 :             :   (if_then_else
     128                 :     1078375 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     129                 :     2156750 :          (not (match_test "TARGET_MIX_SSE_I387")))
     130                 :             :     (match_operand 0 "register_operand")
     131                 :             :     (match_operand 0 "nonimmediate_operand")))
     132                 :             : 
     133                 :      733678 : ;; The above predicate, suitable for x87 arithmetic operators.
     134                 :             : (define_predicate "x87nonimm_ssenomem_operand"
     135                 :      733678 :   (if_then_else
     136                 :      733678 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     137                 :     1467356 :          (not (match_test "TARGET_MIX_SSE_I387 && X87_ENABLE_ARITH (mode)")))
     138                 :             :     (match_operand 0 "register_operand")
     139                 :             :     (match_operand 0 "nonimmediate_operand")))
     140                 :             : 
     141                 :       34360 : ;; Match register operands, include memory operand for TARGET_SSE4_1.
     142                 :             : (define_predicate "register_sse4nonimm_operand"
     143                 :       34360 :   (if_then_else (match_test "TARGET_SSE4_1")
     144                 :             :     (match_operand 0 "nonimmediate_operand")
     145                 :             :     (match_operand 0 "register_operand")))
     146                 :             : 
     147                 :       14090 : ;; Return true if VALUE is symbol reference
     148                 :             : (define_predicate "symbol_operand"
     149                 :       14090 :   (match_code "symbol_ref"))
     150                 :       14090 : 
     151                 :             : ;; Return true if VALUE is an ENDBR opcode in immediate field.
     152                 :             : (define_predicate "ix86_endbr_immediate_operand"
     153                 :             :   (match_code "const_int")
     154                 :  6342905578 : {
     155                 :  6342905578 :   if (flag_cf_protection & CF_BRANCH)
     156                 :             :      {
     157                 :  1227475938 :        unsigned HOST_WIDE_INT imm = UINTVAL (op);
     158                 :  1227475938 :        unsigned HOST_WIDE_INT val = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
     159                 :             : 
     160                 :  1227475938 :        if (imm == val)
     161                 :             :          return true;
     162                 :             : 
     163                 :             :        /* NB: Encoding is byte based.  */
     164                 :  1227475730 :        if (TARGET_64BIT)
     165                 :  2345834553 :          for (; imm >= val; imm >>= 8)
     166                 :  1306794851 :            if (imm == val)
     167                 :             :              return true;
     168                 :             :       }
     169                 :             : 
     170                 :             :   return false;
     171                 :             : })
     172                 :             : 
     173                 :             : ;; Return true if VALUE can be stored in a sign extended immediate field.
     174                 :  8170985374 : (define_predicate "x86_64_immediate_operand"
     175                 :             :   (match_code "const_int,symbol_ref,label_ref,const")
     176                 :  8170985374 : {
     177                 : 11220943235 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     178                 :             :     return false;
     179                 :             : 
     180                 :  4878037406 :   if (!TARGET_64BIT)
     181                 :  5063511543 :     return immediate_operand (op, mode);
     182                 :             : 
     183                 :  4692563520 :   switch (GET_CODE (op))
     184                 :             :     {
     185                 :  3854577828 :     case CONST_INT:
     186                 :  3854577828 :       {
     187                 :  3854577828 :         HOST_WIDE_INT val = INTVAL (op);
     188                 :  3854577828 :         return trunc_int_for_mode (val, SImode) == val;
     189                 :             :       }
     190                 :   683216808 :     case SYMBOL_REF:
     191                 :             :       /* TLS symbols are not constant.  */
     192                 :   683216808 :       if (SYMBOL_REF_TLS_MODEL (op))
     193                 :             :         return false;
     194                 :             : 
     195                 :             :       /* Load the external function address via the GOT slot.  */
     196                 :   683178060 :       if (ix86_force_load_from_GOT_p (op))
     197                 :             :         return false;
     198                 :             : 
     199                 :             :       /* For certain code models, the symbolic references are known to fit.
     200                 :             :          in CM_SMALL_PIC model we know it fits if it is local to the shared
     201                 :             :          library.  Don't count TLS SYMBOL_REFs here, since they should fit
     202                 :             :          only if inside of UNSPEC handled below.  */
     203                 :   683177958 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
     204                 :   683177958 :               || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
     205                 :             : 
     206                 :    21612042 :     case LABEL_REF:
     207                 :             :       /* For certain code models, the code is near as well.  */
     208                 :    21612042 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
     209                 :             :               || ix86_cmodel == CM_KERNEL);
     210                 :             : 
     211                 :   133156842 :     case CONST:
     212                 :             :       /* We also may accept the offsetted memory references in certain
     213                 :             :          special cases.  */
     214                 :   133156842 :       if (GET_CODE (XEXP (op, 0)) == UNSPEC)
     215                 :      707334 :         switch (XINT (XEXP (op, 0), 1))
     216                 :             :           {
     217                 :             :           case UNSPEC_GOTPCREL:
     218                 :             :           case UNSPEC_DTPOFF:
     219                 :             :           case UNSPEC_GOTNTPOFF:
     220                 :             :           case UNSPEC_NTPOFF:
     221                 :             :           case UNSPEC_SECREL32:
     222                 :             :             return true;
     223                 :             :           default:
     224                 :             :             break;
     225                 :             :           }
     226                 :             : 
     227                 :   132450554 :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     228                 :             :         {
     229                 :   132449508 :           rtx op1 = XEXP (XEXP (op, 0), 0);
     230                 :   132449508 :           rtx op2 = XEXP (XEXP (op, 0), 1);
     231                 :             : 
     232                 :   132449508 :           if (ix86_cmodel == CM_LARGE && GET_CODE (op1) != UNSPEC)
     233                 :             :             return false;
     234                 :   132449503 :           if (!CONST_INT_P (op2))
     235                 :             :             return false;
     236                 :             : 
     237                 :   132449503 :           HOST_WIDE_INT offset = INTVAL (op2);
     238                 :   132449503 :           if (trunc_int_for_mode (offset, SImode) != offset)
     239                 :             :             return false;
     240                 :             : 
     241                 :   132443846 :           switch (GET_CODE (op1))
     242                 :             :             {
     243                 :   132119539 :             case SYMBOL_REF:
     244                 :             :               /* TLS symbols are not constant.  */
     245                 :   132119539 :               if (SYMBOL_REF_TLS_MODEL (op1))
     246                 :             :                 return false;
     247                 :             : 
     248                 :             :               /* Load the external function address via the GOT slot.  */
     249                 :   132107985 :               if (ix86_force_load_from_GOT_p (op1))
     250                 :             :                 return false;
     251                 :             : 
     252                 :             :               /* For CM_SMALL assume that latest object is 16MB before
     253                 :             :                  end of 31bits boundary.  We may also accept pretty
     254                 :             :                  large negative constants knowing that all objects are
     255                 :             :                  in the positive half of address space.  */
     256                 :   132107979 :               if ((ix86_cmodel == CM_SMALL
     257                 :      192757 :                    || (ix86_cmodel == CM_MEDIUM
     258                 :           0 :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     259                 :   132107979 :                   && offset < 16*1024*1024)
     260                 :             :                 return true;
     261                 :             :               /* For CM_KERNEL we know that all object resist in the
     262                 :             :                  negative half of 32bits address space.  We may not
     263                 :             :                  accept negative offsets, since they may be just off
     264                 :             :                  and we may accept pretty large positive ones.  */
     265                 :      195369 :               if (ix86_cmodel == CM_KERNEL
     266                 :           0 :                   && offset > 0)
     267                 :             :                 return true;
     268                 :             :               break;
     269                 :             : 
     270                 :        3736 :             case LABEL_REF:
     271                 :             :               /* These conditions are similar to SYMBOL_REF ones, just the
     272                 :             :                  constraints for code models differ.  */
     273                 :        3736 :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     274                 :        3736 :                   && offset < 16*1024*1024)
     275                 :             :                 return true;
     276                 :           0 :               if (ix86_cmodel == CM_KERNEL
     277                 :           0 :                   && offset > 0)
     278                 :             :                 return true;
     279                 :             :               break;
     280                 :             : 
     281                 :      320571 :             case UNSPEC:
     282                 :      320571 :               switch (XINT (op1, 1))
     283                 :             :                 {
     284                 :             :                 case UNSPEC_DTPOFF:
     285                 :             :                 case UNSPEC_NTPOFF:
     286                 :             :                   return true;
     287                 :             :                 }
     288                 :             :               break;
     289                 :             : 
     290                 :             :             default:
     291                 :             :               break;
     292                 :             :             }
     293                 :             :         }
     294                 :             :       break;
     295                 :             : 
     296                 :           0 :       default:
     297                 :           0 :         gcc_unreachable ();
     298                 :             :     }
     299                 :             : 
     300                 :             :   return false;
     301                 :             : })
     302                 :             : 
     303                 :             : ;; Return true if VALUE can be stored in the zero extended immediate field.
     304                 :  5353634594 : (define_predicate "x86_64_zext_immediate_operand"
     305                 :             :   (match_code "const_int,symbol_ref,label_ref,const")
     306                 :  5353634594 : {
     307                 :   721082563 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     308                 :  4878037657 :     return false;
     309                 :  4878037657 : 
     310                 :   721082415 :   switch (GET_CODE (op))
     311                 :  4878037657 :     {
     312                 :  5533825609 :     case CONST_INT:
     313                 :   655787952 :       return !(INTVAL (op) & ~HOST_WIDE_INT_C (0xffffffff));
     314                 :             : 
     315                 :    59091693 :     case SYMBOL_REF:
     316                 :  4878037657 :       /* TLS symbols are not constant.  */
     317                 :  4937129350 :       if (SYMBOL_REF_TLS_MODEL (op))
     318                 :   265923283 :         return false;
     319                 :             : 
     320                 :             :       /* Load the external function address via the GOT slot.  */
     321                 :    59053806 :       if (ix86_force_load_from_GOT_p (op))
     322                 :   721082563 :         return false;
     323                 :             : 
     324                 :             :      /* For certain code models, the symbolic references are known to fit.  */
     325                 :    59053705 :       return (ix86_cmodel == CM_SMALL
     326                 :    59053705 :               || (ix86_cmodel == CM_MEDIUM
     327                 :         219 :                   && !SYMBOL_REF_FAR_ADDR_P (op)));
     328                 :             : 
     329                 :     1895041 :     case LABEL_REF:
     330                 :             :       /* For certain code models, the code is near as well.  */
     331                 :     1895041 :       return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
     332                 :             : 
     333                 :     4307729 :     case CONST:
     334                 :             :       /* We also may accept the offsetted memory references in certain
     335                 :             :          special cases.  */
     336                 :     4307729 :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     337                 :             :         {
     338                 :     4303408 :           rtx op1 = XEXP (XEXP (op, 0), 0);
     339                 :     4303408 :           rtx op2 = XEXP (XEXP (op, 0), 1);
     340                 :             : 
     341                 :     4303408 :           if (ix86_cmodel == CM_LARGE)
     342                 :             :             return false;
     343                 :     4303406 :           if (!CONST_INT_P (op2))
     344                 :             :             return false;
     345                 :             : 
     346                 :     4303406 :           HOST_WIDE_INT offset = INTVAL (op2);
     347                 :     4303406 :           if (trunc_int_for_mode (offset, SImode) != offset)
     348                 :             :             return false;
     349                 :             : 
     350                 :     4300361 :           switch (GET_CODE (op1))
     351                 :             :             {
     352                 :     4299863 :             case SYMBOL_REF:
     353                 :             :               /* TLS symbols are not constant.  */
     354                 :     4299863 :               if (SYMBOL_REF_TLS_MODEL (op1))
     355                 :             :                 return false;
     356                 :             : 
     357                 :             :               /* Load the external function address via the GOT slot.  */
     358                 :     4289537 :               if (ix86_force_load_from_GOT_p (op1))
     359                 :             :                 return false;
     360                 :             : 
     361                 :             :               /* For small code model we may accept pretty large positive
     362                 :             :                  offsets, since one bit is available for free.  Negative
     363                 :             :                  offsets are limited by the size of NULL pointer area
     364                 :             :                  specified by the ABI.  */
     365                 :     4289531 :               if ((ix86_cmodel == CM_SMALL
     366                 :      162874 :                    || (ix86_cmodel == CM_MEDIUM
     367                 :           0 :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     368                 :     4289531 :                   && offset > -0x10000)
     369                 :             :                 return true;
     370                 :             :               /* ??? For the kernel, we may accept adjustment of
     371                 :             :                  -0x10000000, since we know that it will just convert
     372                 :             :                  negative address space to positive, but perhaps this
     373                 :             :                  is not worthwhile.  */
     374                 :             :               break;
     375                 :             : 
     376                 :           0 :             case LABEL_REF:
     377                 :             :               /* These conditions are similar to SYMBOL_REF ones, just the
     378                 :             :                  constraints for code models differ.  */
     379                 :           0 :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     380                 :           0 :                   && offset > -0x10000)
     381                 :             :                 return true;
     382                 :             :               break;
     383                 :             : 
     384                 :             :             default:
     385                 :             :               return false;
     386                 :             :             }
     387                 :             :         }
     388                 :             :       break;
     389                 :             : 
     390                 :           0 :     default:
     391                 :           0 :       gcc_unreachable ();
     392                 :             :     }
     393                 :             :   return false;
     394                 :             : })
     395                 :             : 
     396                 :             : ;; Return true if VALUE is a constant integer whose negation satisfies
     397                 :   965765623 : ;; x86_64_immediate_operand.
     398                 :             : (define_predicate "x86_64_neg_const_int_operand"
     399                 :   965765623 :   (match_code "const_int")
     400                 :             : {
     401                 :   721122892 :   HOST_WIDE_INT val = -UINTVAL (op);
     402                 :       20376 :   if (mode == DImode && trunc_int_for_mode (val, SImode) != val)
     403                 :   721082563 :     return false;
     404                 :       39632 :   if (flag_cf_protection & CF_BRANCH)
     405                 :   721082563 :     {
     406                 :       17303 :       unsigned HOST_WIDE_INT endbr = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
     407                 :       17303 :       if ((val & HOST_WIDE_INT_C (0xffffffff)) == endbr)
     408                 :             :         return false;
     409                 :   721082563 :     }
     410                 :   721082563 :   return true;
     411                 :    56121793 : })
     412                 :             : 
     413                 :             : ;; Return true if VALUE is a constant integer whose low and high words satisfy
     414                 :       53594 : ;; x86_64_immediate_operand.
     415                 :       40329 : (define_predicate "x86_64_hilo_int_operand"
     416                 :       93923 :   (match_code "const_int,const_wide_int")
     417                 :       40329 : {
     418                 :    42939822 :   switch (GET_CODE (op))
     419                 :             :     {
     420                 :    42890907 :     case CONST_INT:
     421                 :    42939822 :       return x86_64_immediate_operand (op, mode);
     422                 :             : 
     423                 :       48915 :     case CONST_WIDE_INT:
     424                 :       48915 :       gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
     425                 :       48915 :       return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
     426                 :             :                                         DImode)
     427                 :       48915 :               && x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op,
     428                 :             :                                                                         1)),
     429                 :             :                                            DImode));
     430                 :             : 
     431                 :           0 :     default:
     432                 :           0 :       gcc_unreachable ();
     433                 :             :     }
     434                 :             : })
     435                 :             : 
     436                 :             : ;; Return true if VALUE is a constant integer whose value is
     437                 :    43631260 : ;; x86_64_immediate_operand value zero extended from word mode to mode.
     438                 :             : (define_predicate "x86_64_dwzext_immediate_operand"
     439                 :    43631260 :   (match_code "const_int,const_wide_int")
     440                 :             : {
     441                 :        3742 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     442                 :    42939822 :     return false;
     443                 :    42939822 : 
     444                 :        3742 :   switch (GET_CODE (op))
     445                 :             :     {
     446                 :        1624 :     case CONST_INT:
     447                 :        1624 :       if (!TARGET_64BIT)
     448                 :    42939822 :         return UINTVAL (op) <= HOST_WIDE_INT_UC (0xffffffff);
     449                 :        1624 :       return UINTVAL (op) <= HOST_WIDE_INT_UC (0x7fffffff);
     450                 :             : 
     451                 :        2118 :     case CONST_WIDE_INT:
     452                 :        5860 :       if (!TARGET_64BIT)
     453                 :             :         return false;
     454                 :        2118 :       return (CONST_WIDE_INT_NUNITS (op) == 2
     455                 :        2118 :               && CONST_WIDE_INT_ELT (op, 1) == 0
     456                 :        4236 :               && (trunc_int_for_mode (CONST_WIDE_INT_ELT (op, 0), SImode)
     457                 :        2118 :                   == (HOST_WIDE_INT) CONST_WIDE_INT_ELT (op, 0)));
     458                 :             : 
     459                 :           0 :     default:
     460                 :           0 :       gcc_unreachable ();
     461                 :             :     }
     462                 :             : })
     463                 :             : 
     464                 :             : ;; Return true if size of VALUE can be stored in a sign
     465                 :        3742 : ;; extended immediate field.
     466                 :             : (define_predicate "x86_64_immediate_size_operand"
     467                 :        3742 :   (and (match_code "symbol_ref")
     468                 :           0 :        (ior (not (match_test "TARGET_64BIT"))
     469                 :           0 :             (match_test "ix86_cmodel == CM_SMALL")
     470                 :           0 :             (match_test "ix86_cmodel == CM_KERNEL"))))
     471                 :           0 : 
     472                 :             : ;; Return true if OP is general operand representable on x86_64.
     473                 :             : (define_predicate "x86_64_general_operand"
     474                 :   145302639 :   (if_then_else (match_test "TARGET_64BIT")
     475                 :   145306381 :     (ior (match_operand 0 "nonimmediate_operand")
     476                 :        3742 :          (match_operand 0 "x86_64_immediate_operand"))
     477                 :   145302639 :     (match_operand 0 "general_operand")))
     478                 :    60436038 : 
     479                 :             : ;; Return true if OP's both words are general operands representable
     480                 :    60436038 : ;; on x86_64.
     481                 :             : (define_predicate "x86_64_hilo_general_operand"
     482                 :    60436038 :   (if_then_else (match_test "TARGET_64BIT")
     483                 :             :     (ior (match_operand 0 "nonimmediate_operand")
     484                 :             :          (match_operand 0 "x86_64_hilo_int_operand"))
     485                 :             :     (match_operand 0 "general_operand")))
     486                 :      325829 : 
     487                 :             : ;; Return true if OP is non-VOIDmode general operand representable
     488                 :      325829 : ;; on x86_64.  This predicate is used in sign-extending conversion
     489                 :             : ;; operations that require non-VOIDmode immediate operands.
     490                 :             : (define_predicate "x86_64_sext_operand"
     491                 :      325829 :   (and (match_test "GET_MODE (op) != VOIDmode")
     492                 :             :        (match_operand 0 "x86_64_general_operand")))
     493                 :             : 
     494                 :             : ;; Return true if OP is non-VOIDmode general operand.  This predicate
     495                 :       11474 : ;; is used in sign-extending conversion operations that require
     496                 :             : ;; non-VOIDmode immediate operands.
     497                 :       11474 : (define_predicate "sext_operand"
     498                 :       11474 :   (and (match_test "GET_MODE (op) != VOIDmode")
     499                 :             :        (match_operand 0 "general_operand")))
     500                 :             : 
     501                 :             : ;; Return true if OP is representable on x86_64 as zero-extended operand.
     502                 :     3636761 : ;; This predicate is used in zero-extending conversion operations that
     503                 :             : ;; require non-VOIDmode immediate operands.
     504                 :     3636761 : (define_predicate "x86_64_zext_operand"
     505                 :     3636761 :   (if_then_else (match_test "TARGET_64BIT")
     506                 :             :     (ior (match_operand 0 "nonimmediate_operand")
     507                 :             :          (and (match_operand 0 "x86_64_zext_immediate_operand")
     508                 :      114006 :               (match_test "GET_MODE (op) != VOIDmode")))
     509                 :             :     (match_operand 0 "nonimmediate_operand")))
     510                 :             : 
     511                 :             : ;; Return true if OP is general operand representable on x86_64
     512                 :     2473293 : ;; as either sign extended or zero extended constant.
     513                 :             : (define_predicate "x86_64_szext_general_operand"
     514                 :     2473293 :   (if_then_else (match_test "TARGET_64BIT")
     515                 :             :     (ior (match_operand 0 "nonimmediate_operand")
     516                 :             :          (match_operand 0 "x86_64_immediate_operand")
     517                 :             :          (match_operand 0 "x86_64_zext_immediate_operand"))
     518                 :    29334229 :     (match_operand 0 "general_operand")))
     519                 :             : 
     520                 :    29334229 : ;; Return true if OP is nonmemory operand representable on x86_64.
     521                 :             : (define_predicate "x86_64_nonmemory_operand"
     522                 :    29334229 :   (if_then_else (match_test "TARGET_64BIT")
     523                 :             :     (ior (match_operand 0 "register_operand")
     524                 :             :          (match_operand 0 "x86_64_immediate_operand"))
     525                 :             :     (match_operand 0 "nonmemory_operand")))
     526                 :      281576 : 
     527                 :             : ;; Return true if OP is nonmemory operand representable on x86_64.
     528                 :      281576 : (define_predicate "x86_64_szext_nonmemory_operand"
     529                 :      281576 :   (if_then_else (match_test "TARGET_64BIT")
     530                 :             :     (ior (match_operand 0 "register_operand")
     531                 :             :          (match_operand 0 "x86_64_immediate_operand")
     532                 :             :          (match_operand 0 "x86_64_zext_immediate_operand"))
     533                 :   167179082 :     (match_operand 0 "nonmemory_operand")))
     534                 :             : 
     535                 :             : ;; Return true when operand is PIC expression that can be computed by lea
     536                 :             : ;; operation.
     537                 :             : (define_predicate "pic_32bit_operand"
     538                 :             :   (match_code "const,symbol_ref,label_ref")
     539                 :             : {
     540                 :   167179082 :   if (!flag_pic)
     541                 :             :     return false;
     542                 :             : 
     543                 :             :   /* Rule out relocations that translate into 64bit constants.  */
     544                 :     7818298 :   if (TARGET_64BIT && GET_CODE (op) == CONST)
     545                 :             :     {
     546                 :      144148 :       op = XEXP (op, 0);
     547                 :      144148 :       if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
     548                 :      143118 :         op = XEXP (op, 0);
     549                 :      144148 :       if (GET_CODE (op) == UNSPEC
     550                 :        1030 :           && (XINT (op, 1) == UNSPEC_GOTOFF
     551                 :        1030 :               || XINT (op, 1) == UNSPEC_GOT))
     552                 :             :         return false;
     553                 :             :     }
     554                 :             : 
     555                 :     7817696 :   return symbolic_operand (op, mode);
     556                 :             : })
     557                 :             : 
     558                 :             : ;; Return true if OP is nonmemory operand acceptable by movabs patterns.
     559                 :  1241674454 : (define_predicate "x86_64_movabs_operand"
     560                 :             :   (and (match_operand 0 "nonmemory_operand")
     561                 :  1241674454 :        (not (match_operand 0 "pic_32bit_operand"))))
     562                 :             : 
     563                 :   167179082 : ;; Return true if OP is either a symbol reference or a sum of a symbol
     564                 :   167179082 : ;; reference and a constant.
     565                 :   167179082 : (define_predicate "symbolic_operand"
     566                 :   167179082 :   (match_code "symbol_ref,label_ref,const")
     567                 :             : {
     568                 :     8171306 :   switch (GET_CODE (op))
     569                 :             :     {
     570                 :   167179082 :     case SYMBOL_REF:
     571                 :   167179082 :     case LABEL_REF:
     572                 :      170076 :       return true;
     573                 :             : 
     574                 :       32864 :     case CONST:
     575                 :       32864 :       op = XEXP (op, 0);
     576                 :   479565853 :       if (GET_CODE (op) == SYMBOL_REF
     577                 :       32864 :           || GET_CODE (op) == LABEL_REF
     578                 :   479565853 :           || (GET_CODE (op) == UNSPEC
     579                 :        7972 :               && (XINT (op, 1) == UNSPEC_GOT
     580                 :        7972 :                   || XINT (op, 1) == UNSPEC_GOTOFF
     581                 :         172 :                   || XINT (op, 1) == UNSPEC_PCREL
     582                 :     8171478 :                   || XINT (op, 1) == UNSPEC_GOTPCREL)))
     583                 :             :         return true;
     584                 :       25036 :       if (GET_CODE (op) != PLUS
     585                 :       24892 :           || !CONST_INT_P (XEXP (op, 1)))
     586                 :             :         return false;
     587                 :             : 
     588                 :       24892 :       op = XEXP (op, 0);
     589                 :       24892 :       if (GET_CODE (op) == SYMBOL_REF
     590                 :       24892 :           || GET_CODE (op) == LABEL_REF)
     591                 :             :         return true;
     592                 :             :       /* Only @GOTOFF gets offsets.  */
     593                 :        2095 :       if (GET_CODE (op) != UNSPEC
     594                 :        2095 :           || XINT (op, 1) != UNSPEC_GOTOFF)
     595                 :             :         return false;
     596                 :             : 
     597                 :        2095 :       op = XVECEXP (op, 0, 0);
     598                 :        2095 :       if (GET_CODE (op) == SYMBOL_REF
     599                 :        2095 :           || GET_CODE (op) == LABEL_REF)
     600                 :        2095 :         return true;
     601                 :             :       return false;
     602                 :             : 
     603                 :           0 :     default:
     604                 :           0 :       gcc_unreachable ();
     605                 :             :     }
     606                 :             : })
     607                 :             : 
     608                 :             : ;; Return true if OP is a symbolic operand that resolves locally.
     609                 :    15406046 : (define_predicate "local_symbolic_operand"
     610                 :             :   (match_code "const,label_ref,symbol_ref")
     611                 :    15406046 : {
     612                 :     2854214 :   if (GET_CODE (op) == CONST
     613                 :       16140 :       && GET_CODE (XEXP (op, 0)) == PLUS
     614                 :        8378 :       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
     615                 :        8378 :     op = XEXP (XEXP (op, 0), 0);
     616                 :     8171306 : 
     617                 :     2854214 :   if (GET_CODE (op) == LABEL_REF)
     618                 :             :     return true;
     619                 :             : 
     620                 :     2814494 :   if (GET_CODE (op) != SYMBOL_REF)
     621                 :     8171306 :     return false;
     622                 :      523970 : 
     623                 :     2804637 :   if (SYMBOL_REF_TLS_MODEL (op))
     624                 :             :     return false;
     625                 :             : 
     626                 :     2854214 :   /* Dll-imported symbols are always external.  */
     627                 :     2804637 :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     628                 :             :     return false;
     629                 :     2804637 :   if (SYMBOL_REF_LOCAL_P (op))
     630                 :             :     return true;
     631                 :             : 
     632                 :             :   /* There is, however, a not insubstantial body of code in the rest of
     633                 :             :      the compiler that assumes it can just stick the results of
     634                 :             :      ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done.  */
     635                 :             :   /* ??? This is a hack.  Should update the body of the compiler to
     636                 :             :      always create a DECL an invoke targetm.encode_section_info.  */
     637                 :       92244 :   if (strncmp (XSTR (op, 0), internal_label_prefix,
     638                 :             :                internal_label_prefix_len) == 0)
     639                 :           0 :     return true;
     640                 :             : 
     641                 :             :   return false;
     642                 :             : })
     643                 :             : 
     644                 :             : (define_predicate "local_func_symbolic_operand"
     645                 :     2862617 :   (match_operand 0 "local_symbolic_operand")
     646                 :             : {
     647                 :     2862617 :   if (GET_CODE (op) == CONST
     648                 :           0 :       && GET_CODE (XEXP (op, 0)) == PLUS
     649                 :           0 :       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
     650                 :           0 :     op = XEXP (XEXP (op, 0), 0);
     651                 :     2854214 : 
     652                 :     2854226 :   if (GET_CODE (op) == SYMBOL_REF
     653                 :          12 :       && !SYMBOL_REF_FUNCTION_P (op))
     654                 :           0 :     return false;
     655                 :             : 
     656                 :     2854214 :   return true;
     657                 :     2854214 : })
     658                 :     2752105 : 
     659                 :             : ;; Test for a legitimate @GOTOFF operand.
     660                 :          30 : ;;
     661                 :             : ;; VxWorks does not impose a fixed gap between segments; the run-time
     662                 :          42 : ;; gap can be different from the object-file gap.  We therefore can't
     663                 :          12 : ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
     664                 :             : ;; same segment as the GOT.  Unfortunately, the flexibility of linker
     665                 :             : ;; scripts means that we can't be sure of that in general, so assume
     666                 :             : ;; @GOTOFF is not valid on VxWorks, except with the large code model.
     667                 :     2862554 : (define_predicate "gotoff_operand"
     668                 :             :   (and (ior (not (match_test "TARGET_VXWORKS_RTP"))
     669                 :     2862554 :             (match_test "ix86_cmodel == CM_LARGE")
     670                 :     2862554 :             (match_test "ix86_cmodel == CM_LARGE_PIC"))
     671                 :             :        (match_operand 0 "local_symbolic_operand")))
     672                 :             : 
     673                 :             : ;; Test for various thread-local symbols.
     674                 :       28990 : (define_special_predicate "tls_symbolic_operand"
     675                 :             :   (and (match_code "symbol_ref")
     676                 :       28990 :        (match_test "SYMBOL_REF_TLS_MODEL (op)")))
     677                 :             : 
     678                 :             : (define_special_predicate "tls_modbase_operand"
     679                 :             :   (and (match_code "symbol_ref")
     680                 :          10 :        (match_test "op == ix86_tls_module_base ()")))
     681                 :             : 
     682                 :          20 : (define_predicate "tls_address_pattern"
     683                 :             :   (and (match_code "set,parallel,unspec,unspec_volatile")
     684                 :   231888370 :        (match_test "ix86_tls_address_pattern_p (op)")))
     685                 :           0 : 
     686                 :   231888370 : ;; Test for a pc-relative call operand
     687                 :             : (define_predicate "constant_call_address_operand"
     688                 :   231888370 :   (match_code "symbol_ref")
     689                 :   362091836 : {
     690                 :   130203257 :   if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
     691                 :   130203251 :       || flag_force_indirect_call
     692                 :   260405213 :       || (TARGET_INDIRECT_BRANCH_REGISTER
     693                 :        1022 :           && ix86_nopic_noplt_attribute_p (op)))
     694                 :        1743 :     return false;
     695                 :             :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     696                 :   231888370 :     return false;
     697                 :             :   return true;
     698                 :             : })
     699                 :             : 
     700                 :             : ;; True for any non-virtual and non-eliminable register.  Used in places where
     701                 :   136129690 : ;; instantiation of such a register may cause the pattern to not be recognized.
     702                 :             : (define_predicate "register_no_elim_operand"
     703                 :   130203466 :   (match_operand 0 "register_operand")
     704                 :   266331413 : {
     705                 :    94835468 :   if (SUBREG_P (op))
     706                 :       68515 :     op = SUBREG_REG (op);
     707                 :             : 
     708                 :             :   /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
     709                 :    20350237 :      because it is guaranteed to be reloaded into one.  */
     710                 :    20350237 :   if (MEM_P (op))
     711                 :             :     return true;
     712                 :             : 
     713                 :    20350237 :   return !(op == arg_pointer_rtx
     714                 :    20323642 :            || op == frame_pointer_rtx
     715                 :    20323134 :            || VIRTUAL_REGISTER_P (op));
     716                 :             : })
     717                 :             : 
     718                 :             : ;; Similarly, but include the stack pointer.  This is used
     719                 :    24996508 : ;; to prevent esp from being used as an index reg.
     720                 :             : (define_predicate "register_no_SP_operand"
     721                 :    24996508 :   (match_operand 0 "register_operand")
     722                 :    20350237 : {
     723                 :      332849 :   if (SUBREG_P (op))
     724                 :        7840 :     op = SUBREG_REG (op);
     725                 :             : 
     726                 :      332849 :   /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
     727                 :             :      because it is guaranteed to be reloaded into one.  */
     728                 :      332849 :   if (MEM_P (op))
     729                 :             :     return true;
     730                 :             : 
     731                 :      332849 :   return !(op == arg_pointer_rtx
     732                 :      332849 :            || op == frame_pointer_rtx
     733                 :      332849 :            || op == stack_pointer_rtx
     734                 :      332849 :            || VIRTUAL_REGISTER_P (op));
     735                 :             : })
     736                 :             : 
     737                 :             : ;; P6 processors will jump to the address after the decrement when %esp
     738                 :      369024 : ;; is used as a call operand, so they will execute return address as a code.
     739                 :             : ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
     740                 :      369024 : 
     741                 :      332849 : (define_predicate "call_register_operand"
     742                 :     1931023 :   (if_then_else (match_test "TARGET_64BIT")
     743                 :             :     (match_operand 0 "register_operand")
     744                 :             :     (match_operand 0 "register_no_SP_operand")))
     745                 :     1931023 : 
     746                 :    18381608 : ;; Return false if this is any eliminable register.  Otherwise general_operand.
     747                 :     1931023 : (define_predicate "general_no_elim_operand"
     748                 :    18381608 :   (if_then_else (match_code "reg,subreg")
     749                 :             :     (match_operand 0 "register_no_elim_operand")
     750                 :             :     (match_operand 0 "general_operand")))
     751                 :             : 
     752                 :    12103195 : ;; Return false if this is any eliminable register.  Otherwise
     753                 :             : ;; register_operand or a constant.
     754                 :    12103195 : (define_predicate "nonmemory_no_elim_operand"
     755                 :             :   (ior (match_operand 0 "register_no_elim_operand")
     756                 :             :        (match_operand 0 "immediate_operand")))
     757                 :             : 
     758                 :      747052 : ;; Test for a valid operand for indirect branch.
     759                 :             : (define_predicate "indirect_branch_operand"
     760                 :      747052 :   (ior (match_operand 0 "register_operand")
     761                 :      675281 :        (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
     762                 :      675254 :             (not (match_test "TARGET_X32"))
     763                 :             :             (match_operand 0 "memory_operand"))))
     764                 :             : 
     765                 :             : ;; Return true if OP is a memory operands that can be used in sibcalls.
     766                 :       24142 : ;; Since sibcall never returns, we can only use call-clobbered register
     767                 :             : ;; as GOT base.  Allow GOT slot here only with pseudo register as GOT
     768                 :             : ;; base.  Properly handle sibcall over GOT slot with *sibcall_GOT_32
     769                 :             : ;; and *sibcall_value_GOT_32 patterns.
     770                 :             : (define_predicate "sibcall_memory_operand"
     771                 :             :   (match_operand 0 "memory_operand")
     772                 :             : {
     773                 :       24142 :   op = XEXP (op, 0);
     774                 :       24142 :   if (CONSTANT_P (op))
     775                 :             :     return true;
     776                 :       10980 :   if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
     777                 :             :     {
     778                 :        9696 :       int regno = REGNO (XEXP (op, 0));
     779                 :        9696 :       if (!HARD_REGISTER_NUM_P (regno) || call_used_or_fixed_reg_p (regno))
     780                 :             :         {
     781                 :        8146 :           op = XEXP (op, 1);
     782                 :        8146 :           if (GOT32_symbol_operand (op, VOIDmode))
     783                 :             :             return true;
     784                 :             :         }
     785                 :             :     }
     786                 :             :   return false;
     787                 :             : })
     788                 :             : 
     789                 :             : ;; Return true if OP is a GOT memory operand.
     790                 :     1365026 : (define_predicate "GOT_memory_operand"
     791                 :             :   (and (match_operand 0 "memory_operand")
     792                 :     1389168 :        (match_code "const" "0")
     793                 :       24142 :        (match_code "unspec" "00")
     794                 :         555 :        (match_test "XINT (XEXP (XEXP (op, 0), 0), 1) == UNSPEC_GOTPCREL")))
     795                 :             : 
     796                 :             : ;; Test for a valid operand for a call instruction.
     797                 :         453 : ;; Allow constant call address operands in Pmode only.
     798                 :    47397986 : (define_special_predicate "call_insn_operand"
     799                 :         453 :   (ior (match_test "constant_call_address_operand
     800                 :    53585445 :                      (op, mode == VOIDmode ? mode : Pmode)")
     801                 :             :        (match_operand 0 "call_register_operand")
     802                 :      918632 :        (match_test "satisfies_constraint_Bw (op)")))
     803                 :             : 
     804                 :             : ;; Similarly, but for tail calls, in which we cannot allow memory references.
     805                 :             : (define_special_predicate "sibcall_insn_operand"
     806                 :     1220399 :   (ior (match_test "constant_call_address_operand
     807                 :     1425511 :                      (op, mode == VOIDmode ? mode : Pmode)")
     808                 :     1220399 :        (match_operand 0 "register_no_elim_operand")
     809                 :      169050 :        (match_test "satisfies_constraint_Bs (op)")))
     810                 :             : 
     811                 :             : ;; Return true if OP is a 32-bit GOT symbol operand.
     812                 :             : (define_predicate "GOT32_symbol_operand"
     813                 :       10047 :   (and (match_code "const")
     814                 :             :        (match_code "unspec" "0")
     815                 :       10047 :        (match_test "XINT (XEXP (op, 0), 1) == UNSPEC_GOT")))
     816                 :           0 : 
     817                 :             : ;; Match exactly zero.
     818                 :             : (define_predicate "const0_operand"
     819                 :             :   (match_code "const_int,const_double,const_vector")
     820                 :   129165150 : {
     821                 :   129165150 :   if (mode == VOIDmode)
     822                 :    20471958 :     mode = GET_MODE (op);
     823                 :   129165150 :   return op == CONST0_RTX (mode);
     824                 :             : })
     825                 :             : 
     826                 :             : ;; Match one or a vector with all elements equal to one.
     827                 :   935614585 : (define_predicate "const1_operand"
     828                 :             :   (match_code "const_int,const_double,const_vector")
     829                 :   935614585 : {
     830                 :    12535490 :   if (mode == VOIDmode)
     831                 :    12532656 :     mode = GET_MODE (op);
     832                 :   141700640 :   return op == CONST1_RTX (mode);
     833                 :   129165150 : })
     834                 :   129165150 : 
     835                 :             : ;; Match exactly -1.
     836                 :    13529877 : (define_predicate "constm1_operand"
     837                 :             :   (and (match_code "const_int")
     838                 :   142695027 :        (match_test "op == constm1_rtx")))
     839                 :   129165150 : 
     840                 :    57812828 : ;; Match 0 or -1.
     841                 :    12535490 : (define_predicate "const0_or_m1_operand"
     842                 :    12537896 :   (ior (match_operand 0 "const0_operand")
     843                 :    12535490 :        (match_operand 0 "constm1_operand")))
     844                 :        2406 : 
     845                 :             : ;; Match exactly eight.
     846                 :             : (define_predicate "const8_operand"
     847                 :    12535490 :   (and (match_code "const_int")
     848                 :    12535490 :        (match_test "INTVAL (op) == 8")))
     849                 :        2807 : 
     850                 :           0 : ;; Match exactly 128.
     851                 :             : (define_predicate "const128_operand"
     852                 :    25500388 :   (and (match_code "const_int")
     853                 :   234658109 :        (match_test "INTVAL (op) == 128")))
     854                 :    25500388 : 
     855                 :   187760038 : ;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation
     856                 :             : (define_predicate "const_32bit_mask"
     857                 :     2982529 :   (and (match_code "const_int")
     858                 :     2132363 :        (match_test "trunc_int_for_mode (INTVAL (op), DImode)
     859                 :     5114892 :                     == HOST_WIDE_INT_C (0xffffffff)")))
     860                 :             : 
     861                 :             : ;; Match 2, 4, or 8.  Used for leal multiplicands.
     862                 :             : (define_predicate "const248_operand"
     863                 :      353716 :   (match_code "const_int")
     864                 :             : {
     865                 :      353716 :   HOST_WIDE_INT i = INTVAL (op);
     866                 :      353716 :   return i == 2 || i == 4 || i == 8;
     867                 :             : })
     868                 :             : 
     869                 :             : ;; Match 1, 2, or 3.  Used for lea shift amounts.
     870                 :     1055513 : (define_predicate "const123_operand"
     871                 :             :   (match_code "const_int")
     872                 :     1055513 : {
     873                 :     1276712 :   HOST_WIDE_INT i = INTVAL (op);
     874                 :      221199 :   return i == 1 || i == 2 || i == 3;
     875                 :             : })
     876                 :             : 
     877                 :      221199 : ;; Match 2, 3, 6, or 7
     878                 :      229649 : (define_predicate "const2367_operand"
     879                 :             :   (match_code "const_int")
     880                 :      229649 : {
     881                 :      221199 :   HOST_WIDE_INT i = INTVAL (op);
     882                 :           0 :   return i == 2 || i == 3 || i == 6 || i == 7;
     883                 :             : })
     884                 :             : 
     885                 :           0 : ;; Match 1, 2, 4, or 8
     886                 :           0 : (define_predicate "const1248_operand"
     887                 :             :   (match_code "const_int")
     888                 :           0 : {
     889                 :      131886 :   HOST_WIDE_INT i = INTVAL (op);
     890                 :      131886 :   return i == 1 || i == 2 || i == 4 || i == 8;
     891                 :             : })
     892                 :             : 
     893                 :      131886 : ;; Match 3, 5, or 9.  Used for leal multiplicands.
     894                 :      506648 : (define_predicate "const359_operand"
     895                 :             :   (match_code "const_int")
     896                 :      506648 : {
     897                 :      569452 :   HOST_WIDE_INT i = INTVAL (op);
     898                 :       62804 :   return i == 3 || i == 5 || i == 9;
     899                 :             : })
     900                 :             : 
     901                 :       62804 : ;; Match 4 or 8 to 11.  Used for embeded rounding.
     902                 :      214701 : (define_predicate "const_4_or_8_to_11_operand"
     903                 :             :   (match_code "const_int")
     904                 :      214701 : {
     905                 :      295206 :   HOST_WIDE_INT i = INTVAL (op);
     906                 :       80505 :   return i == 4 || (i >= 8 && i <= 11);
     907                 :             : })
     908                 :             : 
     909                 :       80505 : ;; Match 4 or 8. Used for SAE.
     910                 :       80507 : (define_predicate "const48_operand"
     911                 :             :   (match_code "const_int")
     912                 :       80507 : {
     913                 :       80505 :   HOST_WIDE_INT i = INTVAL (op);
     914                 :       63816 :   return i == 4 || i == 8;
     915                 :             : })
     916                 :             : 
     917                 :       63816 : ;; Match 0 or 1.
     918                 :       63816 : (define_predicate "const_0_to_1_operand"
     919                 :             :   (and (match_code "const_int")
     920                 :       63816 :        (ior (match_test "op == const0_rtx")
     921                 :      252490 :             (match_test "op == const1_rtx"))))
     922                 :             : 
     923                 :             : ;; Match 0 to 3.
     924                 :             : (define_predicate "const_0_to_3_operand"
     925                 :     6643221 :   (and (match_code "const_int")
     926                 :    12617025 :        (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
     927                 :     6643221 : 
     928                 :             : ;; Match 0 to 4.
     929                 :             : (define_predicate "const_0_to_4_operand"
     930                 :           0 :   (and (match_code "const_int")
     931                 :           0 :        (match_test "IN_RANGE (INTVAL (op), 0, 4)")))
     932                 :           0 : 
     933                 :             : ;; Match 0 to 5.
     934                 :             : (define_predicate "const_0_to_5_operand"
     935                 :           0 :   (and (match_code "const_int")
     936                 :           0 :        (match_test "IN_RANGE (INTVAL (op), 0, 5)")))
     937                 :           0 : 
     938                 :             : ;; Match 0 to 7.
     939                 :             : (define_predicate "const_0_to_7_operand"
     940                 :      615226 :   (and (match_code "const_int")
     941                 :     1230438 :        (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
     942                 :      615226 : 
     943                 :             : ;; Match 0 to 15.
     944                 :             : (define_predicate "const_0_to_15_operand"
     945                 :       80754 :   (and (match_code "const_int")
     946                 :      161492 :        (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
     947                 :       80754 : 
     948                 :             : ;; Match 0 to 31.
     949                 :             : (define_predicate "const_0_to_31_operand"
     950                 :       62097 :   (and (match_code "const_int")
     951                 :      123635 :        (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
     952                 :       62097 : 
     953                 :             : ;; Match 0 to 63.
     954                 :             : (define_predicate "const_0_to_63_operand"
     955                 :       29336 :   (and (match_code "const_int")
     956                 :       56861 :        (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
     957                 :       29336 : 
     958                 :             : ;; Match 0 to 127.
     959                 :             : (define_predicate "const_0_to_127_operand"
     960                 :        9251 :   (and (match_code "const_int")
     961                 :       17778 :        (match_test "IN_RANGE (INTVAL (op), 0, 127)")))
     962                 :        9251 : 
     963                 :             : ;; Match 0 to 255.
     964                 :             : (define_predicate "const_0_to_255_operand"
     965                 :     9016382 :   (and (match_code "const_int")
     966                 :    17999190 :        (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
     967                 :     9016382 : 
     968                 :             : ;; Match (0 to 255) * 8
     969                 :             : (define_predicate "const_0_to_255_mul_8_operand"
     970                 :      422588 :   (match_code "const_int")
     971                 :             : {
     972                 :      422588 :   unsigned HOST_WIDE_INT val = INTVAL (op);
     973                 :      422588 :   return val <= 255*8 && val % 8 == 0;
     974                 :             : })
     975                 :             : 
     976                 :             : ;; Match 1 to 255 except multiples of 8
     977                 :      422590 : (define_predicate "const_0_to_255_not_mul_8_operand"
     978                 :             :   (match_code "const_int")
     979                 :      422590 : {
     980                 :     1253780 :   unsigned HOST_WIDE_INT val = INTVAL (op);
     981                 :      831176 :   return val <= 255 && val % 8 != 0;
     982                 :             : })
     983                 :             : 
     984                 :      831190 : ;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand
     985                 :      831190 : ;; for shift & compare patterns, as shifting by 0 does not change flags).
     986                 :             : (define_predicate "const_1_to_31_operand"
     987                 :      831190 :   (and (match_code "const_int")
     988                 :      874329 :        (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
     989                 :             : 
     990                 :             : ;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand
     991                 :             : ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
     992                 :       90485 : (define_predicate "const_1_to_63_operand"
     993                 :             :   (and (match_code "const_int")
     994                 :       90485 :        (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
     995                 :             : 
     996                 :             : ;; Match 2 or 3.
     997                 :             : (define_predicate "const_2_to_3_operand"
     998                 :       66563 :   (and (match_code "const_int")
     999                 :      133126 :        (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
    1000                 :       66563 : 
    1001                 :             : ;; Match 4 to 5.
    1002                 :             : (define_predicate "const_4_to_5_operand"
    1003                 :        7175 :   (and (match_code "const_int")
    1004                 :       14350 :        (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
    1005                 :        7175 : 
    1006                 :             : ;; Match 4 to 7.
    1007                 :             : (define_predicate "const_4_to_7_operand"
    1008                 :      920849 :   (and (match_code "const_int")
    1009                 :     1841698 :        (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
    1010                 :      920849 : 
    1011                 :             : ;; Match 6 to 7.
    1012                 :             : (define_predicate "const_6_to_7_operand"
    1013                 :         686 :   (and (match_code "const_int")
    1014                 :        1372 :        (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
    1015                 :         686 : 
    1016                 :             : ;; Match 8 to 9.
    1017                 :             : (define_predicate "const_8_to_9_operand"
    1018                 :         506 :   (and (match_code "const_int")
    1019                 :        1012 :        (match_test "IN_RANGE (INTVAL (op), 8, 9)")))
    1020                 :         506 : 
    1021                 :             : ;; Match 8 to 11.
    1022                 :             : (define_predicate "const_8_to_11_operand"
    1023                 :       46567 :   (and (match_code "const_int")
    1024                 :       93134 :        (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
    1025                 :       46567 : 
    1026                 :             : ;; Match 8 to 15.
    1027                 :             : (define_predicate "const_8_to_15_operand"
    1028                 :       45677 :   (and (match_code "const_int")
    1029                 :       91354 :        (match_test "IN_RANGE (INTVAL (op), 8, 15)")))
    1030                 :       45677 : 
    1031                 :             : ;; Match 10 to 11.
    1032                 :             : (define_predicate "const_10_to_11_operand"
    1033                 :         265 :   (and (match_code "const_int")
    1034                 :         530 :        (match_test "IN_RANGE (INTVAL (op), 10, 11)")))
    1035                 :         265 : 
    1036                 :             : ;; Match 12 to 13.
    1037                 :             : (define_predicate "const_12_to_13_operand"
    1038                 :         265 :   (and (match_code "const_int")
    1039                 :         530 :        (match_test "IN_RANGE (INTVAL (op), 12, 13)")))
    1040                 :         265 : 
    1041                 :             : ;; Match 12 to 15.
    1042                 :             : (define_predicate "const_12_to_15_operand"
    1043                 :       29012 :   (and (match_code "const_int")
    1044                 :       58024 :        (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
    1045                 :       29012 : 
    1046                 :             : ;; Match 14 to 15.
    1047                 :             : (define_predicate "const_14_to_15_operand"
    1048                 :         265 :   (and (match_code "const_int")
    1049                 :         530 :        (match_test "IN_RANGE (INTVAL (op), 14, 15)")))
    1050                 :         265 : 
    1051                 :             : ;; Match 16 to 19.
    1052                 :             : (define_predicate "const_16_to_19_operand"
    1053                 :        1470 :   (and (match_code "const_int")
    1054                 :        2940 :        (match_test "IN_RANGE (INTVAL (op), 16, 19)")))
    1055                 :        1470 : 
    1056                 :             : ;; Match 16 to 31.
    1057                 :             : (define_predicate "const_16_to_31_operand"
    1058                 :       10137 :   (and (match_code "const_int")
    1059                 :       20274 :        (match_test "IN_RANGE (INTVAL (op), 16, 31)")))
    1060                 :       10137 : 
    1061                 :             : ;; Match 20 to 23.
    1062                 :             : (define_predicate "const_20_to_23_operand"
    1063                 :        1078 :   (and (match_code "const_int")
    1064                 :        2156 :        (match_test "IN_RANGE (INTVAL (op), 20, 23)")))
    1065                 :        1078 : 
    1066                 :             : ;; Match 24 to 27.
    1067                 :             : (define_predicate "const_24_to_27_operand"
    1068                 :        1078 :   (and (match_code "const_int")
    1069                 :        2156 :        (match_test "IN_RANGE (INTVAL (op), 24, 27)")))
    1070                 :        1078 : 
    1071                 :             : ;; Match 28 to 31.
    1072                 :             : (define_predicate "const_28_to_31_operand"
    1073                 :        1078 :   (and (match_code "const_int")
    1074                 :        2156 :        (match_test "IN_RANGE (INTVAL (op), 28, 31)")))
    1075                 :        1078 : 
    1076                 :             : (define_predicate "cmpps_imm_operand"
    1077                 :             :   (ior (match_operand 0 "const_0_to_7_operand")
    1078                 :        4017 :        (and (match_test "TARGET_AVX")
    1079                 :             :             (match_operand 0 "const_0_to_31_operand"))))
    1080                 :       30544 : 
    1081                 :             : ;; True if this is a constant appropriate for an increment or decrement.
    1082                 :    96161106 : (define_predicate "incdec_operand"
    1083                 :             :   (match_code "const_int")
    1084                 :             : {
    1085                 :             :   /* On Pentium4, the inc and dec operations causes extra dependency on flag
    1086                 :             :      registers, since carry flag is not set.  */
    1087                 :    96161106 :   if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
    1088                 :             :     return false;
    1089                 :     2354375 :   return op == const1_rtx || op == constm1_rtx;
    1090                 :             : })
    1091                 :             : 
    1092                 :             : ;; True for registers, or const_int_operand, used to vec_setm expander.
    1093                 :   118854159 : (define_predicate "vec_setm_sse41_operand"
    1094                 :             :   (ior (and (match_operand 0 "register_operand")
    1095                 :   215015930 :             (match_test "TARGET_SSE4_1"))
    1096                 :    96161106 :        (match_code "const_int")))
    1097                 :             : 
    1098                 :             : (define_predicate "vec_setm_avx2_operand"
    1099                 :             :   (ior (and (match_operand 0 "register_operand")
    1100                 :         901 :             (match_test "TARGET_AVX2"))
    1101                 :           0 :        (match_code "const_int")))
    1102                 :        1136 : 
    1103                 :             : (define_predicate "vec_setm_mmx_operand"
    1104                 :             :   (ior (and (match_operand 0 "register_operand")
    1105                 :          22 :             (match_test "TARGET_SSE4_1")
    1106                 :         230 :             (match_test "TARGET_MMX_WITH_SSE"))
    1107                 :         230 :        (match_code "const_int")))
    1108                 :             : 
    1109                 :             : ;; True for registers, or 1 or -1.  Used to optimize double-word shifts.
    1110                 :             : (define_predicate "reg_or_pm1_operand"
    1111                 :     4212726 :   (ior (match_operand 0 "register_operand")
    1112                 :             :        (and (match_code "const_int")
    1113                 :     4212726 :             (ior (match_test "op == const1_rtx")
    1114                 :      313498 :                  (match_test "op == constm1_rtx")))))
    1115                 :      298087 : 
    1116                 :             : ;; True for registers, or (not: registers).  Used to optimize 3-operand
    1117                 :             : ;; bitwise operation.
    1118                 :             : (define_predicate "regmem_or_bitnot_regmem_operand"
    1119                 :      501024 :   (ior (match_operand 0 "nonimmediate_operand")
    1120                 :             :        (and (match_code "not")
    1121                 :      501024 :             (match_test "nonimmediate_operand (XEXP (op, 0), mode)"))))
    1122                 :       26478 : 
    1123                 :             : ;; True for expressions valid for 3-operand ternlog instructions.
    1124                 :             : (define_predicate "ternlog_operand"
    1125                 :             :   (and (match_code "not,and,ior,xor")
    1126                 :     1861839 :        (match_test "ix86_ternlog_operand_p (op)")))
    1127                 :      199426 : 
    1128                 :    64105549 : ;; True if OP is acceptable as operand of DImode shift expander.
    1129                 :             : (define_predicate "shiftdi_operand"
    1130                 :     1345603 :   (if_then_else (match_test "TARGET_64BIT")
    1131                 :     3207442 :     (match_operand 0 "nonimmediate_operand")
    1132                 :     1861839 :     (match_operand 0 "register_operand")))
    1133                 :     1345603 : 
    1134                 :     2458466 : (define_predicate "ashldi_input_operand"
    1135                 :      596627 :   (if_then_else (match_test "TARGET_64BIT")
    1136                 :      596627 :     (match_operand 0 "nonimmediate_operand")
    1137                 :             :     (match_operand 0 "reg_or_pm1_operand")))
    1138                 :     1861839 : 
    1139                 :      554268 : ;; Return true if OP is a vector load from the constant pool with just
    1140                 :             : ;; the first element nonzero.
    1141                 :             : (define_predicate "zero_extended_scalar_load_operand"
    1142                 :             :   (match_code "mem")
    1143                 :             : {
    1144                 :      554268 :   unsigned n_elts;
    1145                 :      554268 :   op = avoid_constant_pool_reference (op);
    1146                 :             : 
    1147                 :      554268 :   if (GET_CODE (op) != CONST_VECTOR)
    1148                 :             :     return false;
    1149                 :             : 
    1150                 :       81869 :   n_elts = CONST_VECTOR_NUNITS (op);
    1151                 :             : 
    1152                 :      166609 :   for (n_elts--; n_elts > 0; n_elts--)
    1153                 :             :     {
    1154                 :      121577 :       rtx elt = CONST_VECTOR_ELT (op, n_elts);
    1155                 :      243154 :       if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
    1156                 :             :         return false;
    1157                 :             :     }
    1158                 :             :   return true;
    1159                 :             : })
    1160                 :             : 
    1161                 :             : /* Return true if operand is a float vector constant that is all ones. */
    1162                 :     1790672 : (define_predicate "float_vector_all_ones_operand"
    1163                 :             :   (match_code "const_vector,mem")
    1164                 :      554268 : {
    1165                 :     1835704 :   mode = GET_MODE (op);
    1166                 :       45032 :   if (!FLOAT_MODE_P (mode)
    1167                 :    13553332 :       || (MEM_P (op)
    1168                 :    11674643 :           && (!SYMBOL_REF_P (XEXP (op, 0))
    1169                 :     1419708 :               || !CONSTANT_POOL_ADDRESS_P (XEXP (op, 0)))))
    1170                 :    16039440 :     return false;
    1171                 :             : 
    1172                 :     3064134 :   if (MEM_P (op))
    1173                 :             :     {
    1174                 :     1185445 :       op = get_pool_constant (XEXP (op, 0));
    1175                 :     1185445 :       if (GET_CODE (op) != CONST_VECTOR)
    1176                 :             :         return false;
    1177                 :             : 
    1178                 :     1185441 :       if (GET_MODE (op) != mode
    1179                 :        4521 :          && INTEGRAL_MODE_P (GET_MODE (op))
    1180                 :        4521 :          && op == CONSTM1_RTX (GET_MODE (op)))
    1181                 :             :         return true;
    1182                 :             :     }
    1183                 :             : 
    1184                 :     3064130 :   rtx first = XVECEXP (op, 0, 0);
    1185                 :     8575952 :   for (int i = 1; i != GET_MODE_NUNITS (GET_MODE (op)); i++)
    1186                 :             :     {
    1187                 :     3802432 :       rtx tmp = XVECEXP (op, 0, i);
    1188                 :     3802432 :       if (!rtx_equal_p (tmp, first))
    1189                 :             :         return false;
    1190                 :             :     }
    1191                 :      485544 :   if (GET_MODE (first) == E_SFmode)
    1192                 :             :     {
    1193                 :      221025 :       long l;
    1194                 :      221025 :       REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (first), l);
    1195                 :      221025 :       return (l & 0xffffffff) == 0xffffffff;
    1196                 :             :     }
    1197                 :      264519 :   else if (GET_MODE (first) == E_DFmode)
    1198                 :             :     {
    1199                 :      259241 :       long l[2];
    1200                 :      259241 :       REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (first), l);
    1201                 :      259241 :       return ((l[0] & 0xffffffff) == 0xffffffff
    1202                 :      259241 :              && (l[1] & 0xffffffff) == 0xffffffff);
    1203                 :             :     }
    1204                 :             :   else
    1205                 :             :     return false;
    1206                 :             : })
    1207                 :             : 
    1208                 :             : /* Return true if operand is an integral vector constant that is all ones. */
    1209                 :    52784940 : (define_predicate "vector_all_ones_operand"
    1210                 :             :   (and (match_code "const_vector")
    1211                 :    65485970 :        (match_test "INTEGRAL_MODE_P (GET_MODE (op))")
    1212                 :    10845768 :        (match_test "op == CONSTM1_RTX (GET_MODE (op))")))
    1213                 :      778661 : 
    1214                 :    16039440 : /* Return true if operand is a vector constant that is all ones. */
    1215                 :    16039440 : (define_predicate "int_float_vector_all_ones_operand"
    1216                 :             :   (ior (match_operand 0 "vector_all_ones_operand")
    1217                 :     8282108 :        (match_operand 0 "float_vector_all_ones_operand")
    1218                 :           0 :        (match_test "op == constm1_rtx")))
    1219                 :     8282108 : 
    1220                 :    16039440 : /* Return true if operand is an 128/256bit all ones vector
    1221                 :        3384 :    that zero-extends to 256/512bit.  */
    1222                 :             : (define_predicate "vector_all_ones_zero_extend_half_operand"
    1223                 :    11518899 :   (match_code "const_vector")
    1224                 :             : {
    1225                 :   147072695 :   mode = GET_MODE (op);
    1226                 :    11518899 :   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
    1227                 :   156932600 :       || (GET_MODE_SIZE (mode) != 32
    1228                 :     9591893 :           && GET_MODE_SIZE (mode) != 64))
    1229                 :             :     return false;
    1230                 :             : 
    1231                 :      412976 :   int nelts = CONST_VECTOR_NUNITS (op);
    1232                 :      455660 :   for (int i = 0; i != nelts; i++)
    1233                 :             :     {
    1234                 :      454728 :       rtx elt = CONST_VECTOR_ELT (op, i);
    1235                 :      454728 :       if (i < nelts / 2
    1236                 :      903030 :           && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
    1237                 :             :         return false;
    1238                 :       47175 :       if (i >= nelts / 2
    1239                 :       53601 :           && elt != CONST0_RTX (GET_MODE_INNER (mode)))
    1240                 :             :         return false;
    1241                 :             :     }
    1242                 :             :   return true;
    1243                 :             : })
    1244                 :             : 
    1245                 :             : /* Return true if operand is an 128bit all ones vector
    1246                 :   148947211 :    that zero extends to 512bit.  */
    1247                 :             : (define_predicate "vector_all_ones_zero_extend_quarter_operand"
    1248                 :    11518899 :   (match_code "const_vector")
    1249                 :   148948143 : {
    1250                 :         932 :   mode = GET_MODE (op);
    1251                 :    11517967 :   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
    1252                 :     9858973 :       || GET_MODE_SIZE (mode) != 64)
    1253                 :             :     return false;
    1254                 :    11517967 : 
    1255                 :      144760 :   int nelts = CONST_VECTOR_NUNITS (op);
    1256                 :      156554 :   for (int i = 0; i != nelts; i++)
    1257                 :             :     {
    1258                 :      156468 :       rtx elt = CONST_VECTOR_ELT (op, i);
    1259                 :      156468 :       if (i < nelts / 4
    1260                 :      309748 :           && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
    1261                 :             :         return false;
    1262                 :       14166 :       if (i >= nelts / 4
    1263                 :       17354 :           && elt != CONST0_RTX (GET_MODE_INNER (mode)))
    1264                 :             :         return false;
    1265                 :             :     }
    1266                 :             :   return true;
    1267                 :             : })
    1268                 :             : 
    1269                 :             : ; Return true when OP is operand acceptable for vector memory operand.
    1270                 :   148946279 : ; Only AVX can have misaligned memory operand.
    1271                 :             : (define_predicate "vector_memory_operand"
    1272                 :    11517967 :   (and (match_operand 0 "memory_operand")
    1273                 :   150070265 :        (ior (match_test "TARGET_AVX")
    1274                 :     1123986 :             (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)"))))
    1275                 :             : 
    1276                 :             : ; Return true when OP is register_operand or vector_memory_operand.
    1277                 :             : (define_predicate "vector_operand"
    1278                 :    17446809 :   (ior (match_operand 0 "register_operand")
    1279                 :             :        (match_operand 0 "vector_memory_operand")))
    1280                 :    17446809 : 
    1281                 :             : ; Return true when OP is register_operand, vector_memory_operand
    1282                 :             : ; or const_vector.
    1283                 :             : (define_predicate "vector_or_const_vector_operand"
    1284                 :       12308 :   (ior (match_operand 0 "register_operand")
    1285                 :             :        (match_operand 0 "vector_memory_operand")
    1286                 :       12308 :        (match_code "const_vector")))
    1287                 :        7080 : 
    1288                 :             : ; Return true when OP is register_operand, vector_memory_operand,
    1289                 :             : ; const_vector zero or const_vector all ones.
    1290                 :             : (define_predicate "vector_or_0_or_1s_operand"
    1291                 :        3691 :   (ior (match_operand 0 "register_operand")
    1292                 :             :        (match_operand 0 "vector_memory_operand")
    1293                 :        3691 :        (match_operand 0 "const0_operand")
    1294                 :             :        (match_operand 0 "int_float_vector_all_ones_operand")))
    1295                 :             : 
    1296                 :             : (define_predicate "bcst_mem_operand"
    1297                 :   162875622 :   (and (match_code "vec_duplicate")
    1298                 :        9632 :        (and (match_test "TARGET_AVX512F")
    1299                 :       89851 :             (ior (match_test "TARGET_AVX512VL")
    1300                 :        8704 :                  (match_test "GET_MODE_SIZE (GET_MODE (op)) == 64")))
    1301                 :       30510 :        (match_test "VALID_BCST_MODE_P (GET_MODE_INNER (GET_MODE (op)))")
    1302                 :        8837 :        (match_test "GET_MODE (XEXP (op, 0))
    1303                 :       26495 :                     == GET_MODE_INNER (GET_MODE (op))")
    1304                 :   162889802 :        (match_test "memory_operand (XEXP (op, 0), GET_MODE (XEXP (op, 0)))")))
    1305                 :        5359 : 
    1306                 :             : ; Return true when OP is bcst_mem_operand or vector_memory_operand.
    1307                 :             : (define_predicate "bcst_vector_operand"
    1308                 :             :   (ior (match_operand 0 "vector_operand")
    1309                 :     4814603 :        (match_operand 0 "bcst_mem_operand")))
    1310                 :             : 
    1311                 :     4814603 : ;; Return true when OP is either nonimmediate operand, or any
    1312                 :             : ;; CONST_VECTOR.
    1313                 :             : (define_predicate "nonimmediate_or_const_vector_operand"
    1314                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1315                 :       78196 :        (match_code "const_vector")))
    1316                 :             : 
    1317                 :       78196 : (define_predicate "nonimmediate_or_const_vec_dup_operand"
    1318                 :       10669 :   (ior (match_operand 0 "nonimmediate_operand")
    1319                 :          58 :        (match_test "const_vec_duplicate_p (op)")))
    1320                 :          58 : 
    1321                 :             : ;; Return true when OP is either register operand, or any
    1322                 :         106 : ;; CONST_VECTOR.
    1323                 :             : (define_predicate "reg_or_const_vector_operand"
    1324                 :         106 :   (ior (match_operand 0 "register_operand")
    1325                 :             :        (match_code "const_vector")))
    1326                 :         240 : 
    1327                 :         153 : ;; Return true when OP is CONST_VECTOR which can be converted to a
    1328                 :             : ;; sign extended 32-bit integer.
    1329                 :             : (define_predicate "x86_64_const_vector_operand"
    1330                 :             :   (match_code "const_vector")
    1331                 :      174440 : {
    1332                 :      174440 :   if (mode == VOIDmode)
    1333                 :           0 :     mode = GET_MODE (op);
    1334                 :      174440 :   else if (GET_MODE (op) != mode)
    1335                 :             :     return false;
    1336                 :      409528 :   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
    1337                 :             :     return false;
    1338                 :      131615 :   HOST_WIDE_INT val = ix86_convert_const_vector_to_integer (op, mode);
    1339                 :      131615 :   return trunc_int_for_mode (val, SImode) == val;
    1340                 :             : })
    1341                 :             : 
    1342                 :             : (define_predicate "nonimmediate_or_x86_64_const_vector_operand"
    1343                 :     1516056 :   (ior (match_operand 0 "nonimmediate_operand")
    1344                 :             :        (match_operand 0 "x86_64_const_vector_operand")))
    1345                 :      174440 : 
    1346                 :     1633698 : ;; Return true when OP is nonimmediate or standard SSE constant.
    1347                 :      117642 : (define_predicate "nonimmediate_or_sse_const_operand"
    1348                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1349                 :    22100144 :        (match_test "standard_sse_constant_p (op, mode)")))
    1350                 :     2144657 : 
    1351                 :        3976 : ;; Return true if OP is a register or a zero.
    1352                 :             : (define_predicate "reg_or_0_operand"
    1353                 :        3976 :   (ior (match_operand 0 "register_operand")
    1354                 :      579475 :        (match_operand 0 "const0_operand")))
    1355                 :             : 
    1356                 :      579475 : ; Return true when OP is a nonimmediate or zero.
    1357                 :    92213237 : (define_predicate "nonimm_or_0_operand"
    1358                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1359                 :   112168724 :        (match_operand 0 "const0_operand")))
    1360                 :    73715124 : 
    1361                 :             : ; Return true when OP is a nonimmediate or zero or all ones.
    1362                 :    73715124 : (define_predicate "nonimm_or_0_or_1s_operand"
    1363                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1364                 :             :        (match_operand 0 "const0_operand")
    1365                 :             :        (match_operand 0 "int_float_vector_all_ones_operand")))
    1366                 :      101928 : 
    1367                 :             : ;; Return true for RTX codes that force SImode address.
    1368                 :      101928 : (define_predicate "SImode_address_operand"
    1369                 :             :   (match_code "subreg,zero_extend,and"))
    1370                 :             : 
    1371                 :             : ;; Return true if op is a valid address for LEA, and does not contain
    1372                 :   258800557 : ;; a segment override.  Defined as a special predicate to allow
    1373                 :             : ;; mode-less const_int operands pass to address_operand.
    1374                 :   258800557 : (define_special_predicate "address_no_seg_operand"
    1375                 :   176889295 :   (match_test "address_operand (op, VOIDmode)")
    1376                 :    63850584 : {
    1377                 :    64322238 :   struct ix86_address parts;
    1378                 :    64322238 :   int ok;
    1379                 :      471654 : 
    1380                 :    63890429 :   if (!CONST_INT_P (op)
    1381                 :    60957945 :       && mode != VOIDmode
    1382                 :    60957945 :       && GET_MODE (op) != mode)
    1383                 :      471654 :     return false;
    1384                 :      471654 : 
    1385                 :    63850510 :   ok = ix86_decompose_address (op, &parts);
    1386                 :    63850510 :   gcc_assert (ok);
    1387                 :    63850510 :   return parts.seg == ADDR_SPACE_GENERIC;
    1388                 :    63850584 : })
    1389                 :             : 
    1390                 :             : ;; Return true if op if a valid base register, displacement or
    1391                 :   113038711 : ;; sum of base register and displacement for VSIB addressing.
    1392                 :             : (define_predicate "vsib_address_operand"
    1393                 :   113078556 :   (match_test "address_operand (op, VOIDmode)")
    1394                 :       80451 : {
    1395                 :       38406 :   struct ix86_address parts;
    1396                 :       39845 :   int ok;
    1397                 :       39845 :   rtx disp;
    1398                 :             : 
    1399                 :       39845 :   ok = ix86_decompose_address (op, &parts);
    1400                 :       39845 :   gcc_assert (ok);
    1401                 :       66828 :   if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
    1402                 :       26983 :     return false;
    1403                 :             : 
    1404                 :             :   /* VSIB addressing doesn't support (%rip).  */
    1405                 :       39825 :   if (parts.disp)
    1406                 :    26114225 :     {
    1407                 :        7804 :       disp = parts.disp;
    1408                 :        7804 :       if (GET_CODE (disp) == CONST)
    1409                 :             :         {
    1410                 :         151 :           disp = XEXP (disp, 0);
    1411                 :         151 :           if (GET_CODE (disp) == PLUS)
    1412                 :         151 :             disp = XEXP (disp, 0);
    1413                 :         151 :           if (GET_CODE (disp) == UNSPEC)
    1414                 :           0 :             switch (XINT (disp, 1))
    1415                 :             :               {
    1416                 :             :               case UNSPEC_GOTPCREL:
    1417                 :             :               case UNSPEC_PCREL:
    1418                 :             :               case UNSPEC_GOTNTPOFF:
    1419                 :             :                 return false;
    1420                 :             :               }
    1421                 :             :         }
    1422                 :        7804 :       if (TARGET_64BIT
    1423                 :        7804 :           && flag_pic
    1424                 :           0 :           && (GET_CODE (disp) == SYMBOL_REF
    1425                 :           0 :               || GET_CODE (disp) == LABEL_REF))
    1426                 :           0 :         return false;
    1427                 :             :     }
    1428                 :             : 
    1429                 :             :   return true;
    1430                 :             : })
    1431                 :             : 
    1432                 :             : (define_predicate "vsib_mem_operator"
    1433                 :       40626 :   (match_code "mem"))
    1434                 :             : 
    1435                 :       40626 : ;; Return true if the rtx is known to be at least 32 bits aligned.
    1436                 :             : (define_predicate "aligned_operand"
    1437                 :             :   (match_operand 0 "general_operand")
    1438                 :             : {
    1439                 :    26114225 :   struct ix86_address parts;
    1440                 :    26114225 :   int ok;
    1441                 :             : 
    1442                 :             :   /* Registers and immediate operands are always "aligned".  */
    1443                 :    26114225 :   if (!MEM_P (op))
    1444                 :             :     return true;
    1445                 :             : 
    1446                 :             :   /* All patterns using aligned_operand on memory operands ends up
    1447                 :             :      in promoting memory operand to 64bit and thus causing memory mismatch.  */
    1448                 :     7185434 :   if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
    1449                 :             :     return false;
    1450                 :             : 
    1451                 :             :   /* Don't even try to do any aligned optimizations with volatiles.  */
    1452                 :      140404 :   if (MEM_VOLATILE_P (op))
    1453                 :             :     return false;
    1454                 :             : 
    1455                 :      127438 :   if (MEM_ALIGN (op) >= 32)
    1456                 :             :     return true;
    1457                 :             : 
    1458                 :       46060 :   op = XEXP (op, 0);
    1459                 :             : 
    1460                 :             :   /* Pushes and pops are only valid on the stack pointer.  */
    1461                 :       46060 :   if (GET_CODE (op) == PRE_DEC
    1462                 :       46060 :       || GET_CODE (op) == POST_INC)
    1463                 :             :     return true;
    1464                 :             : 
    1465                 :             :   /* Decode the address.  */
    1466                 :       46060 :   ok = ix86_decompose_address (op, &parts);
    1467                 :       46060 :   gcc_assert (ok);
    1468                 :             : 
    1469                 :       46060 :   if (parts.base && SUBREG_P (parts.base))
    1470                 :           0 :     parts.base = SUBREG_REG (parts.base);
    1471                 :       46060 :   if (parts.index && SUBREG_P (parts.index))
    1472                 :           0 :     parts.index = SUBREG_REG (parts.index);
    1473                 :             : 
    1474                 :             :   /* Look for some component that isn't known to be aligned.  */
    1475                 :       46060 :   if (parts.index)
    1476                 :             :     {
    1477                 :        3745 :       if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
    1478                 :             :         return false;
    1479                 :             :     }
    1480                 :       42315 :   if (parts.base)
    1481                 :             :     {
    1482                 :       35429 :       if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
    1483                 :             :         return false;
    1484                 :             :     }
    1485                 :       13788 :   if (parts.disp)
    1486                 :             :     {
    1487                 :       13788 :       if (!CONST_INT_P (parts.disp)
    1488                 :        7010 :           || (INTVAL (parts.disp) & 3))
    1489                 :             :         return false;
    1490                 :             :     }
    1491                 :             : 
    1492                 :             :   /* Didn't find one -- this must be an aligned address.  */
    1493                 :             :   return true;
    1494                 :             : })
    1495                 :             : 
    1496                 :             : ;; Return true if OP is memory operand with a displacement.
    1497                 :    26671630 : (define_predicate "memory_displacement_operand"
    1498                 :             :   (match_operand 0 "memory_operand")
    1499                 :    52785855 : {
    1500                 :    26114225 :   struct ix86_address parts;
    1501                 :           0 :   int ok;
    1502                 :             : 
    1503                 :           0 :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1504                 :           0 :   gcc_assert (ok);
    1505                 :           0 :   return parts.disp != NULL_RTX;
    1506                 :             : })
    1507                 :             : 
    1508                 :             : ;; Return true if OP is memory operand with a displacement only.
    1509                 :           0 : (define_predicate "memory_displacement_only_operand"
    1510                 :             :   (match_operand 0 "memory_operand")
    1511                 :           0 : {
    1512                 :           0 :   struct ix86_address parts;
    1513                 :    39006039 :   int ok;
    1514                 :             : 
    1515                 :    39006039 :   if (TARGET_64BIT)
    1516                 :    39006039 :     return false;
    1517                 :             : 
    1518                 :    18809874 :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1519                 :    18809874 :   gcc_assert (ok);
    1520                 :             : 
    1521                 :    18809874 :   if (parts.base || parts.index)
    1522                 :             :     return false;
    1523                 :             : 
    1524                 :      237219 :   return parts.disp != NULL_RTX;
    1525                 :             : })
    1526                 :             : 
    1527                 :             : ;; Return true if OP is memory operand that cannot be represented
    1528                 :    60307040 : ;; by the modRM array.
    1529                 :             : (define_predicate "long_memory_operand"
    1530                 :    99313079 :   (and (match_operand 0 "memory_operand")
    1531                 :    39006039 :        (match_test "memory_address_length (op, false)")))
    1532                 :             : 
    1533                 :             : ;; Return true if OP is a comparison operator that can be issued by fcmov.
    1534                 :             : (define_predicate "fcmov_comparison_operator"
    1535                 :       84044 :   (match_operand 0 "comparison_operator")
    1536                 :             : {
    1537                 :           0 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1538                 :       84044 :   enum rtx_code code = GET_CODE (op);
    1539                 :             : 
    1540                 :       84044 :   if (inmode == CCFPmode)
    1541                 :        8501 :     code = ix86_fp_compare_code_to_integer (code);
    1542                 :             : 
    1543                 :             :   /* i387 supports just limited amount of conditional codes.  */
    1544                 :       84044 :   switch (code)
    1545                 :             :     {
    1546                 :        2027 :     case GEU: case LTU:
    1547                 :        2027 :       if (inmode == CCCmode || inmode == CCGZmode)
    1548                 :             :         return true;
    1549                 :             :       /* FALLTHRU */
    1550                 :        6624 :     case GTU: case LEU:
    1551                 :        6624 :       if (inmode == CCmode || inmode == CCFPmode)
    1552                 :             :         return true;
    1553                 :             :       return false;
    1554                 :             :     case ORDERED: case UNORDERED:
    1555                 :             :     case EQ: case NE:
    1556                 :             :       return true;
    1557                 :             :     default:
    1558                 :             :       return false;
    1559                 :             :     }
    1560                 :             : })
    1561                 :             : 
    1562                 :             : ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
    1563                 :       84044 : ;; The first set are supported directly; the second set can't be done with
    1564                 :             : ;; full IEEE support, i.e. NaNs.
    1565                 :      168088 : 
    1566                 :       84044 : (define_predicate "sse_comparison_operator"
    1567                 :             :   (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered")
    1568                 :      131162 :        (and (match_test "TARGET_AVX")
    1569                 :      131162 :             (match_code "ge,gt,uneq,unle,unlt,ltgt"))))
    1570                 :      132574 : 
    1571                 :             : (define_predicate "ix86_comparison_int_operator"
    1572                 :      132574 :   (match_code "ne,eq,ge,gt,le,lt"))
    1573                 :      187793 : 
    1574                 :             : (define_predicate "ix86_comparison_uns_operator"
    1575                 :      187793 :   (match_code "ne,eq,geu,gtu,leu,ltu"))
    1576                 :             : 
    1577                 :      187793 : (define_predicate "bt_comparison_operator"
    1578                 :      187793 :   (match_code "ne,eq"))
    1579                 :      187793 : 
    1580                 :      187793 : (define_predicate "shr_comparison_operator"
    1581                 :      187793 :   (match_code "gtu,leu"))
    1582                 :      187793 : 
    1583                 :      187793 : (define_predicate "add_comparison_operator"
    1584                 :             :   (match_code "geu,ltu"))
    1585                 :             : 
    1586                 :             : ;; Return true if OP is a valid comparison operator in valid mode.
    1587                 :      187793 : (define_predicate "ix86_comparison_operator"
    1588                 :      187793 :   (match_operand 0 "comparison_operator")
    1589                 :             : {
    1590                 :    98244489 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1591                 :    98244489 :   enum rtx_code code = GET_CODE (op);
    1592                 :      103879 : 
    1593                 :    98244489 :   if (inmode == CCFPmode)
    1594                 :     6900979 :     return ix86_trivial_fp_comparison_operator (op, mode);
    1595                 :             : 
    1596                 :    91447389 :   switch (code)
    1597                 :      103879 :     {
    1598                 :    70774058 :     case EQ: case NE:
    1599                 :    70670179 :       if (inmode == CCGZmode)
    1600                 :           0 :         return false;
    1601                 :      103879 :       return true;
    1602                 :     4562818 :     case GE: case LT:
    1603                 :     4458939 :       if (inmode == CCmode || inmode == CCGCmode
    1604                 :     2258248 :           || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
    1605                 :     3940108 :         return true;
    1606                 :      103879 :       return false;
    1607                 :      103879 :     case GEU: case LTU:
    1608                 :     7100935 :       if (inmode == CCCmode || inmode == CCGZmode)
    1609                 :             :         return true;
    1610                 :             :       /* FALLTHRU */
    1611                 :    70161812 :     case GTU: case LEU:
    1612                 :     9841541 :       if (inmode == CCmode)
    1613                 :    69040990 :         return true;
    1614                 :             :       return false;
    1615                 :    49952169 :     case ORDERED: case UNORDERED:
    1616                 :        3562 :       if (inmode == CCmode)
    1617                 :        3167 :         return true;
    1618                 :             :       return false;
    1619                 :     5944865 :     case GT: case LE:
    1620                 :     5944865 :       if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
    1621                 :     5211226 :         return true;
    1622                 :    49948607 :       return false;
    1623                 :             :     default:
    1624                 :             :       return false;
    1625                 :             :     }
    1626                 :      732787 : })
    1627                 :             : 
    1628                 :      732787 : ;; Return true if OP is a valid comparison operator
    1629                 :   112456920 : ;; testing carry flag to be set.
    1630                 :      732787 : (define_predicate "ix86_carry_flag_operator"
    1631                 :   210701409 :   (match_code "ltu,unlt")
    1632                 :    98244489 : {
    1633                 :      818533 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1634                 :      818533 :   enum rtx_code code = GET_CODE (op);
    1635                 :             : 
    1636                 :      818533 :   if (inmode == CCFPmode)
    1637                 :      744536 :     code = ix86_fp_compare_code_to_integer (code);
    1638                 :      806784 :   else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
    1639                 :             :     return false;
    1640                 :             : 
    1641                 :      618127 :   return code == LTU;
    1642                 :             : })
    1643                 :     1268855 : 
    1644                 :             : ;; Return true if OP is a valid comparison operator
    1645                 :     4216628 : ;; testing carry flag to be unset.
    1646                 :     1268855 : (define_predicate "ix86_carry_flag_unset_operator"
    1647                 :     2947773 :   (match_code "geu,ge")
    1648                 :             : {
    1649                 :      819706 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1650                 :      819706 :   enum rtx_code code = GET_CODE (op);
    1651                 :     2087388 : 
    1652                 :     1268855 :   if (inmode == CCFPmode)
    1653                 :          66 :     code = ix86_fp_compare_code_to_integer (code);
    1654                 :        1107 :   else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
    1655                 :      818533 :     return false;
    1656                 :    99063022 : 
    1657                 :      426662 :   return code == GEU;
    1658                 :             : })
    1659                 :             : 
    1660                 :             : ;; Return true if this comparison only requires testing one flag bit.
    1661                 :     1901381 : ;; VCOMX/VUCOMX set ZF, SF, OF, differently from COMI/UCOMI.
    1662                 :             : (define_predicate "ix86_trivial_fp_comparison_operator"
    1663                 :    11139267 :   (if_then_else (match_test "TARGET_AVX10_2")
    1664                 :      655497 :                 (match_code "gt,ge,unlt,unle,eq,uneq,ne,ltgt,ordered,unordered")
    1665                 :        1173 :                 (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered")))
    1666                 :        1173 : 
    1667                 :        1173 : (define_predicate "ix86_trivial_fp_comparison_operator_xf"
    1668                 :     1355978 :   (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered"))
    1669                 :             : 
    1670                 :     1355978 : ;; Return true if we know how to do this comparison.  Others require
    1671                 :        1173 : ;; testing more than one flag bit, and we let the generic middle-end
    1672                 :      411578 : ;; code do that.
    1673                 :      411206 : (define_predicate "ix86_fp_comparison_operator"
    1674                 :     2852364 :   (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
    1675                 :     2441959 :                              == IX86_FPCMP_ARITH")
    1676                 :      410405 :                (match_operand 0 "comparison_operator")
    1677                 :     9649464 :                (match_operand 0 "ix86_trivial_fp_comparison_operator")))
    1678                 :      410405 : 
    1679                 :     9239059 : (define_predicate "ix86_fp_comparison_operator_xf"
    1680                 :     1766383 :   (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
    1681                 :     1355978 :                              == IX86_FPCMP_ARITH")
    1682                 :             :                (match_operand 0 "comparison_operator")
    1683                 :             :                (match_operand 0 "ix86_trivial_fp_comparison_operator_xf")))
    1684                 :      410405 : 
    1685                 :      410405 : ;; Return true if we can perform this comparison on TImode operands.
    1686                 :             : (define_predicate "ix86_timode_comparison_operator"
    1687                 :      349326 :   (if_then_else (match_test "TARGET_64BIT")
    1688                 :             :                 (match_operand 0 "ordered_comparison_operator")
    1689                 :     2441959 :                 (match_operand 0 "bt_comparison_operator")))
    1690                 :             : 
    1691                 :     2441959 : ;; Return true if this is a valid second operand for a TImode comparison.
    1692                 :             : (define_predicate "ix86_timode_comparison_operand"
    1693                 :      140338 :   (if_then_else (match_test "TARGET_64BIT")
    1694                 :             :                 (match_operand 0 "x86_64_general_operand")
    1695                 :             :                 (match_operand 0 "nonimmediate_operand")))
    1696                 :             : 
    1697                 :     2007434 : ;; Nearly general operand, but accept any const_double, since we wish
    1698                 :             : ;; to be able to drop them into memory rather than have them get pulled
    1699                 :      506717 : ;; into registers.
    1700                 :     2514151 : (define_predicate "cmp_fp_expander_operand"
    1701                 :             :   (ior (match_code "const_double")
    1702                 :             :        (match_operand 0 "general_operand")))
    1703                 :             : 
    1704                 :     4974273 : ;; Return true if this is a valid binary floating-point operation.
    1705                 :             : (define_predicate "binary_fp_operator"
    1706                 :     4974273 :   (match_code "plus,minus,mult,div"))
    1707                 :             : 
    1708                 :     4966366 : ;; Return true if this is a multiply operation.
    1709                 :     4966366 : (define_predicate "mult_operator"
    1710                 :     4966366 :   (match_code "mult"))
    1711                 :     4966366 : 
    1712                 :     4966366 : ;; Return true if this is a division operation.
    1713                 :             : (define_predicate "div_operator"
    1714                 :             :   (match_code "div"))
    1715                 :             : 
    1716                 :     4966366 : ;; Return true if this is a and, ior or xor operation.
    1717                 :     4966366 : (define_predicate "logic_operator"
    1718                 :             :   (match_code "and,ior,xor"))
    1719                 :             : 
    1720                 :             : ;; Return true if this is a plus, minus, and, ior or xor operation.
    1721                 :    17450474 : (define_predicate "plusminuslogic_operator"
    1722                 :             :   (match_code "plus,minus,and,ior,xor"))
    1723                 :    17450474 : 
    1724                 :     3663653 : ;; Return true for ARITHMETIC_P.
    1725                 :             : (define_predicate "arith_or_logical_operator"
    1726                 :             :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
    1727                 :             :                mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
    1728                 :     2627037 : 
    1729                 :             : ;; Return true for COMMUTATIVE_P.
    1730                 :     2627037 : (define_predicate "commutative_operator"
    1731                 :      940617 :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
    1732                 :             : 
    1733                 :             : ;; Return true if OP is a binary operator that can be promoted to wider mode.
    1734                 :             : (define_predicate "promotable_binary_operator"
    1735                 :           0 :   (ior (match_code "plus,minus,and,ior,xor,ashift")
    1736                 :             :        (and (match_code "mult")
    1737                 :    25428044 :             (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
    1738                 :           0 : 
    1739                 :           0 : (define_predicate "compare_operator"
    1740                 :           0 :   (match_code "compare"))
    1741                 :           0 : 
    1742                 :     7619706 : (define_predicate "extract_operator"
    1743                 :             :   (match_code "zero_extract,sign_extract"))
    1744                 :     7619706 : 
    1745                 :           0 : ;; Return true if OP is a memory operand, aligned to
    1746                 :           0 : ;; less than its natural alignment.
    1747                 :           0 : (define_predicate "misaligned_operand"
    1748                 :             :   (and (match_code "mem")
    1749                 :     5692795 :        (match_test "MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)")))
    1750                 :     1333005 : 
    1751                 :       55374 : ;; Return true if OP is a parallel for an mov{d,q,dqa,ps,pd} vec_select,
    1752                 :             : ;; where one of the two operands of the vec_concat is const0_operand.
    1753                 :      502920 : (define_predicate "movq_parallel"
    1754                 :     1317060 :   (match_code "parallel")
    1755                 :      554598 : {
    1756                 :     1760910 :   unsigned nelt = XVECLEN (op, 0);
    1757                 :     1760910 :   unsigned nelt2 = nelt >> 1;
    1758                 :     1760910 :   unsigned i;
    1759                 :      554598 : 
    1760                 :     1317060 :   if (nelt < 2)
    1761                 :             :     return false;
    1762                 :             : 
    1763                 :             :   /* Validate that all of the elements are constants,
    1764                 :     8400389 :      lower halves of permute are lower halves of the first operand,
    1765                 :      499224 :      upper halves of permute come from any of the second operand.  */
    1766                 :    14383451 :   for (i = 0; i < nelt; ++i)
    1767                 :             :     {
    1768                 :     2026908 :       rtx er = XVECEXP (op, 0, i);
    1769                 :     6341121 :       unsigned HOST_WIDE_INT ei;
    1770                 :             : 
    1771                 :     6341121 :       if (!CONST_INT_P (er))
    1772                 :             :         return false;
    1773                 :     6341121 :       ei = INTVAL (er);
    1774                 :     2026908 :       if (i < nelt2 && ei != i)
    1775                 :     4314213 :         return false;
    1776                 :      863347 :       if (i >= nelt2 && (ei < nelt || ei >= nelt << 1))
    1777                 :     4314213 :         return false;
    1778                 :     4314213 :     }
    1779                 :     4314213 : 
    1780                 :     4314213 :   return true;
    1781                 :     4314213 : })
    1782                 :     4314213 : 
    1783                 :     4314213 : ;; Return true if OP is a vzeroall operation, known to be a PARALLEL.
    1784                 :     5575899 : (define_predicate "vzeroall_operation"
    1785                 :     4314213 :   (match_code "parallel")
    1786                 :     6837585 : {
    1787                 :     1261705 :   unsigned i, nregs = TARGET_64BIT ? 16 : 8;
    1788                 :           0 : 
    1789                 :        5260 :   if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
    1790                 :     4314213 :     return false;
    1791                 :     4314213 : 
    1792                 :       94528 :   for (i = 0; i < nregs; i++)
    1793                 :     4314213 :     {
    1794                 :       84008 :       rtx elt = XVECEXP (op, 0, i+1);
    1795                 :             : 
    1796                 :       84008 :       if (GET_CODE (elt) != SET
    1797                 :       84008 :           || GET_CODE (SET_DEST (elt)) != REG
    1798                 :     4398221 :           || GET_MODE (SET_DEST (elt)) != V8SImode
    1799                 :       84008 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    1800                 :      168016 :           || SET_SRC (elt) != CONST0_RTX (V8SImode))
    1801                 :             :         return false;
    1802                 :      939162 :     }
    1803                 :             :   return true;
    1804                 :      939162 : })
    1805                 :             : 
    1806                 :      332168 : ;; return true if OP is a vzeroall pattern.
    1807                 :      337428 : (define_predicate "vzeroall_pattern"
    1808                 :      332168 :   (and (match_code "parallel")
    1809                 :      342688 :        (match_code "unspec_volatile" "a")
    1810                 :        5412 :        (match_test "XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROALL")))
    1811                 :           0 : 
    1812                 :      332168 : ;; return true if OP is a vzeroupper pattern.
    1813                 :      332168 : (define_predicate "vzeroupper_pattern"
    1814                 :      332168 :   (and (match_code "parallel")
    1815                 :   251996589 :        (match_code "unspec" "b")
    1816                 :      813522 :        (match_test "XINT (XVECEXP (op, 0, 1), 1) == UNSPEC_CALLEE_ABI")
    1817                 :   251664421 :        (match_test "INTVAL (XVECEXP (XVECEXP (op, 0, 1), 0, 0)) == ABI_VZEROUPPER")))
    1818                 :           0 : 
    1819                 :      332168 : ;; Return true if OP is an addsub vec_merge operation
    1820                 :      332168 : (define_predicate "addsub_vm_operator"
    1821                 :             :   (match_code "vec_merge")
    1822                 :        4396 : {
    1823                 :        4396 :   rtx op0, op1;
    1824                 :    25432440 :   int swapped;
    1825                 :        4396 :   HOST_WIDE_INT mask;
    1826                 :    25428044 :   int nunits, elt;
    1827                 :             : 
    1828                 :        4396 :   op0 = XEXP (op, 0);
    1829                 :        4396 :   op1 = XEXP (op, 1);
    1830                 :             : 
    1831                 :             :   /* Sanity check.  */
    1832                 :        4396 :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1833                 :             :     swapped = 0;
    1834                 :        2468 :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1835                 :             :     swapped = 1;
    1836                 :             :   else
    1837                 :           0 :     gcc_unreachable ();
    1838                 :             : 
    1839                 :        4396 :   mask = INTVAL (XEXP (op, 2));
    1840                 :        4396 :   nunits = GET_MODE_NUNITS (mode);
    1841                 :             : 
    1842                 :       17434 :   for (elt = 0; elt < nunits; elt++)
    1843                 :             :     {
    1844                 :             :       /* bit clear: take from op0, set: take from op1  */
    1845                 :       13249 :       int bit = !(mask & (HOST_WIDE_INT_1U << elt));
    1846                 :             : 
    1847                 :       13249 :       if (bit != ((elt & 1) ^ swapped))
    1848                 :             :         return false;
    1849                 :             :     }
    1850                 :             : 
    1851                 :             :   return true;
    1852                 :             : })
    1853                 :             : 
    1854                 :             : ;; Return true if OP is an addsub vec_select/vec_concat operation
    1855                 :        4396 : (define_predicate "addsub_vs_operator"
    1856                 :             :   (and (match_code "vec_select")
    1857                 :        4396 :        (match_code "vec_concat" "0"))
    1858                 :        8581 : {
    1859                 :        4185 :   rtx op0, op1;
    1860                 :           0 :   bool swapped;
    1861                 :           0 :   int nunits, elt;
    1862                 :             : 
    1863                 :           0 :   op0 = XEXP (XEXP (op, 0), 0);
    1864                 :           0 :   op1 = XEXP (XEXP (op, 0), 1);
    1865                 :             : 
    1866                 :             :   /* Sanity check.  */
    1867                 :           0 :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1868                 :             :     swapped = false;
    1869                 :           0 :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1870                 :             :     swapped = true;
    1871                 :             :   else
    1872                 :           0 :     gcc_unreachable ();
    1873                 :             : 
    1874                 :           0 :   nunits = GET_MODE_NUNITS (mode);
    1875                 :           0 :   if (XVECLEN (XEXP (op, 1), 0) != nunits)
    1876                 :             :     return false;
    1877                 :             : 
    1878                 :             :   /* We already checked that permutation is suitable for addsub,
    1879                 :             :      so only look at the first element of the parallel.  */
    1880                 :           0 :   elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
    1881                 :             : 
    1882                 :           0 :   return elt == (swapped ? nunits : 0);
    1883                 :             : })
    1884                 :             : 
    1885                 :             : ;; Return true if OP is a parallel for an addsub vec_select.
    1886                 :           0 : (define_predicate "addsub_vs_parallel"
    1887                 :             :   (and (match_code "parallel")
    1888                 :           0 :        (match_code "const_int" "a"))
    1889                 :           0 : {
    1890                 :           0 :   int nelt = XVECLEN (op, 0);
    1891                 :         548 :   int elt, i;
    1892                 :             :   
    1893                 :         548 :   if (nelt < 2)
    1894                 :         548 :     return false;
    1895                 :             : 
    1896                 :             :   /* Check that the permutation is suitable for addsub.
    1897                 :             :      For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }.  */
    1898                 :         548 :   elt = INTVAL (XVECEXP (op, 0, 0));
    1899                 :         548 :   if (elt == 0)
    1900                 :             :     {
    1901                 :         428 :       for (i = 1; i < nelt; ++i)
    1902                 :         428 :         if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
    1903                 :             :           return false;
    1904                 :             :     }
    1905                 :         120 :   else if (elt == nelt)
    1906                 :             :     {
    1907                 :           0 :       for (i = 1; i < nelt; ++i)
    1908                 :           0 :         if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
    1909                 :             :           return false;
    1910                 :             :     }
    1911                 :             :   else
    1912                 :             :     return false;
    1913                 :             : 
    1914                 :             :   return true;
    1915                 :             : })
    1916                 :             : 
    1917                 :             : ;; Return true if OP is a constant pool in perm{w,d,b} which constains index
    1918                 :         548 : ;; match pmov{dw,wb,qd}.
    1919                 :             : (define_predicate "permvar_truncate_operand"
    1920                 :         548 :  (match_code "mem")
    1921                 :        1096 : {
    1922                 :           0 :   int nelt = GET_MODE_NUNITS (mode);
    1923                 :          16 :   int perm[128];
    1924                 :          16 :   int id;
    1925                 :             : 
    1926                 :          32 :   if (!INTEGRAL_MODE_P (mode) || !VECTOR_MODE_P (mode))
    1927                 :             :     return false;
    1928                 :             : 
    1929                 :          16 :   if (nelt < 2)
    1930                 :             :     return false;
    1931                 :             : 
    1932                 :          16 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1933                 :             :     return false;
    1934                 :             : 
    1935                 :          16 :   id = exact_log2 (nelt);
    1936                 :             : 
    1937                 :             :   /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
    1938                 :             :      For example V16HImode to V8HImode
    1939                 :             :      { 0 2 4 6 8 10 12 14 * * * * * * * * }.  */
    1940                 :         232 :   for (int i = 0; i != nelt / 2; i++)
    1941                 :         216 :     if ((perm[i] & ((1 << id) - 1)) != i * 2)
    1942                 :             :       return false;
    1943                 :             : 
    1944                 :             :   return true;
    1945                 :             : })
    1946                 :             : 
    1947                 :             : ;; Return true if OP is a constant pool in shufb which constains index
    1948                 :          33 : ;; match pmovdw.
    1949                 :             : (define_predicate "pshufb_truncv4siv4hi_operand"
    1950                 :          16 :  (match_code "mem")
    1951                 :          49 : {
    1952                 :          16 :   int perm[128];
    1953                 :             : 
    1954                 :           8 :   if (mode != E_V16QImode)
    1955                 :             :     return false;
    1956                 :           8 : 
    1957                 :           8 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1958                 :             :     return false;
    1959                 :             : 
    1960                 :             :   /* Check that the permutation is suitable for pmovdw.
    1961                 :             :      For example V4SImode to V4HImode
    1962                 :             :      { 0 1 4 5 8 9 12 13 * * * * * * * * }.
    1963                 :             :      index = i % 2 + (i / 2) * 4.  */
    1964                 :          58 :   for (int i = 0; i != 8; i++)
    1965                 :             :     {
    1966                 :             :       /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0;  */
    1967                 :          52 :       if (perm[i] & 128)
    1968                 :             :         return false;
    1969                 :             : 
    1970                 :          52 :       if ((perm[i] & 15) != ((i & 1) + (i & 0xFE) * 2))
    1971                 :             :         return false;
    1972                 :             :      }
    1973                 :             : 
    1974                 :             :   return true;
    1975                 :             : })
    1976                 :             : 
    1977                 :             : ;; Return true if OP is a constant pool in shufb which constains index
    1978                 :          11 : ;; match pmovdw.
    1979                 :             : (define_predicate "pshufb_truncv8hiv8qi_operand"
    1980                 :           8 :  (match_code "mem")
    1981                 :          17 : {
    1982                 :           6 :   int perm[128];
    1983                 :             : 
    1984                 :          11 :   if (mode != E_V16QImode)
    1985                 :             :     return false;
    1986                 :          11 : 
    1987                 :          11 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1988                 :             :     return false;
    1989                 :             : 
    1990                 :             :   /* Check that the permutation is suitable for pmovwb.
    1991                 :             :      For example V16QImode to V8QImode
    1992                 :             :      { 0 2 4 6 8 10 12 14 * * * * * * * * }.
    1993                 :             :      index = i % 2 + (i / 2) * 4.  */
    1994                 :          57 :   for (int i = 0; i != 8; i++)
    1995                 :             :     {
    1996                 :             :       /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0;  */
    1997                 :          52 :       if (perm[i] & 128)
    1998                 :             :         return false;
    1999                 :             : 
    2000                 :          52 :       if ((perm[i] & 15) != i * 2)
    2001                 :             :          return false;
    2002                 :             :     }
    2003                 :             : 
    2004                 :             :   return true;
    2005                 :             : })
    2006                 :             : 
    2007                 :             : ;; Return true if OP is a parallel for an pmovz{bw,wd,dq} vec_select,
    2008                 :          14 : ;; where one of the two operands of the vec_concat is const0_operand.
    2009                 :             : (define_predicate "pmovzx_parallel"
    2010                 :          11 :   (and (match_code "parallel")
    2011                 :          19 :        (match_code "const_int" "a"))
    2012                 :           5 : {
    2013                 :     1329000 :   int nelt = XVECLEN (op, 0);
    2014                 :     1329000 :   int elt, i;
    2015                 :             : 
    2016                 :     1329000 :   if (nelt < 2)
    2017                 :             :     return false;
    2018                 :             : 
    2019                 :             :   /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
    2020                 :             :      For example { 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23 }.  */
    2021                 :     1329000 :   elt = INTVAL (XVECEXP (op, 0, 0));
    2022                 :     1329000 :   if (elt == 0)
    2023                 :             :     {
    2024                 :     2953316 :       for (i = 1; i < nelt; ++i)
    2025                 :     2539814 :         if ((i & 1) != 0)
    2026                 :             :           {
    2027                 :     1606031 :             if (INTVAL (XVECEXP (op, 0, i)) < nelt)
    2028                 :             :               return false;
    2029                 :             :           }
    2030                 :      933783 :         else if (INTVAL (XVECEXP (op, 0, i)) != i / 2)
    2031                 :             :           return false;
    2032                 :             :     }
    2033                 :             :   else
    2034                 :             :     return false;
    2035                 :             : 
    2036                 :             :   return true;
    2037                 :             : })
    2038                 :             : 
    2039                 :             : ;; Return true if OP is a const vector with duplicate value.
    2040                 :     1329000 : (define_predicate "const_vector_duplicate_operand"
    2041                 :             :   (match_code "const_vector")
    2042                 :     1329000 : {
    2043                 :     2658000 :   rtx elt = XVECEXP (op, 0, 0);
    2044                 :           0 :   int i, nelt = XVECLEN (op, 0);
    2045                 :             : 
    2046                 :          96 :   for (i = 1; i < nelt; ++i)
    2047                 :          93 :     if (!rtx_equal_p (elt, XVECEXP (op, 0, i)))
    2048                 :           3 :       return false;
    2049                 :             :   return true;
    2050                 :             : })
    2051                 :             : 
    2052                 :             : ;; Return true if OP is a parallel for a vbroadcast permute.
    2053                 :           3 : (define_predicate "avx_vbroadcast_operand"
    2054                 :             :   (and (match_code "parallel")
    2055                 :           3 :        (match_code "const_int" "a"))
    2056                 :           6 : {
    2057                 :           3 :   rtx elt = XVECEXP (op, 0, 0);
    2058                 :      388289 :   int i, nelt = XVECLEN (op, 0);
    2059                 :             : 
    2060                 :             :   /* Don't bother checking there are the right number of operands,
    2061                 :      388289 :      merely that they're all identical.  */
    2062                 :      470159 :   for (i = 1; i < nelt; ++i)
    2063                 :      243746 :     if (XVECEXP (op, 0, i) != elt)
    2064                 :             :       return false;
    2065                 :             :   return true;
    2066                 :             : })
    2067                 :             : 
    2068                 :             : ;; Return true if OP is a parallel for a palignr permute.
    2069                 :      388289 : (define_predicate "palignr_operand"
    2070                 :             :   (and (match_code "parallel")
    2071                 :      388289 :        (match_code "const_int" "a"))
    2072                 :      776578 : {
    2073                 :           0 :   int elt = INTVAL (XVECEXP (op, 0, 0));
    2074                 :       27533 :   int i, nelt = XVECLEN (op, 0);
    2075                 :             : 
    2076                 :             :   /* Check that an order in the permutation is suitable for palignr.
    2077                 :       27533 :      For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm".  */
    2078                 :       59824 :   for (i = 1; i < nelt; ++i)
    2079                 :       56950 :     if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
    2080                 :             :       return false;
    2081                 :             :   return true;
    2082                 :             : })
    2083                 :             : 
    2084                 :             : ;; Return true if OP is a proper third operand to vpblendw256.
    2085                 :       27533 : (define_predicate "avx2_pblendw_operand"
    2086                 :             :   (match_code "const_int")
    2087                 :       27533 : {
    2088                 :       55066 :   HOST_WIDE_INT val = INTVAL (op);
    2089                 :           0 :   HOST_WIDE_INT low = val & 0xff;
    2090                 :        6628 :   return val == ((low << 8) | low);
    2091                 :             : })
    2092                 :             : 
    2093                 :        6628 : ;; Return true if OP is vector_operand or CONST_VECTOR.
    2094                 :        6628 : (define_predicate "general_vector_operand"
    2095                 :             :   (ior (match_operand 0 "vector_operand")
    2096                 :        6628 :        (match_code "const_vector")))
    2097                 :        6628 : 
    2098                 :             : ;; Return true if OP is either -1 constant or stored in register.
    2099                 :             : (define_predicate "register_or_constm1_operand"
    2100                 :             :   (ior (match_operand 0 "register_operand")
    2101                 :       12074 :        (and (match_code "const_int")
    2102                 :           0 :             (match_test "op == constm1_rtx"))))
    2103                 :       12074 : 
    2104                 :        2308 : ;; Return true if the vector ends with between 12 and 18 register saves using
    2105                 :             : ;; RAX as the base address.
    2106                 :             : (define_predicate "save_multiple"
    2107                 :      211867 :   (match_code "parallel")
    2108                 :        1324 : {
    2109                 :      211867 :   const unsigned len = XVECLEN (op, 0);
    2110                 :        1324 :   unsigned i;
    2111                 :             : 
    2112                 :             :   /* Starting from end of vector, count register saves.  */
    2113                 :      304700 :   for (i = 0; i < len; ++i)
    2114                 :             :     {
    2115                 :      304700 :       rtx src, dest, addr;
    2116                 :      304700 :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2117                 :             : 
    2118                 :      304700 :       if (GET_CODE (e) != SET)
    2119                 :             :         break;
    2120                 :             : 
    2121                 :      297655 :       src  = SET_SRC (e);
    2122                 :      297655 :       dest = SET_DEST (e);
    2123                 :             : 
    2124                 :      297655 :       if (!REG_P (src) || !MEM_P (dest))
    2125                 :             :         break;
    2126                 :             : 
    2127                 :       92833 :       addr = XEXP (dest, 0);
    2128                 :             : 
    2129                 :             :       /* Good if dest address is in RAX.  */
    2130                 :       92833 :       if (REG_P (addr) && REGNO (addr) == AX_REG)
    2131                 :        4202 :         continue;
    2132                 :             : 
    2133                 :             :       /* Good if dest address is offset of RAX.  */
    2134                 :      177262 :       if (GET_CODE (addr) == PLUS
    2135                 :       88631 :           && REG_P (XEXP (addr, 0))
    2136                 :      177262 :           && REGNO (XEXP (addr, 0)) == AX_REG)
    2137                 :       88631 :         continue;
    2138                 :             : 
    2139                 :             :       break;
    2140                 :             :     }
    2141                 :      211867 :   return (i >= 12 && i <= 18);
    2142                 :             : })
    2143                 :             : 
    2144                 :             : 
    2145                 :      211867 : ;; Return true if the vector ends with between 12 and 18 register loads using
    2146                 :             : ;; RSI as the base address.
    2147                 :      423734 : (define_predicate "restore_multiple"
    2148                 :      211867 :   (match_code "parallel")
    2149                 :           0 : {
    2150                 :     8155774 :   const unsigned len = XVECLEN (op, 0);
    2151                 :     8155774 :   unsigned i;
    2152                 :             : 
    2153                 :     8155774 :   /* Starting from end of vector, count register restores.  */
    2154                 :     8262352 :   for (i = 0; i < len; ++i)
    2155                 :             :     {
    2156                 :     8262352 :       rtx src, dest, addr;
    2157                 :     8262352 :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2158                 :             : 
    2159                 :     8262352 :       if (GET_CODE (e) != SET)
    2160                 :             :         break;
    2161                 :             : 
    2162                 :     4131147 :       src  = SET_SRC (e);
    2163                 :     4131147 :       dest = SET_DEST (e);
    2164                 :             : 
    2165                 :     4131147 :       if (!MEM_P (src) || !REG_P (dest))
    2166                 :             :         break;
    2167                 :             : 
    2168                 :     1174774 :       addr = XEXP (src, 0);
    2169                 :             : 
    2170                 :             :       /* Good if src address is in RSI.  */
    2171                 :     1174774 :       if (REG_P (addr) && REGNO (addr) == SI_REG)
    2172                 :        5137 :         continue;
    2173                 :             : 
    2174                 :             :       /* Good if src address is offset of RSI.  */
    2175                 :     1271078 :       if (GET_CODE (addr) == PLUS
    2176                 :      788195 :           && REG_P (XEXP (addr, 0))
    2177                 :     1881411 :           && REGNO (XEXP (addr, 0)) == SI_REG)
    2178                 :      101441 :         continue;
    2179                 :             : 
    2180                 :             :       break;
    2181                 :             :     }
    2182                 :     8155774 :   return (i >= 12 && i <= 18);
    2183                 :             : })
    2184                 :             : 
    2185                 :             : ;; Keylocker specific predicates
    2186                 :     8155774 : (define_predicate "encodekey128_operation"
    2187                 :             :   (match_code "parallel")
    2188                 :    16311548 : {
    2189                 :     8155774 :   unsigned i;
    2190                 :           0 :   rtx elt;
    2191                 :             : 
    2192                 :         107 :   if (XVECLEN (op, 0) != 8)
    2193                 :             :     return false;
    2194                 :         107 : 
    2195                 :         388 :   for(i = 0; i < 3; i++)
    2196                 :             :     {
    2197                 :         291 :       elt = XVECEXP (op, 0, i + 1);
    2198                 :         291 :       if (GET_CODE (elt) != SET
    2199                 :         291 :           || GET_CODE (SET_DEST (elt)) != REG
    2200                 :         291 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2201                 :         291 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2202                 :         291 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2203                 :         291 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2204                 :         291 :           || XVECLEN(SET_SRC (elt), 0) != 1
    2205                 :         582 :           || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
    2206                 :             :         return false;
    2207                 :             :     }
    2208                 :             : 
    2209                 :         388 :   for(i = 4; i < 7; i++)
    2210                 :             :     {
    2211                 :         291 :       elt = XVECEXP (op, 0, i);
    2212                 :         291 :       if (GET_CODE (elt) != CLOBBER
    2213                 :         291 :           || GET_MODE (elt) != VOIDmode
    2214                 :         291 :           || GET_CODE (XEXP (elt, 0)) != REG
    2215                 :         291 :           || GET_MODE (XEXP (elt, 0)) != V2DImode
    2216                 :         582 :           || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
    2217                 :             :         return false;
    2218                 :             :     }
    2219                 :             : 
    2220                 :          97 :   elt = XVECEXP (op, 0, 7);
    2221                 :          97 :   if (GET_CODE (elt) != CLOBBER
    2222                 :          97 :       || GET_MODE (elt) != VOIDmode
    2223                 :          97 :       || GET_CODE (XEXP (elt, 0)) != REG
    2224                 :          97 :       || GET_MODE (XEXP (elt, 0)) != CCmode
    2225                 :         194 :       || REGNO (XEXP (elt, 0)) != FLAGS_REG)
    2226                 :             :     return false;
    2227                 :             :   return true;
    2228                 :             : })
    2229                 :             : 
    2230                 :             : (define_predicate "encodekey256_operation"
    2231                 :         107 :   (match_code "parallel")
    2232                 :             : {
    2233                 :         334 :   unsigned i;
    2234                 :         107 :   rtx elt;
    2235                 :           0 : 
    2236                 :         120 :   if (XVECLEN (op, 0) != 9)
    2237                 :             :     return false;
    2238                 :             : 
    2239                 :         120 :   elt = SET_SRC (XVECEXP (op, 0, 0));
    2240                 :         111 :   elt = XVECEXP (elt, 0, 2);
    2241                 :         111 :   if (!REG_P (elt)
    2242                 :         111 :       || REGNO(elt) != GET_SSE_REGNO (1))
    2243                 :             :     return false;
    2244                 :             : 
    2245                 :         555 :   for(i = 0; i < 4; i++)
    2246                 :             :     {
    2247                 :         444 :       elt = XVECEXP (op, 0, i + 1);
    2248                 :         444 :       if (GET_CODE (elt) != SET
    2249                 :         444 :           || GET_CODE (SET_DEST (elt)) != REG
    2250                 :         444 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2251                 :         444 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2252                 :         444 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2253                 :         444 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2254                 :         444 :           || XVECLEN(SET_SRC (elt), 0) != 1
    2255                 :         888 :           || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
    2256                 :             :         return false;
    2257                 :             :     }
    2258                 :             : 
    2259                 :         444 :   for(i = 4; i < 7; i++)
    2260                 :             :     {
    2261                 :         333 :       elt = XVECEXP (op, 0, i + 1);
    2262                 :         333 :       if (GET_CODE (elt) != CLOBBER
    2263                 :         333 :           || GET_MODE (elt) != VOIDmode
    2264                 :         333 :           || GET_CODE (XEXP (elt, 0)) != REG
    2265                 :         333 :           || GET_MODE (XEXP (elt, 0)) != V2DImode
    2266                 :         666 :           || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
    2267                 :             :         return false;
    2268                 :             :     }
    2269                 :             : 
    2270                 :         111 :   elt = XVECEXP (op, 0, 8);
    2271                 :         111 :   if (GET_CODE (elt) != CLOBBER
    2272                 :         111 :       || GET_MODE (elt) != VOIDmode
    2273                 :         111 :       || GET_CODE (XEXP (elt, 0)) != REG
    2274                 :         111 :       || GET_MODE (XEXP (elt, 0)) != CCmode
    2275                 :         222 :       || REGNO (XEXP (elt, 0)) != FLAGS_REG)
    2276                 :             :     return false;
    2277                 :             :   return true;
    2278                 :             : })
    2279                 :             : 
    2280                 :             : 
    2281                 :         120 : (define_predicate "aeswidekl_operation"
    2282                 :             :   (match_code "parallel")
    2283                 :         240 : {
    2284                 :         120 :   unsigned i;
    2285                 :           0 :   rtx elt;
    2286                 :             : 
    2287                 :        5796 :   for (i = 0; i < 8; i++)
    2288                 :             :     {
    2289                 :         660 :       elt = XVECEXP (op, 0, i + 1);
    2290                 :        5168 :       if (GET_CODE (elt) != SET
    2291                 :        5168 :           || GET_CODE (SET_DEST (elt)) != REG
    2292                 :        5168 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2293                 :        5168 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2294                 :        5168 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2295                 :        5168 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2296                 :        5168 :           || XVECLEN (SET_SRC (elt), 0) != 1
    2297                 :        5168 :           || !REG_P (XVECEXP (SET_SRC (elt), 0, 0))
    2298                 :       10304 :           || REGNO (XVECEXP (SET_SRC (elt), 0, 0)) != GET_SSE_REGNO (i))
    2299                 :             :         return false;
    2300                 :             :     }
    2301                 :             :   return true;
    2302                 :             : })
    2303                 :             : 
    2304                 :             : ;; Return true if OP is a memory operand that can be also used in APX
    2305                 :         660 : ;; EVEX-encoded patterns (i.e. APX NDD/NF) with immediate operand.  With
    2306                 :             : ;; non-default address space, segment register or address size prefix,
    2307                 :        1320 : ;; APX EVEX-encoded instruction length can exceed the 15 byte size limit.
    2308                 :         660 : (define_predicate "apx_evex_memory_operand"
    2309                 :           0 :   (match_operand 0 "memory_operand")
    2310                 :             : {
    2311                 :             :   /* OK if immediate operand size < 4 bytes.  */
    2312                 :        1689 :   if (GET_MODE_SIZE (mode) < 4)
    2313                 :        1689 :     return true;
    2314                 :             : 
    2315                 :        1530 :   bool default_addr = ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (op));
    2316                 :        1698 :   bool address_size_prefix = TARGET_X32 && Pmode == SImode;
    2317                 :             : 
    2318                 :        1530 :   struct ix86_address parts;
    2319                 :        1530 :   int ok;
    2320                 :             : 
    2321                 :        1530 :   op = XEXP (op, 0);
    2322                 :        1530 :   ok = ix86_decompose_address (op, &parts);
    2323                 :        1530 :   gcc_assert (ok);
    2324                 :             : 
    2325                 :        1530 :   if (default_addr)
    2326                 :             :     {
    2327                 :             :       /* Default address space.  */
    2328                 :             : 
    2329                 :             :       /* Not OK with address size prefix, index register and disp.  */
    2330                 :         694 :       if (address_size_prefix
    2331                 :         168 :           && parts.index
    2332                 :          42 :           && parts.disp
    2333                 :          42 :           && parts.disp != const0_rtx)
    2334                 :             :         return false;
    2335                 :             :     }
    2336                 :             :   else
    2337                 :             :     {
    2338                 :             :       /* Non-default address space.  */
    2339                 :             : 
    2340                 :             :       /* Not OK without base register.  */
    2341                 :         836 :       if (!parts.base)
    2342                 :             :         return false;
    2343                 :             : 
    2344                 :             :       /* Not OK with disp and address size prefix.  */
    2345                 :         668 :       if (address_size_prefix && parts.disp)
    2346                 :             :         return false;
    2347                 :             :     }
    2348                 :             : 
    2349                 :             :   return true;
    2350                 :             : })
    2351                 :             : 
    2352                 :             : ;; Return true if OP is a memory operand which can be used in APX EVEX-encoded
    2353                 :        1900 : ;; ADD patterns (i.e. APX NDD/NF) for with register source operand.
    2354                 :             : ;; UNSPEC_GOTNTPOFF memory operand is allowed with APX EVEX-encoded ADD only if
    2355                 :        3589 : ;; R_X86_64_CODE_6_GOTTPOFF works.
    2356                 :        1689 : (define_predicate "apx_evex_add_memory_operand"
    2357                 :             :   (match_operand 0 "memory_operand")
    2358                 :             : {
    2359                 :             :   /* OK if "add %reg1, name@gottpoff(%rip), %reg2" or
    2360                 :             :    "{nf} add name@gottpoff(%rip), %reg1" are supported.  */
    2361                 :             :   if (HAVE_AS_R_X86_64_CODE_6_GOTTPOFF)
    2362                 :             :     return true;
    2363                 :             : 
    2364                 :             :   op = XEXP (op, 0);
    2365                 :             : 
    2366                 :             :   /* Disallow APX EVEX-encoded ADD with UNSPEC_GOTNTPOFF.  */
    2367                 :             :   if (GET_CODE (op) == CONST
    2368                 :             :       && GET_CODE (XEXP (op, 0)) == UNSPEC
    2369                 :             :       && XINT (XEXP (op, 0), 1) == UNSPEC_GOTNTPOFF)
    2370                 :             :     return false;
    2371                 :             : 
    2372                 :             :   return true;
    2373                 :             : })
    2374                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2375                 :             : /* (content generated from line coverage data) */
    2376                 :        1027 : /* ... */
    2377                 :             : /* ... */
    2378                 :        1027 : /* ... */
    2379                 :        1027 : /* ... */
    2380                 :             : /* ... */
    2381                 :             : /* ... */
    2382                 :             : /* ... */
    2383                 :   971106464 : /* ... */
    2384                 :             : /* ... */
    2385                 :   971106464 : /* ... */
    2386                 :             : /* ... */
    2387                 :             : /* ... */
    2388                 :             : /* ... */
    2389                 :           0 : /* ... */
    2390                 :           0 : /* ... */
    2391                 :           0 : /* ... */
    2392                 :           0 : /* ... */
    2393                 :           0 : /* ... */
    2394                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2395                 :   566735540 : /* (content generated from line coverage data) */
    2396                 :   566735540 : /* ... */
    2397                 :             : /* ... */
    2398                 :             : /* ... */
    2399                 :     7302994 : /* ... */
    2400                 :             : /* ... */
    2401                 :   135138048 : /* ... */
    2402                 :             : /* ... */
    2403                 :      132850 : /* ... */
    2404                 :             : /* ... */
    2405                 :     1603498 : /* ... */
    2406                 :             : /* ... */
    2407                 :     1353970 : /* ... */
    2408                 :             : /* ... */
    2409                 :    54999717 : /* ... */
    2410                 :             : /* ... */
    2411                 :    50119190 : /* ... */
    2412                 :             : /* ... */
    2413                 :    92890261 : /* ... */
    2414                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2415                 :    38899322 : /* (content generated from line coverage data) */
    2416                 :             : /* ... */
    2417                 :   111005479 : /* ... */
    2418                 :             : /* ... */
    2419                 :    73289405 : /* ... */
    2420                 :             : /* ... */
    2421                 :         806 : /* ... */
    2422                 :             : /* ... */
    2423                 :           0 : /* ... */
    2424                 :           0 : /* ... */
    2425                 :           0 : /* ... */
    2426                 :           0 : /* ... */
    2427                 :           0 : /* ... */
    2428                 :           0 : /* ... */
    2429                 :           0 : /* ... */
    2430                 :           0 : /* ... */
    2431                 :           0 : /* ... */
    2432                 :           0 : /* ... */
    2433                 :           0 : /* ... */
    2434                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2435                 :           0 : /* (content generated from line coverage data) */
    2436                 :           0 : /* ... */
    2437                 :           0 : /* ... */
    2438                 :           0 : /* ... */
    2439                 :           0 : /* ... */
    2440                 :           0 : /* ... */
    2441                 :           0 : /* ... */
    2442                 :           0 : /* ... */
    2443                 :           0 : /* ... */
    2444                 :           0 : /* ... */
    2445                 :           0 : /* ... */
    2446                 :           0 : /* ... */
    2447                 :           0 : /* ... */
    2448                 :           0 : /* ... */
    2449                 :           0 : /* ... */
    2450                 :           0 : /* ... */
    2451                 :           0 : /* ... */
    2452                 :           0 : /* ... */
    2453                 :    38969050 : /* ... */
    2454                 :    38969050 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2455                 :             : /* (content generated from line coverage data) */
    2456                 :       22636 : /* ... */
    2457                 :             : /* ... */
    2458                 :             : /* ... */
    2459                 :           0 : /* ... */
    2460                 :           0 : /* ... */
    2461                 :           0 : /* ... */
    2462                 :           0 : /* ... */
    2463                 :     2944085 : /* ... */
    2464                 :     2944085 : /* ... */
    2465                 :             : /* ... */
    2466                 :             : /* ... */
    2467                 :        4678 : /* ... */
    2468                 :             : /* ... */
    2469                 :      333376 : /* ... */
    2470                 :             : /* ... */
    2471                 :     2275998 : /* ... */
    2472                 :             : /* ... */
    2473                 :      255596 : /* ... */
    2474                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2475                 :        1418 : /* (content generated from line coverage data) */
    2476                 :             : /* ... */
    2477                 :         236 : /* ... */
    2478                 :             : /* ... */
    2479                 :        4685 : /* ... */
    2480                 :             : /* ... */
    2481                 :           0 : /* ... */
    2482                 :           0 : /* ... */
    2483                 :   354351012 : /* ... */
    2484                 :   354351012 : /* ... */
    2485                 :             : /* ... */
    2486                 :             : /* ... */
    2487                 :     9464047 : /* ... */
    2488                 :             : /* ... */
    2489                 :     1365597 : /* ... */
    2490                 :             : /* ... */
    2491                 :     1678129 : /* ... */
    2492                 :             : /* ... */
    2493                 :       19198 : /* ... */
    2494                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2495                 :   195682480 : /* (content generated from line coverage data) */
    2496                 :             : /* ... */
    2497                 :      808505 : /* ... */
    2498                 :             : /* ... */
    2499                 :   140710874 : /* ... */
    2500                 :             : /* ... */
    2501                 :     3140799 : /* ... */
    2502                 :             : /* ... */
    2503                 :      383994 : /* ... */
    2504                 :             : /* ... */
    2505                 :     1073119 : /* ... */
    2506                 :             : /* ... */
    2507                 :           0 : /* ... */
    2508                 :           0 : /* ... */
    2509                 :           0 : /* ... */
    2510                 :           0 : /* ... */
    2511                 :           0 : /* ... */
    2512                 :           0 : /* ... */
    2513                 :           0 : /* ... */
    2514                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2515                 :           0 : /* (content generated from line coverage data) */
    2516                 :           0 : /* ... */
    2517                 :           0 : /* ... */
    2518                 :           0 : /* ... */
    2519                 :           0 : /* ... */
    2520                 :           0 : /* ... */
    2521                 :           0 : /* ... */
    2522                 :           0 : /* ... */
    2523                 :     8106777 : /* ... */
    2524                 :     8106777 : /* ... */
    2525                 :             : /* ... */
    2526                 :             : /* ... */
    2527                 :      975236 : /* ... */
    2528                 :             : /* ... */
    2529                 :           0 : /* ... */
    2530                 :             : /* ... */
    2531                 :           0 : /* ... */
    2532                 :             : /* ... */
    2533                 :           0 : /* ... */
    2534                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2535                 :           0 : /* (content generated from line coverage data) */
    2536                 :             : /* ... */
    2537                 :           0 : /* ... */
    2538                 :             : /* ... */
    2539                 :      141336 : /* ... */
    2540                 :             : /* ... */
    2541                 :        8537 : /* ... */
    2542                 :             : /* ... */
    2543                 :     6070917 : /* ... */
    2544                 :             : /* ... */
    2545                 :      150458 : /* ... */
    2546                 :             : /* ... */
    2547                 :      265820 : /* ... */
    2548                 :             : /* ... */
    2549                 :        3618 : /* ... */
    2550                 :             : /* ... */
    2551                 :           0 : /* ... */
    2552                 :             : /* ... */
    2553                 :           0 : /* ... */
    2554                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2555                 :           0 : /* (content generated from line coverage data) */
    2556                 :           0 : /* ... */
    2557                 :           0 : /* ... */
    2558                 :           0 : /* ... */
    2559                 :           0 : /* ... */
    2560                 :           0 : /* ... */
    2561                 :           0 : /* ... */
    2562                 :           0 : /* ... */
    2563                 :           0 : /* ... */
    2564                 :           0 : /* ... */
    2565                 :           0 : /* ... */
    2566                 :           0 : /* ... */
    2567                 :           0 : /* ... */
    2568                 :           0 : /* ... */
    2569                 :           0 : /* ... */
    2570                 :           0 : /* ... */
    2571                 :           0 : /* ... */
    2572                 :           0 : /* ... */
    2573                 :           0 : /* ... */
    2574                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2575                 :           0 : /* (content generated from line coverage data) */
    2576                 :           0 : /* ... */
    2577                 :           0 : /* ... */
    2578                 :           0 : /* ... */
    2579                 :           0 : /* ... */
    2580                 :           0 : /* ... */
    2581                 :             : /* ... */
    2582                 :             : /* ... */
    2583                 :        1337 : /* ... */
    2584                 :             : /* ... */
    2585                 :             : /* ... */
    2586                 :             : /* ... */
    2587                 :             : /* ... */
    2588                 :             : /* ... */
    2589                 :             : /* ... */
    2590                 :             : /* ... */
    2591                 :             : /* ... */
    2592                 :             : /* ... */
    2593                 :             : /* ... */
    2594                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2595                 :             : /* (content generated from line coverage data) */
    2596                 :             : /* ... */
    2597                 :             : /* ... */
    2598                 :             : /* ... */
    2599                 :             : /* ... */
    2600                 :             : /* ... */
    2601                 :             : /* ... */
    2602                 :             : /* ... */
    2603                 :             : /* ... */
    2604                 :             : /* ... */
    2605                 :             : /* ... */
    2606                 :             : /* ... */
    2607                 :             : /* ... */
    2608                 :             : /* ... */
    2609                 :             : /* ... */
    2610                 :             : /* ... */
    2611                 :             : /* ... */
    2612                 :             : /* ... */
    2613                 :             : /* ... */
    2614                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2615                 :             : /* (content generated from line coverage data) */
    2616                 :             : /* ... */
    2617                 :             : /* ... */
    2618                 :             : /* ... */
    2619                 :             : /* ... */
    2620                 :             : /* ... */
    2621                 :             : /* ... */
    2622                 :             : /* ... */
    2623                 :             : /* ... */
    2624                 :             : /* ... */
    2625                 :             : /* ... */
    2626                 :             : /* ... */
    2627                 :             : /* ... */
    2628                 :             : /* ... */
    2629                 :             : /* ... */
    2630                 :             : /* ... */
    2631                 :             : /* ... */
    2632                 :             : /* ... */
    2633                 :             : /* ... */
    2634                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2635                 :             : /* (content generated from line coverage data) */
    2636                 :             : /* ... */
    2637                 :             : /* ... */
    2638                 :             : /* ... */
    2639                 :             : /* ... */
    2640                 :             : /* ... */
    2641                 :             : /* ... */
    2642                 :             : /* ... */
    2643                 :             : /* ... */
    2644                 :             : /* ... */
    2645                 :             : /* ... */
    2646                 :             : /* ... */
    2647                 :             : /* ... */
    2648                 :             : /* ... */
    2649                 :             : /* ... */
    2650                 :             : /* ... */
    2651                 :             : /* ... */
    2652                 :             : /* ... */
    2653                 :             : /* ... */
    2654                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2655                 :             : /* (content generated from line coverage data) */
    2656                 :             : /* ... */
    2657                 :             : /* ... */
    2658                 :             : /* ... */
    2659                 :             : /* ... */
    2660                 :             : /* ... */
    2661                 :             : /* ... */
    2662                 :             : /* ... */
    2663                 :             : /* ... */
    2664                 :             : /* ... */
    2665                 :             : /* ... */
    2666                 :             : /* ... */
    2667                 :             : /* ... */
    2668                 :             : /* ... */
    2669                 :             : /* ... */
    2670                 :             : /* ... */
    2671                 :             : /* ... */
    2672                 :             : /* ... */
    2673                 :             : /* ... */
    2674                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2675                 :             : /* (content generated from line coverage data) */
    2676                 :             : /* ... */
    2677                 :             : /* ... */
    2678                 :             : /* ... */
    2679                 :             : /* ... */
    2680                 :             : /* ... */
    2681                 :             : /* ... */
    2682                 :             : /* ... */
    2683                 :             : /* ... */
    2684                 :             : /* ... */
    2685                 :             : /* ... */
    2686                 :             : /* ... */
    2687                 :             : /* ... */
    2688                 :             : /* ... */
    2689                 :             : /* ... */
    2690                 :             : /* ... */
    2691                 :             : /* ... */
    2692                 :             : /* ... */
    2693                 :             : /* ... */
    2694                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2695                 :             : /* (content generated from line coverage data) */
    2696                 :             : /* ... */
    2697                 :             : /* ... */
    2698                 :             : /* ... */
    2699                 :             : /* ... */
    2700                 :             : /* ... */
    2701                 :             : /* ... */
    2702                 :             : /* ... */
    2703                 :             : /* ... */
    2704                 :             : /* ... */
    2705                 :             : /* ... */
    2706                 :             : /* ... */
    2707                 :             : /* ... */
    2708                 :             : /* ... */
    2709                 :             : /* ... */
    2710                 :             : /* ... */
    2711                 :             : /* ... */
    2712                 :             : /* ... */
    2713                 :             : /* ... */
    2714                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2715                 :             : /* (content generated from line coverage data) */
    2716                 :             : /* ... */
    2717                 :             : /* ... */
    2718                 :             : /* ... */
    2719                 :             : /* ... */
    2720                 :             : /* ... */
    2721                 :             : /* ... */
    2722                 :             : /* ... */
    2723                 :             : /* ... */
    2724                 :             : /* ... */
    2725                 :             : /* ... */
    2726                 :             : /* ... */
    2727                 :             : /* ... */
    2728                 :             : /* ... */
    2729                 :             : /* ... */
    2730                 :             : /* ... */
    2731                 :             : /* ... */
    2732                 :             : /* ... */
    2733                 :             : /* ... */
    2734                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2735                 :             : /* (content generated from line coverage data) */
    2736                 :             : /* ... */
    2737                 :             : /* ... */
    2738                 :             : /* ... */
    2739                 :             : /* ... */
    2740                 :             : /* ... */
    2741                 :             : /* ... */
    2742                 :             : /* ... */
    2743                 :             : /* ... */
    2744                 :             : /* ... */
    2745                 :             : /* ... */
    2746                 :             : /* ... */
    2747                 :             : /* ... */
    2748                 :             : /* ... */
    2749                 :             : /* ... */
    2750                 :             : /* ... */
    2751                 :             : /* ... */
    2752                 :             : /* ... */
    2753                 :             : /* ... */
    2754                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2755                 :             : /* (content generated from line coverage data) */
    2756                 :             : /* ... */
    2757                 :             : /* ... */
    2758                 :             : /* ... */
    2759                 :             : /* ... */
    2760                 :             : /* ... */
    2761                 :             : /* ... */
    2762                 :             : /* ... */
    2763                 :             : /* ... */
    2764                 :             : /* ... */
    2765                 :             : /* ... */
    2766                 :             : /* ... */
    2767                 :             : /* ... */
    2768                 :             : /* ... */
    2769                 :             : /* ... */
    2770                 :             : /* ... */
    2771                 :             : /* ... */
    2772                 :             : /* ... */
    2773                 :             : /* ... */
    2774                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2775                 :             : /* (content generated from line coverage data) */
    2776                 :             : /* ... */
    2777                 :             : /* ... */
    2778                 :             : /* ... */
    2779                 :             : /* ... */
    2780                 :             : /* ... */
    2781                 :             : /* ... */
    2782                 :             : /* ... */
    2783                 :             : /* ... */
    2784                 :             : /* ... */
    2785                 :             : /* ... */
    2786                 :             : /* ... */
    2787                 :             : /* ... */
    2788                 :             : /* ... */
    2789                 :             : /* ... */
    2790                 :             : /* ... */
    2791                 :             : /* ... */
    2792                 :             : /* ... */
    2793                 :             : /* ... */
    2794                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2795                 :             : /* (content generated from line coverage data) */
    2796                 :             : /* ... */
    2797                 :             : /* ... */
    2798                 :             : /* ... */
    2799                 :             : /* ... */
    2800                 :             : /* ... */
    2801                 :             : /* ... */
    2802                 :             : /* ... */
    2803                 :             : /* ... */
    2804                 :             : /* ... */
    2805                 :             : /* ... */
    2806                 :             : /* ... */
    2807                 :             : /* ... */
    2808                 :             : /* ... */
    2809                 :             : /* ... */
    2810                 :             : /* ... */
    2811                 :             : /* ... */
    2812                 :             : /* ... */
    2813                 :             : /* ... */
    2814                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2815                 :             : /* (content generated from line coverage data) */
    2816                 :             : /* ... */
    2817                 :             : /* ... */
    2818                 :             : /* ... */
    2819                 :             : /* ... */
    2820                 :             : /* ... */
    2821                 :             : /* ... */
    2822                 :             : /* ... */
    2823                 :             : /* ... */
    2824                 :             : /* ... */
    2825                 :             : /* ... */
    2826                 :             : /* ... */
    2827                 :             : /* ... */
    2828                 :             : /* ... */
    2829                 :             : /* ... */
    2830                 :             : /* ... */
    2831                 :             : /* ... */
    2832                 :             : /* ... */
    2833                 :             : /* ... */
    2834                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2835                 :             : /* (content generated from line coverage data) */
    2836                 :             : /* ... */
    2837                 :             : /* ... */
    2838                 :             : /* ... */
    2839                 :             : /* ... */
    2840                 :             : /* ... */
    2841                 :             : /* ... */
    2842                 :             : /* ... */
    2843                 :             : /* ... */
    2844                 :             : /* ... */
    2845                 :             : /* ... */
    2846                 :  7176066384 : /* ... */
    2847                 :             : /* ... */
    2848                 :  7176066384 : /* ... */
    2849                 :             : /* ... */
    2850                 :             : /* ... */
    2851                 :             : /* ... */
    2852                 :   139673644 : /* ... */
    2853                 :             : /* ... */
    2854                 :    52860432 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2855                 :    21905450 : /* (content generated from line coverage data) */
    2856                 :             : /* ... */
    2857                 :    23939695 : /* ... */
    2858                 :     9129607 : /* ... */
    2859                 :      892750 : /* ... */
    2860                 :     1295545 : /* ... */
    2861                 :      698107 : /* ... */
    2862                 :     1375933 : /* ... */
    2863                 :   216736276 : /* ... */
    2864                 :       81944 : /* ... */
    2865                 :        8657 : /* ... */
    2866                 :      851126 : /* ... */
    2867                 :    43034464 : /* ... */
    2868                 :   657426807 : /* ... */
    2869                 :   228946008 : /* ... */
    2870                 :  1450368666 : /* ... */
    2871                 :       13909 : /* ... */
    2872                 :     9464047 : /* ... */
    2873                 :     1365597 : /* ... */
    2874                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2875                 :     1678129 : /* (content generated from line coverage data) */
    2876                 :       14474 : /* ... */
    2877                 :   185152808 : /* ... */
    2878                 :      127488 : /* ... */
    2879                 :   140545404 : /* ... */
    2880                 :     2854357 : /* ... */
    2881                 :      341004 : /* ... */
    2882                 :             : /* ... */
    2883                 :       80714 : /* ... */
    2884                 :     6070917 : /* ... */
    2885                 :             : /* ... */
    2886                 :             : /* ... */
    2887                 :             : /* ... */
    2888                 :             : /* ... */
    2889                 :             : /* ... */
    2890                 :             : /* ... */
    2891                 :             : /* ... */
    2892                 :             : /* ... */
    2893                 :             : /* ... */
    2894                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2895                 :             : /* (content generated from line coverage data) */
    2896                 :             : /* ... */
    2897                 :             : /* ... */
    2898                 :             : /* ... */
    2899                 :             : /* ... */
    2900                 :             : /* ... */
    2901                 :             : /* ... */
    2902                 :             : /* ... */
    2903                 :             : /* ... */
    2904                 :             : /* ... */
    2905                 :             : /* ... */
    2906                 :             : /* ... */
    2907                 :             : /* ... */
    2908                 :             : /* ... */
    2909                 :             : /* ... */
    2910                 :             : /* ... */
    2911                 :             : /* ... */
    2912                 :             : /* ... */
    2913                 :             : /* ... */
    2914                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2915                 :             : /* (content generated from line coverage data) */
    2916                 :             : /* ... */
    2917                 :             : /* ... */
    2918                 :             : /* ... */
    2919                 :             : /* ... */
    2920                 :             : /* ... */
    2921                 :             : /* ... */
    2922                 :             : /* ... */
    2923                 :             : /* ... */
    2924                 :             : /* ... */
    2925                 :             : /* ... */
    2926                 :             : /* ... */
    2927                 :             : /* ... */
    2928                 :             : /* ... */
    2929                 :             : /* ... */
    2930                 :             : /* ... */
    2931                 :             : /* ... */
    2932                 :             : /* ... */
    2933                 :             : /* ... */
    2934                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2935                 :             : /* (content generated from line coverage data) */
    2936                 :             : /* ... */
    2937                 :             : /* ... */
    2938                 :             : /* ... */
    2939                 :             : /* ... */
    2940                 :             : /* ... */
    2941                 :             : /* ... */
    2942                 :             : /* ... */
    2943                 :             : /* ... */
    2944                 :             : /* ... */
    2945                 :             : /* ... */
    2946                 :             : /* ... */
    2947                 :             : /* ... */
    2948                 :             : /* ... */
    2949                 :             : /* ... */
    2950                 :             : /* ... */
    2951                 :             : /* ... */
    2952                 :     7161780 : /* ... */
    2953                 :             : /* ... */
    2954                 :     7161780 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2955                 :             : /* (content generated from line coverage data) */
    2956                 :     1374063 : /* ... */
    2957                 :     1374063 : /* ... */
        

Generated by: LCOV version 2.1-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.