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-07-12 13:27:34 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                 :   129931172 :        (match_test "ANY_FP_REGNO_P (REGNO (op))")))
      24                 :       40524 : 
      25                 :             : ;; Return true if OP is an i387 fp register.
      26                 :             : (define_predicate "fp_register_operand"
      27                 :             :   (and (match_code "reg")
      28                 :     1597286 :        (match_test "STACK_REGNO_P (REGNO (op))")))
      29                 :     1511142 : 
      30                 :   427621685 : ;; True if the operand is a GENERAL class register.
      31                 :             : (define_predicate "general_reg_operand"
      32                 :             :   (and (match_code "reg")
      33                 :   265678538 :        (match_test "GENERAL_REGNO_P (REGNO (op))")))
      34                 :   199219331 : 
      35                 :   442696572 : ;; True if the operand is an INDEX class register.
      36                 :             : (define_predicate "index_reg_operand"
      37                 :             :   (and (match_code "reg")
      38                 :      641419 :        (match_test "INDEX_REGNO_P (REGNO (op))")))
      39                 :      641340 : 
      40                 :      641896 : ;; 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                 :    55185736 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      44                 :    61086813 :     (match_operand 0 "nonimmediate_operand")))
      45                 :    76550790 : 
      46                 :             : ;; True if the operand is a general operand with GENERAL class register.
      47                 :             : (define_predicate "general_gr_operand"
      48                 :    89298078 :   (if_then_else (match_code "reg")
      49                 :    38565789 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      50                 :   112965361 :     (match_operand 0 "general_operand")))
      51                 :             : 
      52                 :             : ;; True if the operand is an MMX register.
      53                 :             : (define_predicate "mmx_reg_operand"
      54                 :    38743485 :   (and (match_code "reg")
      55                 :         188 :        (match_test "MMX_REGNO_P (REGNO (op))")))
      56                 :    38743485 : 
      57                 :             : ;; Match register operands, but include memory operands for
      58                 :             : ;; !TARGET_MMX_WITH_SSE.
      59                 :             : (define_predicate "register_mmxmem_operand"
      60                 :      510991 :   (ior (match_operand 0 "register_operand")
      61                 :          15 :        (and (not (match_test "TARGET_MMX_WITH_SSE"))
      62                 :      510991 :             (match_operand 0 "memory_operand"))))
      63                 :             : 
      64                 :             : ;; True if the operand is an SSE register.
      65                 :   154980801 : (define_predicate "sse_reg_operand"
      66                 :             :   (and (match_code "reg")
      67                 :   154980801 :        (match_test "SSE_REGNO_P (REGNO (op))")))
      68                 :     1730155 : 
      69                 :             : ;; Return true if op is a QImode register.
      70                 :             : (define_predicate "any_QIreg_operand"
      71                 :             :   (and (match_code "reg")
      72                 :     2319040 :        (match_test "ANY_QI_REGNO_P (REGNO (op))")))
      73                 :      798769 : 
      74                 :     2345572 : ;; Return true if op is one of QImode registers: %[abcd][hl].
      75                 :             : (define_predicate "QIreg_operand"
      76                 :             :   (and (match_code "reg")
      77                 :      829772 :        (match_test "QI_REGNO_P (REGNO (op))")))
      78                 :      654932 : 
      79                 :     1690841 : ;; Return true if op is a QImode register operand other than %[abcd][hl].
      80                 :             : (define_predicate "ext_QIreg_operand"
      81                 :     3480722 :   (and (match_test "TARGET_64BIT")
      82                 :     3481092 :        (match_code "reg")
      83                 :      985490 :        (not (match_test "QI_REGNO_P (REGNO (op))"))))
      84                 :     3757318 : 
      85                 :             : ;; Return true if op is the AX register.
      86                 :             : (define_predicate "ax_reg_operand"
      87                 :             :   (and (match_code "reg")
      88                 :    22393833 :        (match_test "REGNO (op) == AX_REG")))
      89                 :           0 : 
      90                 :   113647167 : ;; Return true if op is the flags register.
      91                 :             : (define_special_predicate "flags_reg_operand"
      92                 :             :   (and (match_code "reg")
      93                 :   112561361 :        (match_test "REGNO (op) == FLAGS_REG")))
      94                 :             : 
      95                 :    40533957 : ;; True if the operand is a MASK register.
      96                 :             : (define_predicate "mask_reg_operand"
      97                 :     9933646 :   (and (match_code "reg")
      98                 :        3592 :        (match_test "MASK_REGNO_P (REGNO (op))")))
      99                 :     9937238 : 
     100                 :             : ;; Match a DI, SI or HImode register operand.
     101                 :             : (define_special_predicate "int248_register_operand"
     102                 :             :   (and (match_operand 0 "register_operand")
     103                 :      599484 :        (ior (and (match_test "TARGET_64BIT")
     104                 :      180044 :                  (match_test "GET_MODE (op) == DImode"))
     105                 :      388445 :             (match_test "GET_MODE (op) == SImode")
     106                 :      219222 :             (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                 :      455871 :   (and (match_operand 0 "nonimmediate_operand")
     111                 :      614632 :        (ior (and (match_test "TARGET_64BIT")
     112                 :      455871 :                  (match_test "GET_MODE (op) == DImode"))
     113                 :      207345 :             (match_test "GET_MODE (op) == SImode")
     114                 :             :             (match_test "GET_MODE (op) == HImode")
     115                 :      455871 :             (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                 :     2823595 :   (if_then_else
     120                 :     2823595 :     (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     121                 :     2823595 :     (match_operand 0 "nonimmediate_operand")
     122                 :             :     (match_operand 0 "register_operand")))
     123                 :             : 
     124                 :     1078341 : ;; Match nonimmediate operands, but exclude memory operands
     125                 :             : ;; for TARGET_SSE_MATH if TARGET_MIX_SSE_I387 is not enabled.
     126                 :     1078341 : (define_predicate "nonimm_ssenomem_operand"
     127                 :             :   (if_then_else
     128                 :     1078341 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     129                 :     2156682 :          (not (match_test "TARGET_MIX_SSE_I387")))
     130                 :             :     (match_operand 0 "register_operand")
     131                 :             :     (match_operand 0 "nonimmediate_operand")))
     132                 :             : 
     133                 :      732341 : ;; The above predicate, suitable for x87 arithmetic operators.
     134                 :             : (define_predicate "x87nonimm_ssenomem_operand"
     135                 :      732341 :   (if_then_else
     136                 :      732341 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     137                 :     1464682 :          (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                 :       34283 : ;; Match register operands, include memory operand for TARGET_SSE4_1.
     142                 :             : (define_predicate "register_sse4nonimm_operand"
     143                 :       34283 :   (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                 :  6360278427 : {
     155                 :  6360278427 :   if (flag_cf_protection & CF_BRANCH)
     156                 :             :      {
     157                 :  1238076957 :        unsigned HOST_WIDE_INT imm = UINTVAL (op);
     158                 :  1238076957 :        unsigned HOST_WIDE_INT val = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
     159                 :             : 
     160                 :  1238076957 :        if (imm == val)
     161                 :             :          return true;
     162                 :             : 
     163                 :             :        /* NB: Encoding is byte based.  */
     164                 :  1238076749 :        if (TARGET_64BIT)
     165                 :  2386547087 :          for (; imm >= val; imm >>= 8)
     166                 :  1338097234 :            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                 :  8190918050 : (define_predicate "x86_64_immediate_operand"
     175                 :             :   (match_code "const_int,symbol_ref,label_ref,const")
     176                 :  8190918050 : {
     177                 : 11247650474 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     178                 :             :     return false;
     179                 :             : 
     180                 :  4887371796 :   if (!TARGET_64BIT)
     181                 :  5073606044 :     return immediate_operand (op, mode);
     182                 :             : 
     183                 :  4701137799 :   switch (GET_CODE (op))
     184                 :             :     {
     185                 :  3861862658 :     case CONST_INT:
     186                 :  3861862658 :       {
     187                 :  3861862658 :         HOST_WIDE_INT val = INTVAL (op);
     188                 :  3861862658 :         return trunc_int_for_mode (val, SImode) == val;
     189                 :             :       }
     190                 :   682963300 :     case SYMBOL_REF:
     191                 :             :       /* TLS symbols are not constant.  */
     192                 :   682963300 :       if (SYMBOL_REF_TLS_MODEL (op))
     193                 :             :         return false;
     194                 :             : 
     195                 :             :       /* Load the external function address via the GOT slot.  */
     196                 :   682924544 :       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                 :   682924442 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
     204                 :   682924442 :               || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
     205                 :             : 
     206                 :    21746376 :     case LABEL_REF:
     207                 :             :       /* For certain code models, the code is near as well.  */
     208                 :    21746376 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
     209                 :             :               || ix86_cmodel == CM_KERNEL);
     210                 :             : 
     211                 :   134565465 :     case CONST:
     212                 :             :       /* We also may accept the offsetted memory references in certain
     213                 :             :          special cases.  */
     214                 :   134565465 :       if (GET_CODE (XEXP (op, 0)) == UNSPEC)
     215                 :      707769 :         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                 :   133858748 :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     228                 :             :         {
     229                 :   133857696 :           rtx op1 = XEXP (XEXP (op, 0), 0);
     230                 :   133857696 :           rtx op2 = XEXP (XEXP (op, 0), 1);
     231                 :             : 
     232                 :   133857696 :           if (ix86_cmodel == CM_LARGE && GET_CODE (op1) != UNSPEC)
     233                 :             :             return false;
     234                 :   133857691 :           if (!CONST_INT_P (op2))
     235                 :             :             return false;
     236                 :             : 
     237                 :   133857691 :           HOST_WIDE_INT offset = INTVAL (op2);
     238                 :   133857691 :           if (trunc_int_for_mode (offset, SImode) != offset)
     239                 :             :             return false;
     240                 :             : 
     241                 :   133852028 :           switch (GET_CODE (op1))
     242                 :             :             {
     243                 :   133526585 :             case SYMBOL_REF:
     244                 :             :               /* TLS symbols are not constant.  */
     245                 :   133526585 :               if (SYMBOL_REF_TLS_MODEL (op1))
     246                 :             :                 return false;
     247                 :             : 
     248                 :             :               /* Load the external function address via the GOT slot.  */
     249                 :   133515031 :               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                 :   133515025 :               if ((ix86_cmodel == CM_SMALL
     257                 :      192815 :                    || (ix86_cmodel == CM_MEDIUM
     258                 :           0 :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     259                 :   133515025 :                   && 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                 :      195427 :               if (ix86_cmodel == CM_KERNEL
     266                 :           0 :                   && offset > 0)
     267                 :             :                 return true;
     268                 :             :               break;
     269                 :             : 
     270                 :        3900 :             case LABEL_REF:
     271                 :             :               /* These conditions are similar to SYMBOL_REF ones, just the
     272                 :             :                  constraints for code models differ.  */
     273                 :        3900 :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     274                 :        3900 :                   && 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                 :      321543 :             case UNSPEC:
     282                 :      321543 :               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                 :  5361287673 : (define_predicate "x86_64_zext_immediate_operand"
     305                 :             :   (match_code "const_int,symbol_ref,label_ref,const")
     306                 :  5361287673 : {
     307                 :   719811466 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     308                 :  4887372047 :     return false;
     309                 :  4887372047 : 
     310                 :   719811318 :   switch (GET_CODE (op))
     311                 :  4887372047 :     {
     312                 :  5541289439 :     case CONST_INT:
     313                 :   653917392 :       return !(INTVAL (op) & ~HOST_WIDE_INT_C (0xffffffff));
     314                 :             : 
     315                 :    59762462 :     case SYMBOL_REF:
     316                 :  4887372047 :       /* TLS symbols are not constant.  */
     317                 :  4947134509 :       if (SYMBOL_REF_TLS_MODEL (op))
     318                 :   266877749 :         return false;
     319                 :             : 
     320                 :             :       /* Load the external function address via the GOT slot.  */
     321                 :    59724567 :       if (ix86_force_load_from_GOT_p (op))
     322                 :   719811466 :         return false;
     323                 :             : 
     324                 :             :      /* For certain code models, the symbolic references are known to fit.  */
     325                 :    59724466 :       return (ix86_cmodel == CM_SMALL
     326                 :    59724466 :               || (ix86_cmodel == CM_MEDIUM
     327                 :         219 :                   && !SYMBOL_REF_FAR_ADDR_P (op)));
     328                 :             : 
     329                 :     1906750 :     case LABEL_REF:
     330                 :             :       /* For certain code models, the code is near as well.  */
     331                 :     1906750 :       return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
     332                 :             : 
     333                 :     4224714 :     case CONST:
     334                 :             :       /* We also may accept the offsetted memory references in certain
     335                 :             :          special cases.  */
     336                 :     4224714 :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     337                 :             :         {
     338                 :     4220388 :           rtx op1 = XEXP (XEXP (op, 0), 0);
     339                 :     4220388 :           rtx op2 = XEXP (XEXP (op, 0), 1);
     340                 :             : 
     341                 :     4220388 :           if (ix86_cmodel == CM_LARGE)
     342                 :             :             return false;
     343                 :     4220386 :           if (!CONST_INT_P (op2))
     344                 :             :             return false;
     345                 :             : 
     346                 :     4220386 :           HOST_WIDE_INT offset = INTVAL (op2);
     347                 :     4220386 :           if (trunc_int_for_mode (offset, SImode) != offset)
     348                 :             :             return false;
     349                 :             : 
     350                 :     4217339 :           switch (GET_CODE (op1))
     351                 :             :             {
     352                 :     4216834 :             case SYMBOL_REF:
     353                 :             :               /* TLS symbols are not constant.  */
     354                 :     4216834 :               if (SYMBOL_REF_TLS_MODEL (op1))
     355                 :             :                 return false;
     356                 :             : 
     357                 :             :               /* Load the external function address via the GOT slot.  */
     358                 :     4206508 :               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                 :     4206502 :               if ((ix86_cmodel == CM_SMALL
     366                 :      162934 :                    || (ix86_cmodel == CM_MEDIUM
     367                 :           0 :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     368                 :     4206502 :                   && 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                 :   963618986 : ;; x86_64_immediate_operand.
     398                 :             : (define_predicate "x86_64_neg_const_int_operand"
     399                 :   963618986 :   (match_code "const_int")
     400                 :             : {
     401                 :   719851939 :   HOST_WIDE_INT val = -UINTVAL (op);
     402                 :       20437 :   if (mode == DImode && trunc_int_for_mode (val, SImode) != val)
     403                 :   719811466 :     return false;
     404                 :       39776 :   if (flag_cf_protection & CF_BRANCH)
     405                 :   719811466 :     {
     406                 :       17414 :       unsigned HOST_WIDE_INT endbr = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
     407                 :       17414 :       if ((val & HOST_WIDE_INT_C (0xffffffff)) == endbr)
     408                 :             :         return false;
     409                 :   719811466 :     }
     410                 :   719811466 :   return true;
     411                 :    56707177 : })
     412                 :             : 
     413                 :             : ;; Return true if VALUE is a constant integer whose low and high words satisfy
     414                 :       53674 : ;; x86_64_immediate_operand.
     415                 :       40473 : (define_predicate "x86_64_hilo_int_operand"
     416                 :       94147 :   (match_code "const_int,const_wide_int")
     417                 :       40473 : {
     418                 :    42740780 :   switch (GET_CODE (op))
     419                 :             :     {
     420                 :    42691294 :     case CONST_INT:
     421                 :    42740780 :       return x86_64_immediate_operand (op, mode);
     422                 :             : 
     423                 :       49486 :     case CONST_WIDE_INT:
     424                 :       49486 :       gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
     425                 :       49486 :       return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
     426                 :             :                                         DImode)
     427                 :       49486 :               && 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                 :    43426581 : ;; x86_64_immediate_operand value zero extended from word mode to mode.
     438                 :             : (define_predicate "x86_64_dwzext_immediate_operand"
     439                 :    43426581 :   (match_code "const_int,const_wide_int")
     440                 :             : {
     441                 :        3742 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     442                 :    42740780 :     return false;
     443                 :    42740780 : 
     444                 :        3742 :   switch (GET_CODE (op))
     445                 :             :     {
     446                 :        1624 :     case CONST_INT:
     447                 :        1624 :       if (!TARGET_64BIT)
     448                 :    42740780 :         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                 :   144986776 :   (if_then_else (match_test "TARGET_64BIT")
     475                 :   144990518 :     (ior (match_operand 0 "nonimmediate_operand")
     476                 :        3742 :          (match_operand 0 "x86_64_immediate_operand"))
     477                 :   144986776 :     (match_operand 0 "general_operand")))
     478                 :    60064007 : 
     479                 :             : ;; Return true if OP's both words are general operands representable
     480                 :    60064007 : ;; on x86_64.
     481                 :             : (define_predicate "x86_64_hilo_general_operand"
     482                 :    60064007 :   (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                 :      333623 : 
     487                 :             : ;; Return true if OP is non-VOIDmode general operand representable
     488                 :      333623 : ;; 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                 :      333623 :   (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                 :     3735022 : ;; This predicate is used in zero-extending conversion operations that
     503                 :             : ;; require non-VOIDmode immediate operands.
     504                 :     3735022 : (define_predicate "x86_64_zext_operand"
     505                 :     3735022 :   (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                 :      114033 :               (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                 :     2279352 : ;; as either sign extended or zero extended constant.
     513                 :             : (define_predicate "x86_64_szext_general_operand"
     514                 :     2279352 :   (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                 :    29398096 :     (match_operand 0 "general_operand")))
     519                 :             : 
     520                 :    29398096 : ;; Return true if OP is nonmemory operand representable on x86_64.
     521                 :             : (define_predicate "x86_64_nonmemory_operand"
     522                 :    29398096 :   (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                 :      275464 : 
     527                 :             : ;; Return true if OP is nonmemory operand representable on x86_64.
     528                 :      275464 : (define_predicate "x86_64_szext_nonmemory_operand"
     529                 :      275464 :   (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                 :   170461605 :     (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                 :   170461605 :   if (!flag_pic)
     541                 :             :     return false;
     542                 :             : 
     543                 :             :   /* Rule out relocations that translate into 64bit constants.  */
     544                 :     7856662 :   if (TARGET_64BIT && GET_CODE (op) == CONST)
     545                 :             :     {
     546                 :      146405 :       op = XEXP (op, 0);
     547                 :      146405 :       if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
     548                 :      145370 :         op = XEXP (op, 0);
     549                 :      146405 :       if (GET_CODE (op) == UNSPEC
     550                 :        1035 :           && (XINT (op, 1) == UNSPEC_GOTOFF
     551                 :        1035 :               || XINT (op, 1) == UNSPEC_GOT))
     552                 :             :         return false;
     553                 :             :     }
     554                 :             : 
     555                 :     7856055 :   return symbolic_operand (op, mode);
     556                 :             : })
     557                 :             : 
     558                 :             : ;; Return true if OP is nonmemory operand acceptable by movabs patterns.
     559                 :  1240567231 : (define_predicate "x86_64_movabs_operand"
     560                 :             :   (and (match_operand 0 "nonmemory_operand")
     561                 :  1240567231 :        (not (match_operand 0 "pic_32bit_operand"))))
     562                 :             : 
     563                 :   170461605 : ;; Return true if OP is either a symbol reference or a sum of a symbol
     564                 :   170461605 : ;; reference and a constant.
     565                 :   170461605 : (define_predicate "symbolic_operand"
     566                 :   170461605 :   (match_code "symbol_ref,label_ref,const")
     567                 :             : {
     568                 :     8209765 :   switch (GET_CODE (op))
     569                 :             :     {
     570                 :   170461605 :     case SYMBOL_REF:
     571                 :   170461605 :     case LABEL_REF:
     572                 :      172230 :       return true;
     573                 :             : 
     574                 :       32737 :     case CONST:
     575                 :       32737 :       op = XEXP (op, 0);
     576                 :   482016444 :       if (GET_CODE (op) == SYMBOL_REF
     577                 :       32737 :           || GET_CODE (op) == LABEL_REF
     578                 :   482016444 :           || (GET_CODE (op) == UNSPEC
     579                 :        7986 :               && (XINT (op, 1) == UNSPEC_GOT
     580                 :        7986 :                   || XINT (op, 1) == UNSPEC_GOTOFF
     581                 :         172 :                   || XINT (op, 1) == UNSPEC_PCREL
     582                 :     8209937 :                   || XINT (op, 1) == UNSPEC_GOTPCREL)))
     583                 :             :         return true;
     584                 :       24895 :       if (GET_CODE (op) != PLUS
     585                 :       24751 :           || !CONST_INT_P (XEXP (op, 1)))
     586                 :             :         return false;
     587                 :             : 
     588                 :       24751 :       op = XEXP (op, 0);
     589                 :       24751 :       if (GET_CODE (op) == SYMBOL_REF
     590                 :       24751 :           || GET_CODE (op) == LABEL_REF)
     591                 :             :         return true;
     592                 :             :       /* Only @GOTOFF gets offsets.  */
     593                 :        2106 :       if (GET_CODE (op) != UNSPEC
     594                 :        2106 :           || XINT (op, 1) != UNSPEC_GOTOFF)
     595                 :             :         return false;
     596                 :             : 
     597                 :        2106 :       op = XVECEXP (op, 0, 0);
     598                 :        2106 :       if (GET_CODE (op) == SYMBOL_REF
     599                 :        2106 :           || GET_CODE (op) == LABEL_REF)
     600                 :        2106 :         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                 :    15479090 : (define_predicate "local_symbolic_operand"
     610                 :             :   (match_code "const,label_ref,symbol_ref")
     611                 :    15479090 : {
     612                 :     2868563 :   if (GET_CODE (op) == CONST
     613                 :       16132 :       && GET_CODE (XEXP (op, 0)) == PLUS
     614                 :        8356 :       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
     615                 :        8356 :     op = XEXP (XEXP (op, 0), 0);
     616                 :     8209765 : 
     617                 :     2868563 :   if (GET_CODE (op) == LABEL_REF)
     618                 :             :     return true;
     619                 :             : 
     620                 :     2828837 :   if (GET_CODE (op) != SYMBOL_REF)
     621                 :     8209765 :     return false;
     622                 :      526224 : 
     623                 :     2818955 :   if (SYMBOL_REF_TLS_MODEL (op))
     624                 :             :     return false;
     625                 :             : 
     626                 :     2868563 :   /* Dll-imported symbols are always external.  */
     627                 :     2818955 :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     628                 :             :     return false;
     629                 :     2818955 :   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                 :       92131 :   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                 :     2876951 :   (match_operand 0 "local_symbolic_operand")
     646                 :             : {
     647                 :     2876951 :   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                 :     2868563 : 
     652                 :     2868575 :   if (GET_CODE (op) == SYMBOL_REF
     653                 :          12 :       && !SYMBOL_REF_FUNCTION_P (op))
     654                 :           0 :     return false;
     655                 :             : 
     656                 :     2868563 :   return true;
     657                 :     2868563 : })
     658                 :     2766542 : 
     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                 :     2876888 : ;; The comments above seem to apply only to VxWorks releases before 7.
     668                 :             : (define_predicate "gotoff_operand"
     669                 :     2876888 :   (and (ior (not (match_test "TARGET_VXWORKS_VAROFF"))
     670                 :             :             (match_test "ix86_cmodel == CM_LARGE")
     671                 :     2876888 :             (match_test "ix86_cmodel == CM_LARGE_PIC"))
     672                 :             :        (match_operand 0 "local_symbolic_operand")))
     673                 :             : 
     674                 :             : ;; Test for various thread-local symbols.
     675                 :       28983 : (define_special_predicate "tls_symbolic_operand"
     676                 :             :   (and (match_code "symbol_ref")
     677                 :       28983 :        (match_test "SYMBOL_REF_TLS_MODEL (op)")))
     678                 :             : 
     679                 :             : (define_special_predicate "tls_modbase_operand"
     680                 :             :   (and (match_code "symbol_ref")
     681                 :          10 :        (match_test "op == ix86_tls_module_base ()")))
     682                 :             : 
     683                 :          20 : (define_predicate "tls_address_pattern"
     684                 :             :   (and (match_code "set,parallel,unspec,unspec_volatile")
     685                 :   231486709 :        (match_test "ix86_tls_address_pattern_p (op)")))
     686                 :           0 : 
     687                 :   231486709 : ;; Test for a pc-relative call operand
     688                 :             : (define_predicate "constant_call_address_operand"
     689                 :   231486709 :   (match_code "symbol_ref")
     690                 :   361538160 : {
     691                 :   130051242 :   if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
     692                 :   130051236 :       || flag_force_indirect_call
     693                 :   260101183 :       || (TARGET_INDIRECT_BRANCH_REGISTER
     694                 :        1022 :           && ix86_nopic_noplt_attribute_p (op)))
     695                 :        1743 :     return false;
     696                 :             :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     697                 :   231486709 :     return false;
     698                 :             :   return true;
     699                 :             : })
     700                 :             : 
     701                 :             : ;; True for any non-virtual and non-eliminable register.  Used in places where
     702                 :   135981728 : ;; instantiation of such a register may cause the pattern to not be recognized.
     703                 :             : (define_predicate "register_no_elim_operand"
     704                 :   130051451 :   (match_operand 0 "register_operand")
     705                 :   266031436 : {
     706                 :    94637833 :   if (SUBREG_P (op))
     707                 :       68489 :     op = SUBREG_REG (op);
     708                 :             : 
     709                 :             :   /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
     710                 :    20327585 :      because it is guaranteed to be reloaded into one.  */
     711                 :    20327585 :   if (MEM_P (op))
     712                 :             :     return true;
     713                 :             : 
     714                 :    20327585 :   return !(op == arg_pointer_rtx
     715                 :    20300706 :            || op == frame_pointer_rtx
     716                 :    20300198 :            || VIRTUAL_REGISTER_P (op));
     717                 :             : })
     718                 :             : 
     719                 :             : ;; Similarly, but include the stack pointer.  This is used
     720                 :    24984266 : ;; to prevent esp from being used as an index reg.
     721                 :             : (define_predicate "register_no_SP_operand"
     722                 :    24984266 :   (match_operand 0 "register_operand")
     723                 :    20327585 : {
     724                 :      333181 :   if (SUBREG_P (op))
     725                 :        7898 :     op = SUBREG_REG (op);
     726                 :             : 
     727                 :      333181 :   /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
     728                 :             :      because it is guaranteed to be reloaded into one.  */
     729                 :      333181 :   if (MEM_P (op))
     730                 :             :     return true;
     731                 :             : 
     732                 :      333181 :   return !(op == arg_pointer_rtx
     733                 :      333181 :            || op == frame_pointer_rtx
     734                 :      333181 :            || op == stack_pointer_rtx
     735                 :      333181 :            || VIRTUAL_REGISTER_P (op));
     736                 :             : })
     737                 :             : 
     738                 :             : ;; P6 processors will jump to the address after the decrement when %esp
     739                 :      369439 : ;; is used as a call operand, so they will execute return address as a code.
     740                 :             : ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
     741                 :      369439 : 
     742                 :      333181 : (define_predicate "call_register_operand"
     743                 :     1931789 :   (if_then_else (match_test "TARGET_64BIT")
     744                 :             :     (match_operand 0 "register_operand")
     745                 :             :     (match_operand 0 "register_no_SP_operand")))
     746                 :     1931789 : 
     747                 :    18419964 : ;; Return false if this is any eliminable register.  Otherwise general_operand.
     748                 :     1931789 : (define_predicate "general_no_elim_operand"
     749                 :    18419964 :   (if_then_else (match_code "reg,subreg")
     750                 :             :     (match_operand 0 "register_no_elim_operand")
     751                 :             :     (match_operand 0 "general_operand")))
     752                 :             : 
     753                 :    12140229 : ;; Return false if this is any eliminable register.  Otherwise
     754                 :             : ;; register_operand or a constant.
     755                 :    12140229 : (define_predicate "nonmemory_no_elim_operand"
     756                 :             :   (ior (match_operand 0 "register_no_elim_operand")
     757                 :             :        (match_operand 0 "immediate_operand")))
     758                 :             : 
     759                 :      741242 : ;; Test for a valid operand for indirect branch.
     760                 :             : (define_predicate "indirect_branch_operand"
     761                 :      741242 :   (ior (match_operand 0 "register_operand")
     762                 :      674597 :        (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
     763                 :      674570 :             (not (match_test "TARGET_X32"))
     764                 :             :             (match_operand 0 "memory_operand"))))
     765                 :             : 
     766                 :             : ;; Return true if OP is a memory operands that can be used in sibcalls.
     767                 :       24281 : ;; Since sibcall never returns, we can only use call-clobbered register
     768                 :             : ;; as GOT base.  Allow GOT slot here only with pseudo register as GOT
     769                 :             : ;; base.  Properly handle sibcall over GOT slot with *sibcall_GOT_32
     770                 :             : ;; and *sibcall_value_GOT_32 patterns.
     771                 :             : (define_predicate "sibcall_memory_operand"
     772                 :             :   (match_operand 0 "memory_operand")
     773                 :             : {
     774                 :       24281 :   op = XEXP (op, 0);
     775                 :       24281 :   if (CONSTANT_P (op))
     776                 :             :     return true;
     777                 :       11098 :   if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
     778                 :             :     {
     779                 :        9776 :       int regno = REGNO (XEXP (op, 0));
     780                 :        9776 :       if (!HARD_REGISTER_NUM_P (regno) || call_used_or_fixed_reg_p (regno))
     781                 :             :         {
     782                 :        8226 :           op = XEXP (op, 1);
     783                 :        8226 :           if (GOT32_symbol_operand (op, VOIDmode))
     784                 :             :             return true;
     785                 :             :         }
     786                 :             :     }
     787                 :             :   return false;
     788                 :             : })
     789                 :             : 
     790                 :             : ;; Return true if OP is a GOT memory operand.
     791                 :     1370495 : (define_predicate "GOT_memory_operand"
     792                 :             :   (and (match_operand 0 "memory_operand")
     793                 :     1394776 :        (match_code "const" "0")
     794                 :       24281 :        (match_code "unspec" "00")
     795                 :         563 :        (match_test "XINT (XEXP (XEXP (op, 0), 0), 1) == UNSPEC_GOTPCREL")))
     796                 :             : 
     797                 :             : ;; Test for a valid operand for a call instruction.
     798                 :         461 : ;; Allow constant call address operands in Pmode only.
     799                 :    47249766 : (define_special_predicate "call_insn_operand"
     800                 :         461 :   (ior (match_test "constant_call_address_operand
     801                 :    53444032 :                      (op, mode == VOIDmode ? mode : Pmode)")
     802                 :             :        (match_operand 0 "call_register_operand")
     803                 :      918054 :        (match_test "satisfies_constraint_Bw (op)")))
     804                 :             : 
     805                 :             : ;; Similarly, but for tail calls, in which we cannot allow memory references.
     806                 :             : (define_special_predicate "sibcall_insn_operand"
     807                 :     1225113 :   (ior (match_test "constant_call_address_operand
     808                 :     1429764 :                      (op, mode == VOIDmode ? mode : Pmode)")
     809                 :     1225113 :        (match_operand 0 "register_no_elim_operand")
     810                 :      168527 :        (match_test "satisfies_constraint_Bs (op)")))
     811                 :             : 
     812                 :             : ;; Return true if OP is a 32-bit GOT symbol operand.
     813                 :             : (define_predicate "GOT32_symbol_operand"
     814                 :       10127 :   (and (match_code "const")
     815                 :             :        (match_code "unspec" "0")
     816                 :       10127 :        (match_test "XINT (XEXP (op, 0), 1) == UNSPEC_GOT")))
     817                 :           0 : 
     818                 :             : ;; Match exactly zero.
     819                 :             : (define_predicate "const0_operand"
     820                 :             :   (match_code "const_int,const_double,const_vector")
     821                 :   129878255 : {
     822                 :   129878255 :   if (mode == VOIDmode)
     823                 :    20640941 :     mode = GET_MODE (op);
     824                 :   129878255 :   return op == CONST0_RTX (mode);
     825                 :             : })
     826                 :             : 
     827                 :             : ;; Match one or a vector with all elements equal to one.
     828                 :   942139933 : (define_predicate "const1_operand"
     829                 :             :   (match_code "const_int,const_double,const_vector")
     830                 :   942139933 : {
     831                 :    12760881 :   if (mode == VOIDmode)
     832                 :    12758047 :     mode = GET_MODE (op);
     833                 :   142639136 :   return op == CONST1_RTX (mode);
     834                 :   129878255 : })
     835                 :   129878255 : 
     836                 :             : ;; Match exactly -1.
     837                 :    13730932 : (define_predicate "constm1_operand"
     838                 :             :   (and (match_code "const_int")
     839                 :   143609187 :        (match_test "op == constm1_rtx")))
     840                 :   129878255 : 
     841                 :    58942723 : ;; Match 0 or -1.
     842                 :    12760881 : (define_predicate "const0_or_m1_operand"
     843                 :    12763290 :   (ior (match_operand 0 "const0_operand")
     844                 :    12760881 :        (match_operand 0 "constm1_operand")))
     845                 :        2409 : 
     846                 :             : ;; Match exactly eight.
     847                 :             : (define_predicate "const8_operand"
     848                 :    12760881 :   (and (match_code "const_int")
     849                 :    12760881 :        (match_test "INTVAL (op) == 8")))
     850                 :        2807 : 
     851                 :           0 : ;; Match exactly 128.
     852                 :             : (define_predicate "const128_operand"
     853                 :    25788996 :   (and (match_code "const_int")
     854                 :   234819456 :        (match_test "INTVAL (op) == 128")))
     855                 :    25788996 : 
     856                 :   187281681 : ;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation
     857                 :             : (define_predicate "const_32bit_mask"
     858                 :     2637651 :   (and (match_code "const_int")
     859                 :     1776718 :        (match_test "trunc_int_for_mode (INTVAL (op), DImode)
     860                 :     4414369 :                     == HOST_WIDE_INT_C (0xffffffff)")))
     861                 :             : 
     862                 :             : ;; Match 2, 4, or 8.  Used for leal multiplicands.
     863                 :             : (define_predicate "const248_operand"
     864                 :      294730 :   (match_code "const_int")
     865                 :             : {
     866                 :      294730 :   HOST_WIDE_INT i = INTVAL (op);
     867                 :      294730 :   return i == 2 || i == 4 || i == 8;
     868                 :             : })
     869                 :             : 
     870                 :             : ;; Match 1, 2, or 3.  Used for lea shift amounts.
     871                 :      996629 : (define_predicate "const123_operand"
     872                 :             :   (match_code "const_int")
     873                 :      996629 : {
     874                 :     1214000 :   HOST_WIDE_INT i = INTVAL (op);
     875                 :      217371 :   return i == 1 || i == 2 || i == 3;
     876                 :             : })
     877                 :             : 
     878                 :      217371 : ;; Match 2, 3, 6, or 7
     879                 :      225834 : (define_predicate "const2367_operand"
     880                 :             :   (match_code "const_int")
     881                 :      225834 : {
     882                 :      217371 :   HOST_WIDE_INT i = INTVAL (op);
     883                 :           0 :   return i == 2 || i == 3 || i == 6 || i == 7;
     884                 :             : })
     885                 :             : 
     886                 :           0 : ;; Match 1, 2, 4, or 8
     887                 :           0 : (define_predicate "const1248_operand"
     888                 :             :   (match_code "const_int")
     889                 :           0 : {
     890                 :      109568 :   HOST_WIDE_INT i = INTVAL (op);
     891                 :      109568 :   return i == 1 || i == 2 || i == 4 || i == 8;
     892                 :             : })
     893                 :             : 
     894                 :      109568 : ;; Match 3, 5, or 9.  Used for leal multiplicands.
     895                 :      484912 : (define_predicate "const359_operand"
     896                 :             :   (match_code "const_int")
     897                 :      484912 : {
     898                 :      533194 :   HOST_WIDE_INT i = INTVAL (op);
     899                 :       48282 :   return i == 3 || i == 5 || i == 9;
     900                 :             : })
     901                 :             : 
     902                 :       48282 : ;; Match 4 or 8 to 11.  Used for embeded rounding.
     903                 :      200437 : (define_predicate "const_4_or_8_to_11_operand"
     904                 :             :   (match_code "const_int")
     905                 :      200437 : {
     906                 :      280834 :   HOST_WIDE_INT i = INTVAL (op);
     907                 :       80397 :   return i == 4 || (i >= 8 && i <= 11);
     908                 :             : })
     909                 :             : 
     910                 :       80397 : ;; Match 4 or 8. Used for SAE.
     911                 :       80399 : (define_predicate "const48_operand"
     912                 :             :   (match_code "const_int")
     913                 :       80399 : {
     914                 :       80397 :   HOST_WIDE_INT i = INTVAL (op);
     915                 :       63726 :   return i == 4 || i == 8;
     916                 :             : })
     917                 :             : 
     918                 :       63726 : ;; Match 0 or 1.
     919                 :       63726 : (define_predicate "const_0_to_1_operand"
     920                 :             :   (and (match_code "const_int")
     921                 :       63726 :        (ior (match_test "op == const0_rtx")
     922                 :      257756 :             (match_test "op == const1_rtx"))))
     923                 :             : 
     924                 :             : ;; Match 0 to 3.
     925                 :             : (define_predicate "const_0_to_3_operand"
     926                 :     6653152 :   (and (match_code "const_int")
     927                 :    12624101 :        (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
     928                 :     6653152 : 
     929                 :             : ;; Match 0 to 4.
     930                 :             : (define_predicate "const_0_to_4_operand"
     931                 :           0 :   (and (match_code "const_int")
     932                 :           0 :        (match_test "IN_RANGE (INTVAL (op), 0, 4)")))
     933                 :           0 : 
     934                 :             : ;; Match 0 to 5.
     935                 :             : (define_predicate "const_0_to_5_operand"
     936                 :           0 :   (and (match_code "const_int")
     937                 :           0 :        (match_test "IN_RANGE (INTVAL (op), 0, 5)")))
     938                 :           0 : 
     939                 :             : ;; Match 0 to 7.
     940                 :             : (define_predicate "const_0_to_7_operand"
     941                 :      609911 :   (and (match_code "const_int")
     942                 :     1219808 :        (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
     943                 :      609911 : 
     944                 :             : ;; Match 0 to 15.
     945                 :             : (define_predicate "const_0_to_15_operand"
     946                 :       80645 :   (and (match_code "const_int")
     947                 :      161274 :        (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
     948                 :       80645 : 
     949                 :             : ;; Match 0 to 31.
     950                 :             : (define_predicate "const_0_to_31_operand"
     951                 :       62516 :   (and (match_code "const_int")
     952                 :      124473 :        (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
     953                 :       62516 : 
     954                 :             : ;; Match 0 to 63.
     955                 :             : (define_predicate "const_0_to_63_operand"
     956                 :       29502 :   (and (match_code "const_int")
     957                 :       57193 :        (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
     958                 :       29502 : 
     959                 :             : ;; Match 0 to 127.
     960                 :             : (define_predicate "const_0_to_127_operand"
     961                 :        9402 :   (and (match_code "const_int")
     962                 :       17948 :        (match_test "IN_RANGE (INTVAL (op), 0, 127)")))
     963                 :        9402 : 
     964                 :             : ;; Match 0 to 255.
     965                 :             : (define_predicate "const_0_to_255_operand"
     966                 :     8714169 :   (and (match_code "const_int")
     967                 :    17393980 :        (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
     968                 :     8714169 : 
     969                 :             : ;; Match (0 to 255) * 8
     970                 :             : (define_predicate "const_0_to_255_mul_8_operand"
     971                 :      422541 :   (match_code "const_int")
     972                 :             : {
     973                 :      422541 :   unsigned HOST_WIDE_INT val = INTVAL (op);
     974                 :      422541 :   return val <= 255*8 && val % 8 == 0;
     975                 :             : })
     976                 :             : 
     977                 :             : ;; Match 1 to 255 except multiples of 8
     978                 :      422543 : (define_predicate "const_0_to_255_not_mul_8_operand"
     979                 :             :   (match_code "const_int")
     980                 :      422543 : {
     981                 :     1226673 :   unsigned HOST_WIDE_INT val = INTVAL (op);
     982                 :      804116 :   return val <= 255 && val % 8 != 0;
     983                 :             : })
     984                 :             : 
     985                 :      804130 : ;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand
     986                 :      804130 : ;; for shift & compare patterns, as shifting by 0 does not change flags).
     987                 :             : (define_predicate "const_1_to_31_operand"
     988                 :      804130 :   (and (match_code "const_int")
     989                 :      847724 :        (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
     990                 :             : 
     991                 :             : ;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand
     992                 :             : ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
     993                 :       89985 : (define_predicate "const_1_to_63_operand"
     994                 :             :   (and (match_code "const_int")
     995                 :       89985 :        (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
     996                 :             : 
     997                 :             : ;; Match 2 or 3.
     998                 :             : (define_predicate "const_2_to_3_operand"
     999                 :       69967 :   (and (match_code "const_int")
    1000                 :      139934 :        (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
    1001                 :       69967 : 
    1002                 :             : ;; Match 4 to 5.
    1003                 :             : (define_predicate "const_4_to_5_operand"
    1004                 :        6547 :   (and (match_code "const_int")
    1005                 :       13094 :        (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
    1006                 :        6547 : 
    1007                 :             : ;; Match 4 to 7.
    1008                 :             : (define_predicate "const_4_to_7_operand"
    1009                 :      916423 :   (and (match_code "const_int")
    1010                 :     1832846 :        (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
    1011                 :      916423 : 
    1012                 :             : ;; Match 6 to 7.
    1013                 :             : (define_predicate "const_6_to_7_operand"
    1014                 :         686 :   (and (match_code "const_int")
    1015                 :        1372 :        (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
    1016                 :         686 : 
    1017                 :             : ;; Match 8 to 9.
    1018                 :             : (define_predicate "const_8_to_9_operand"
    1019                 :         506 :   (and (match_code "const_int")
    1020                 :        1012 :        (match_test "IN_RANGE (INTVAL (op), 8, 9)")))
    1021                 :         506 : 
    1022                 :             : ;; Match 8 to 11.
    1023                 :             : (define_predicate "const_8_to_11_operand"
    1024                 :       44096 :   (and (match_code "const_int")
    1025                 :       88192 :        (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
    1026                 :       44096 : 
    1027                 :             : ;; Match 8 to 15.
    1028                 :             : (define_predicate "const_8_to_15_operand"
    1029                 :       42683 :   (and (match_code "const_int")
    1030                 :       85366 :        (match_test "IN_RANGE (INTVAL (op), 8, 15)")))
    1031                 :       42683 : 
    1032                 :             : ;; Match 10 to 11.
    1033                 :             : (define_predicate "const_10_to_11_operand"
    1034                 :         265 :   (and (match_code "const_int")
    1035                 :         530 :        (match_test "IN_RANGE (INTVAL (op), 10, 11)")))
    1036                 :         265 : 
    1037                 :             : ;; Match 12 to 13.
    1038                 :             : (define_predicate "const_12_to_13_operand"
    1039                 :         265 :   (and (match_code "const_int")
    1040                 :         530 :        (match_test "IN_RANGE (INTVAL (op), 12, 13)")))
    1041                 :         265 : 
    1042                 :             : ;; Match 12 to 15.
    1043                 :             : (define_predicate "const_12_to_15_operand"
    1044                 :       28686 :   (and (match_code "const_int")
    1045                 :       57372 :        (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
    1046                 :       28686 : 
    1047                 :             : ;; Match 14 to 15.
    1048                 :             : (define_predicate "const_14_to_15_operand"
    1049                 :         265 :   (and (match_code "const_int")
    1050                 :         530 :        (match_test "IN_RANGE (INTVAL (op), 14, 15)")))
    1051                 :         265 : 
    1052                 :             : ;; Match 16 to 19.
    1053                 :             : (define_predicate "const_16_to_19_operand"
    1054                 :        1470 :   (and (match_code "const_int")
    1055                 :        2940 :        (match_test "IN_RANGE (INTVAL (op), 16, 19)")))
    1056                 :        1470 : 
    1057                 :             : ;; Match 16 to 31.
    1058                 :             : (define_predicate "const_16_to_31_operand"
    1059                 :       10137 :   (and (match_code "const_int")
    1060                 :       20274 :        (match_test "IN_RANGE (INTVAL (op), 16, 31)")))
    1061                 :       10137 : 
    1062                 :             : ;; Match 20 to 23.
    1063                 :             : (define_predicate "const_20_to_23_operand"
    1064                 :        1078 :   (and (match_code "const_int")
    1065                 :        2156 :        (match_test "IN_RANGE (INTVAL (op), 20, 23)")))
    1066                 :        1078 : 
    1067                 :             : ;; Match 24 to 27.
    1068                 :             : (define_predicate "const_24_to_27_operand"
    1069                 :        1078 :   (and (match_code "const_int")
    1070                 :        2156 :        (match_test "IN_RANGE (INTVAL (op), 24, 27)")))
    1071                 :        1078 : 
    1072                 :             : ;; Match 28 to 31.
    1073                 :             : (define_predicate "const_28_to_31_operand"
    1074                 :        1078 :   (and (match_code "const_int")
    1075                 :        2156 :        (match_test "IN_RANGE (INTVAL (op), 28, 31)")))
    1076                 :        1078 : 
    1077                 :             : (define_predicate "cmpps_imm_operand"
    1078                 :             :   (ior (match_operand 0 "const_0_to_7_operand")
    1079                 :        3987 :        (and (match_test "TARGET_AVX")
    1080                 :             :             (match_operand 0 "const_0_to_31_operand"))))
    1081                 :       30496 : 
    1082                 :             : ;; True if this is a constant appropriate for an increment or decrement.
    1083                 :    96113274 : (define_predicate "incdec_operand"
    1084                 :             :   (match_code "const_int")
    1085                 :             : {
    1086                 :             :   /* On Pentium4, the inc and dec operations causes extra dependency on flag
    1087                 :             :      registers, since carry flag is not set.  */
    1088                 :    96113274 :   if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
    1089                 :             :     return false;
    1090                 :     2354863 :   return op == const1_rtx || op == constm1_rtx;
    1091                 :             : })
    1092                 :             : 
    1093                 :             : ;; True for registers, or const_int_operand, used to vec_setm expander.
    1094                 :   118455988 : (define_predicate "vec_setm_sse41_operand"
    1095                 :             :   (ior (and (match_operand 0 "register_operand")
    1096                 :   214569927 :             (match_test "TARGET_SSE4_1"))
    1097                 :    96113274 :        (match_code "const_int")))
    1098                 :             : 
    1099                 :             : (define_predicate "vec_setm_avx2_operand"
    1100                 :             :   (ior (and (match_operand 0 "register_operand")
    1101                 :         901 :             (match_test "TARGET_AVX2"))
    1102                 :           0 :        (match_code "const_int")))
    1103                 :        1136 : 
    1104                 :             : (define_predicate "vec_setm_mmx_operand"
    1105                 :             :   (ior (and (match_operand 0 "register_operand")
    1106                 :          22 :             (match_test "TARGET_SSE4_1")
    1107                 :         234 :             (match_test "TARGET_MMX_WITH_SSE"))
    1108                 :         234 :        (match_code "const_int")))
    1109                 :             : 
    1110                 :             : ;; True for registers, or 1 or -1.  Used to optimize double-word shifts.
    1111                 :             : (define_predicate "reg_or_pm1_operand"
    1112                 :     4188838 :   (ior (match_operand 0 "register_operand")
    1113                 :             :        (and (match_code "const_int")
    1114                 :     4188838 :             (ior (match_test "op == const1_rtx")
    1115                 :      287100 :                  (match_test "op == constm1_rtx")))))
    1116                 :      271699 : 
    1117                 :             : ;; True for registers, or (not: registers).  Used to optimize 3-operand
    1118                 :             : ;; bitwise operation.
    1119                 :             : (define_predicate "regmem_or_bitnot_regmem_operand"
    1120                 :      502835 :   (ior (match_operand 0 "nonimmediate_operand")
    1121                 :             :        (and (match_code "not")
    1122                 :      502835 :             (match_test "nonimmediate_operand (XEXP (op, 0), mode)"))))
    1123                 :       26775 : 
    1124                 :             : ;; True for expressions valid for 3-operand ternlog instructions.
    1125                 :             : (define_predicate "ternlog_operand"
    1126                 :             :   (and (match_code "not,and,ior,xor")
    1127                 :     1866508 :        (match_test "ix86_ternlog_operand_p (op)")))
    1128                 :      199923 : 
    1129                 :    64462901 : ;; True if OP is acceptable as operand of DImode shift expander.
    1130                 :             : (define_predicate "shiftdi_operand"
    1131                 :     1290543 :   (if_then_else (match_test "TARGET_64BIT")
    1132                 :     3157051 :     (match_operand 0 "nonimmediate_operand")
    1133                 :     1866508 :     (match_operand 0 "register_operand")))
    1134                 :     1290543 : 
    1135                 :     2459767 : (define_predicate "ashldi_input_operand"
    1136                 :      593259 :   (if_then_else (match_test "TARGET_64BIT")
    1137                 :      593259 :     (match_operand 0 "nonimmediate_operand")
    1138                 :             :     (match_operand 0 "reg_or_pm1_operand")))
    1139                 :     1866508 : 
    1140                 :      555084 : ;; Return true if OP is a vector load from the constant pool with just
    1141                 :             : ;; the first element nonzero.
    1142                 :             : (define_predicate "zero_extended_scalar_load_operand"
    1143                 :             :   (match_code "mem")
    1144                 :             : {
    1145                 :      555084 :   unsigned n_elts;
    1146                 :      555084 :   op = avoid_constant_pool_reference (op);
    1147                 :             : 
    1148                 :      555084 :   if (GET_CODE (op) != CONST_VECTOR)
    1149                 :             :     return false;
    1150                 :             : 
    1151                 :       81955 :   n_elts = CONST_VECTOR_NUNITS (op);
    1152                 :             : 
    1153                 :      166869 :   for (n_elts--; n_elts > 0; n_elts--)
    1154                 :             :     {
    1155                 :      121779 :       rtx elt = CONST_VECTOR_ELT (op, n_elts);
    1156                 :      243558 :       if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
    1157                 :             :         return false;
    1158                 :             :     }
    1159                 :             :   return true;
    1160                 :             : })
    1161                 :             : 
    1162                 :             : /* Return true if operand is a float vector constant that is all ones. */
    1163                 :     1796372 : (define_predicate "float_vector_all_ones_operand"
    1164                 :             :   (match_code "const_vector,mem")
    1165                 :      555084 : {
    1166                 :     1841462 :   mode = GET_MODE (op);
    1167                 :       45090 :   if (!FLOAT_MODE_P (mode)
    1168                 :    13664493 :       || (MEM_P (op)
    1169                 :    11777494 :           && (!SYMBOL_REF_P (XEXP (op, 0))
    1170                 :     1458953 :               || !CONSTANT_POOL_ADDRESS_P (XEXP (op, 0)))))
    1171                 :    16497953 :     return false;
    1172                 :             : 
    1173                 :     3098463 :   if (MEM_P (op))
    1174                 :             :     {
    1175                 :     1211464 :       op = get_pool_constant (XEXP (op, 0));
    1176                 :     1211464 :       if (GET_CODE (op) != CONST_VECTOR)
    1177                 :             :         return false;
    1178                 :             : 
    1179                 :     1211460 :       if (GET_MODE (op) != mode
    1180                 :        4423 :          && INTEGRAL_MODE_P (GET_MODE (op))
    1181                 :        4423 :          && op == CONSTM1_RTX (GET_MODE (op)))
    1182                 :             :         return true;
    1183                 :             :     }
    1184                 :             : 
    1185                 :     3098459 :   rtx first = XVECEXP (op, 0, 0);
    1186                 :     8645800 :   for (int i = 1; i != GET_MODE_NUNITS (GET_MODE (op)); i++)
    1187                 :             :     {
    1188                 :     3835161 :       rtx tmp = XVECEXP (op, 0, i);
    1189                 :     3835161 :       if (!rtx_equal_p (tmp, first))
    1190                 :             :         return false;
    1191                 :             :     }
    1192                 :      487739 :   if (GET_MODE (first) == E_SFmode)
    1193                 :             :     {
    1194                 :      220604 :       long l;
    1195                 :      220604 :       REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (first), l);
    1196                 :      220604 :       return (l & 0xffffffff) == 0xffffffff;
    1197                 :             :     }
    1198                 :      267135 :   else if (GET_MODE (first) == E_DFmode)
    1199                 :             :     {
    1200                 :      261874 :       long l[2];
    1201                 :      261874 :       REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (first), l);
    1202                 :      261874 :       return ((l[0] & 0xffffffff) == 0xffffffff
    1203                 :      261874 :              && (l[1] & 0xffffffff) == 0xffffffff);
    1204                 :             :     }
    1205                 :             :   else
    1206                 :             :     return false;
    1207                 :             : })
    1208                 :             : 
    1209                 :             : /* Return true if operand is an integral vector constant that is all ones. */
    1210                 :    53585816 : (define_predicate "vector_all_ones_operand"
    1211                 :             :   (and (match_code "const_vector")
    1212                 :    66304273 :        (match_test "INTEGRAL_MODE_P (GET_MODE (op))")
    1213                 :    10854674 :        (match_test "op == CONSTM1_RTX (GET_MODE (op))")))
    1214                 :      788483 : 
    1215                 :    16497953 : /* Return true if operand is a vector constant that is all ones. */
    1216                 :    16497953 : (define_predicate "int_float_vector_all_ones_operand"
    1217                 :             :   (ior (match_operand 0 "vector_all_ones_operand")
    1218                 :     8618682 :        (match_operand 0 "float_vector_all_ones_operand")
    1219                 :           0 :        (match_test "op == constm1_rtx")))
    1220                 :     8618682 : 
    1221                 :    16497953 : /* Return true if operand is an 128/256bit all ones vector
    1222                 :        3031 :    that zero-extends to 256/512bit.  */
    1223                 :             : (define_predicate "vector_all_ones_zero_extend_half_operand"
    1224                 :    11512148 :   (match_code "const_vector")
    1225                 :             : {
    1226                 :   154939877 :   mode = GET_MODE (op);
    1227                 :    11512148 :   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
    1228                 :   164784350 :       || (GET_MODE_SIZE (mode) != 32
    1229                 :     9577245 :           && GET_MODE_SIZE (mode) != 64))
    1230                 :             :     return false;
    1231                 :             : 
    1232                 :      411184 :   int nelts = CONST_VECTOR_NUNITS (op);
    1233                 :      453980 :   for (int i = 0; i != nelts; i++)
    1234                 :             :     {
    1235                 :      453048 :       rtx elt = CONST_VECTOR_ELT (op, i);
    1236                 :      453048 :       if (i < nelts / 2
    1237                 :      899669 :           && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
    1238                 :             :         return false;
    1239                 :       47288 :       if (i >= nelts / 2
    1240                 :       53715 :           && elt != CONST0_RTX (GET_MODE_INNER (mode)))
    1241                 :             :         return false;
    1242                 :             :     }
    1243                 :             :   return true;
    1244                 :             : })
    1245                 :             : 
    1246                 :             : /* Return true if operand is an 128bit all ones vector
    1247                 :   156576235 :    that zero extends to 512bit.  */
    1248                 :             : (define_predicate "vector_all_ones_zero_extend_quarter_operand"
    1249                 :    11512148 :   (match_code "const_vector")
    1250                 :   156577167 : {
    1251                 :         932 :   mode = GET_MODE (op);
    1252                 :    11511216 :   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
    1253                 :     9843541 :       || GET_MODE_SIZE (mode) != 64)
    1254                 :             :     return false;
    1255                 :    11511216 : 
    1256                 :      143752 :   int nelts = CONST_VECTOR_NUNITS (op);
    1257                 :      155546 :   for (int i = 0; i != nelts; i++)
    1258                 :             :     {
    1259                 :      155460 :       rtx elt = CONST_VECTOR_ELT (op, i);
    1260                 :      155460 :       if (i < nelts / 4
    1261                 :      307732 :           && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
    1262                 :             :         return false;
    1263                 :       14166 :       if (i >= nelts / 4
    1264                 :       17354 :           && elt != CONST0_RTX (GET_MODE_INNER (mode)))
    1265                 :             :         return false;
    1266                 :             :     }
    1267                 :             :   return true;
    1268                 :             : })
    1269                 :             : 
    1270                 :             : ; Return true when OP is operand acceptable for vector memory operand.
    1271                 :   156575303 : ; Only AVX can have misaligned memory operand.
    1272                 :             : (define_predicate "vector_memory_operand"
    1273                 :    11511216 :   (and (match_operand 0 "memory_operand")
    1274                 :   157698597 :        (ior (match_test "TARGET_AVX")
    1275                 :     1123294 :             (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)"))))
    1276                 :             : 
    1277                 :             : ; Return true when OP is register_operand or vector_memory_operand.
    1278                 :             : (define_predicate "vector_operand"
    1279                 :    17554552 :   (ior (match_operand 0 "register_operand")
    1280                 :             :        (match_operand 0 "vector_memory_operand")))
    1281                 :    17554552 : 
    1282                 :             : ; Return true when OP is register_operand, vector_memory_operand
    1283                 :             : ; or const_vector.
    1284                 :             : (define_predicate "vector_or_const_vector_operand"
    1285                 :       12512 :   (ior (match_operand 0 "register_operand")
    1286                 :             :        (match_operand 0 "vector_memory_operand")
    1287                 :       12512 :        (match_code "const_vector")))
    1288                 :        7228 : 
    1289                 :             : ; Return true when OP is register_operand, vector_memory_operand,
    1290                 :             : ; const_vector zero or const_vector all ones.
    1291                 :             : (define_predicate "vector_or_0_or_1s_operand"
    1292                 :        3769 :   (ior (match_operand 0 "register_operand")
    1293                 :             :        (match_operand 0 "vector_memory_operand")
    1294                 :        3769 :        (match_operand 0 "const0_operand")
    1295                 :             :        (match_operand 0 "int_float_vector_all_ones_operand")))
    1296                 :             : 
    1297                 :             : (define_predicate "bcst_mem_operand"
    1298                 :   161849760 :   (and (match_code "vec_duplicate")
    1299                 :        9605 :        (and (match_test "TARGET_AVX512F")
    1300                 :       88896 :             (ior (match_test "TARGET_AVX512VL")
    1301                 :        8726 :                  (match_test "GET_MODE_SIZE (GET_MODE (op)) == 64")))
    1302                 :       30432 :        (match_test "VALID_BCST_MODE_P (GET_MODE_INNER (GET_MODE (op)))")
    1303                 :        8793 :        (match_test "GET_MODE (XEXP (op, 0))
    1304                 :       26363 :                     == GET_MODE_INNER (GET_MODE (op))")
    1305                 :   161863892 :        (match_test "memory_operand (XEXP (op, 0), GET_MODE (XEXP (op, 0)))")))
    1306                 :        5355 : 
    1307                 :             : ; Return true when OP is bcst_mem_operand or vector_memory_operand.
    1308                 :             : (define_predicate "bcst_vector_operand"
    1309                 :             :   (ior (match_operand 0 "vector_operand")
    1310                 :     4859922 :        (match_operand 0 "bcst_mem_operand")))
    1311                 :             : 
    1312                 :     4859922 : ;; Return true when OP is either nonimmediate operand, or any
    1313                 :             : ;; CONST_VECTOR.
    1314                 :             : (define_predicate "nonimmediate_or_const_vector_operand"
    1315                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1316                 :       78428 :        (match_code "const_vector")))
    1317                 :             : 
    1318                 :       78428 : (define_predicate "nonimmediate_or_const_vec_dup_operand"
    1319                 :       10672 :   (ior (match_operand 0 "nonimmediate_operand")
    1320                 :          58 :        (match_test "const_vec_duplicate_p (op)")))
    1321                 :          58 : 
    1322                 :             : ;; Return true when OP is either register operand, or any
    1323                 :         106 : ;; CONST_VECTOR.
    1324                 :             : (define_predicate "reg_or_const_vector_operand"
    1325                 :         106 :   (ior (match_operand 0 "register_operand")
    1326                 :             :        (match_code "const_vector")))
    1327                 :         240 : 
    1328                 :         153 : ;; Return true when OP is CONST_VECTOR which can be converted to a
    1329                 :             : ;; sign extended 32-bit integer.
    1330                 :             : (define_predicate "x86_64_const_vector_operand"
    1331                 :             :   (match_code "const_vector")
    1332                 :      173483 : {
    1333                 :      173483 :   if (mode == VOIDmode)
    1334                 :           0 :     mode = GET_MODE (op);
    1335                 :      173483 :   else if (GET_MODE (op) != mode)
    1336                 :             :     return false;
    1337                 :      407979 :   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
    1338                 :             :     return false;
    1339                 :      130316 :   HOST_WIDE_INT val = ix86_convert_const_vector_to_integer (op, mode);
    1340                 :      130316 :   return trunc_int_for_mode (val, SImode) == val;
    1341                 :             : })
    1342                 :             : 
    1343                 :             : (define_predicate "nonimmediate_or_x86_64_const_vector_operand"
    1344                 :     1506478 :   (ior (match_operand 0 "nonimmediate_operand")
    1345                 :             :        (match_operand 0 "x86_64_const_vector_operand")))
    1346                 :      173483 : 
    1347                 :     1622818 : ;; Return true when OP is nonimmediate or standard SSE constant.
    1348                 :      116340 : (define_predicate "nonimmediate_or_sse_const_operand"
    1349                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1350                 :    22545392 :        (match_test "standard_sse_constant_p (op, mode)")))
    1351                 :     2382477 : 
    1352                 :        3976 : ;; Return true if OP is a register or a zero.
    1353                 :             : (define_predicate "reg_or_0_operand"
    1354                 :        3976 :   (ior (match_operand 0 "register_operand")
    1355                 :      579474 :        (match_operand 0 "const0_operand")))
    1356                 :             : 
    1357                 :      579474 : ; Return true when OP is a nonimmediate or zero.
    1358                 :    95213878 : (define_predicate "nonimm_or_0_operand"
    1359                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1360                 :   115376793 :        (match_operand 0 "const0_operand")))
    1361                 :    73629050 : 
    1362                 :             : ; Return true when OP is a nonimmediate or zero or all ones.
    1363                 :    73629050 : (define_predicate "nonimm_or_0_or_1s_operand"
    1364                 :             :   (ior (match_operand 0 "nonimmediate_operand")
    1365                 :             :        (match_operand 0 "const0_operand")
    1366                 :             :        (match_operand 0 "int_float_vector_all_ones_operand")))
    1367                 :      101960 : 
    1368                 :             : ;; Return true for RTX codes that force SImode address.
    1369                 :      101960 : (define_predicate "SImode_address_operand"
    1370                 :             :   (match_code "subreg,zero_extend,and"))
    1371                 :             : 
    1372                 :             : ;; Return true if op is a valid address for LEA, and does not contain
    1373                 :   261929610 : ;; a segment override.  Defined as a special predicate to allow
    1374                 :             : ;; mode-less const_int operands pass to address_operand.
    1375                 :   261929610 : (define_special_predicate "address_no_seg_operand"
    1376                 :   175549618 :   (match_test "address_operand (op, VOIDmode)")
    1377                 :    63806886 : {
    1378                 :    64260962 :   struct ix86_address parts;
    1379                 :    64260962 :   int ok;
    1380                 :      454076 : 
    1381                 :    63846723 :   if (!CONST_INT_P (op)
    1382                 :    60952232 :       && mode != VOIDmode
    1383                 :    60952232 :       && GET_MODE (op) != mode)
    1384                 :      454076 :     return false;
    1385                 :      454076 : 
    1386                 :    63806822 :   ok = ix86_decompose_address (op, &parts);
    1387                 :    63806822 :   gcc_assert (ok);
    1388                 :    63806822 :   return parts.seg == ADDR_SPACE_GENERIC;
    1389                 :    63806886 : })
    1390                 :             : 
    1391                 :             : ;; Return true if op if a valid base register, displacement or
    1392                 :   111742732 : ;; sum of base register and displacement for VSIB addressing.
    1393                 :             : (define_predicate "vsib_address_operand"
    1394                 :   111782569 :   (match_test "address_operand (op, VOIDmode)")
    1395                 :       80435 : {
    1396                 :       38415 :   struct ix86_address parts;
    1397                 :       39837 :   int ok;
    1398                 :       39837 :   rtx disp;
    1399                 :             : 
    1400                 :       39837 :   ok = ix86_decompose_address (op, &parts);
    1401                 :       39837 :   gcc_assert (ok);
    1402                 :       66806 :   if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
    1403                 :       26969 :     return false;
    1404                 :             : 
    1405                 :             :   /* VSIB addressing doesn't support (%rip).  */
    1406                 :       39817 :   if (parts.disp)
    1407                 :    26322235 :     {
    1408                 :        7779 :       disp = parts.disp;
    1409                 :        7779 :       if (GET_CODE (disp) == CONST)
    1410                 :             :         {
    1411                 :         151 :           disp = XEXP (disp, 0);
    1412                 :         151 :           if (GET_CODE (disp) == PLUS)
    1413                 :         151 :             disp = XEXP (disp, 0);
    1414                 :         151 :           if (GET_CODE (disp) == UNSPEC)
    1415                 :           0 :             switch (XINT (disp, 1))
    1416                 :             :               {
    1417                 :             :               case UNSPEC_GOTPCREL:
    1418                 :             :               case UNSPEC_PCREL:
    1419                 :             :               case UNSPEC_GOTNTPOFF:
    1420                 :             :                 return false;
    1421                 :             :               }
    1422                 :             :         }
    1423                 :        7779 :       if (TARGET_64BIT
    1424                 :        7779 :           && flag_pic
    1425                 :           0 :           && (GET_CODE (disp) == SYMBOL_REF
    1426                 :           0 :               || GET_CODE (disp) == LABEL_REF))
    1427                 :           0 :         return false;
    1428                 :             :     }
    1429                 :             : 
    1430                 :             :   return true;
    1431                 :             : })
    1432                 :             : 
    1433                 :             : (define_predicate "vsib_mem_operator"
    1434                 :       40618 :   (match_code "mem"))
    1435                 :             : 
    1436                 :       40618 : ;; Return true if the rtx is known to be at least 32 bits aligned.
    1437                 :             : (define_predicate "aligned_operand"
    1438                 :             :   (match_operand 0 "general_operand")
    1439                 :             : {
    1440                 :    26322235 :   struct ix86_address parts;
    1441                 :    26322235 :   int ok;
    1442                 :             : 
    1443                 :             :   /* Registers and immediate operands are always "aligned".  */
    1444                 :    26322235 :   if (!MEM_P (op))
    1445                 :             :     return true;
    1446                 :             : 
    1447                 :             :   /* All patterns using aligned_operand on memory operands ends up
    1448                 :             :      in promoting memory operand to 64bit and thus causing memory mismatch.  */
    1449                 :     7368175 :   if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
    1450                 :             :     return false;
    1451                 :             : 
    1452                 :             :   /* Don't even try to do any aligned optimizations with volatiles.  */
    1453                 :      140331 :   if (MEM_VOLATILE_P (op))
    1454                 :             :     return false;
    1455                 :             : 
    1456                 :      127367 :   if (MEM_ALIGN (op) >= 32)
    1457                 :             :     return true;
    1458                 :             : 
    1459                 :       46029 :   op = XEXP (op, 0);
    1460                 :             : 
    1461                 :             :   /* Pushes and pops are only valid on the stack pointer.  */
    1462                 :       46029 :   if (GET_CODE (op) == PRE_DEC
    1463                 :       46029 :       || GET_CODE (op) == POST_INC)
    1464                 :             :     return true;
    1465                 :             : 
    1466                 :             :   /* Decode the address.  */
    1467                 :       46029 :   ok = ix86_decompose_address (op, &parts);
    1468                 :       46029 :   gcc_assert (ok);
    1469                 :             : 
    1470                 :       46029 :   if (parts.base && SUBREG_P (parts.base))
    1471                 :           0 :     parts.base = SUBREG_REG (parts.base);
    1472                 :       46029 :   if (parts.index && SUBREG_P (parts.index))
    1473                 :           0 :     parts.index = SUBREG_REG (parts.index);
    1474                 :             : 
    1475                 :             :   /* Look for some component that isn't known to be aligned.  */
    1476                 :       46029 :   if (parts.index)
    1477                 :             :     {
    1478                 :        3745 :       if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
    1479                 :             :         return false;
    1480                 :             :     }
    1481                 :       42284 :   if (parts.base)
    1482                 :             :     {
    1483                 :       35307 :       if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
    1484                 :             :         return false;
    1485                 :             :     }
    1486                 :       13867 :   if (parts.disp)
    1487                 :             :     {
    1488                 :       13867 :       if (!CONST_INT_P (parts.disp)
    1489                 :        6998 :           || (INTVAL (parts.disp) & 3))
    1490                 :             :         return false;
    1491                 :             :     }
    1492                 :             : 
    1493                 :             :   /* Didn't find one -- this must be an aligned address.  */
    1494                 :             :   return true;
    1495                 :             : })
    1496                 :             : 
    1497                 :             : ;; Return true if OP is memory operand with a displacement.
    1498                 :    26867657 : (define_predicate "memory_displacement_operand"
    1499                 :             :   (match_operand 0 "memory_operand")
    1500                 :    53189892 : {
    1501                 :    26322235 :   struct ix86_address parts;
    1502                 :           0 :   int ok;
    1503                 :             : 
    1504                 :           0 :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1505                 :           0 :   gcc_assert (ok);
    1506                 :           0 :   return parts.disp != NULL_RTX;
    1507                 :             : })
    1508                 :             : 
    1509                 :             : ;; Return true if OP is memory operand with a displacement only.
    1510                 :           0 : (define_predicate "memory_displacement_only_operand"
    1511                 :             :   (match_operand 0 "memory_operand")
    1512                 :           0 : {
    1513                 :           0 :   struct ix86_address parts;
    1514                 :    38806917 :   int ok;
    1515                 :             : 
    1516                 :    38806917 :   if (TARGET_64BIT)
    1517                 :    38806917 :     return false;
    1518                 :             : 
    1519                 :    18900884 :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1520                 :    18900884 :   gcc_assert (ok);
    1521                 :             : 
    1522                 :    18900884 :   if (parts.base || parts.index)
    1523                 :             :     return false;
    1524                 :             : 
    1525                 :      233210 :   return parts.disp != NULL_RTX;
    1526                 :             : })
    1527                 :             : 
    1528                 :             : ;; Return true if OP is memory operand that cannot be represented
    1529                 :    60174323 : ;; by the modRM array.
    1530                 :             : (define_predicate "long_memory_operand"
    1531                 :    98981240 :   (and (match_operand 0 "memory_operand")
    1532                 :    38806917 :        (match_test "memory_address_length (op, false)")))
    1533                 :             : 
    1534                 :             : ;; Return true if OP is a comparison operator that can be issued by fcmov.
    1535                 :             : (define_predicate "fcmov_comparison_operator"
    1536                 :       84067 :   (match_operand 0 "comparison_operator")
    1537                 :             : {
    1538                 :           0 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1539                 :       84067 :   enum rtx_code code = GET_CODE (op);
    1540                 :             : 
    1541                 :       84067 :   if (inmode == CCFPmode)
    1542                 :        8501 :     code = ix86_fp_compare_code_to_integer (code);
    1543                 :             : 
    1544                 :             :   /* i387 supports just limited amount of conditional codes.  */
    1545                 :       84067 :   switch (code)
    1546                 :             :     {
    1547                 :        2027 :     case GEU: case LTU:
    1548                 :        2027 :       if (inmode == CCCmode || inmode == CCGZmode)
    1549                 :             :         return true;
    1550                 :             :       /* FALLTHRU */
    1551                 :        6624 :     case GTU: case LEU:
    1552                 :        6624 :       if (inmode == CCmode || inmode == CCFPmode)
    1553                 :             :         return true;
    1554                 :             :       return false;
    1555                 :             :     case ORDERED: case UNORDERED:
    1556                 :             :     case EQ: case NE:
    1557                 :             :       return true;
    1558                 :             :     default:
    1559                 :             :       return false;
    1560                 :             :     }
    1561                 :             : })
    1562                 :             : 
    1563                 :             : ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
    1564                 :       84067 : ;; The first set are supported directly; the second set can't be done with
    1565                 :             : ;; full IEEE support, i.e. NaNs.
    1566                 :      168134 : 
    1567                 :       84067 : (define_predicate "sse_comparison_operator"
    1568                 :             :   (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered")
    1569                 :      132539 :        (and (match_test "TARGET_AVX")
    1570                 :      132539 :             (match_code "ge,gt,uneq,unle,unlt,ltgt"))))
    1571                 :      133999 : 
    1572                 :             : (define_predicate "ix86_comparison_int_operator"
    1573                 :      133999 :   (match_code "ne,eq,ge,gt,le,lt"))
    1574                 :      192172 : 
    1575                 :             : (define_predicate "ix86_comparison_uns_operator"
    1576                 :      192172 :   (match_code "ne,eq,geu,gtu,leu,ltu"))
    1577                 :             : 
    1578                 :      192172 : (define_predicate "bt_comparison_operator"
    1579                 :      192172 :   (match_code "ne,eq"))
    1580                 :      192172 : 
    1581                 :      192172 : (define_predicate "shr_comparison_operator"
    1582                 :      192172 :   (match_code "gtu,leu"))
    1583                 :      192172 : 
    1584                 :      192172 : (define_predicate "add_comparison_operator"
    1585                 :             :   (match_code "geu,ltu"))
    1586                 :             : 
    1587                 :             : ;; Return true if OP is a valid comparison operator in valid mode.
    1588                 :      192172 : (define_predicate "ix86_comparison_operator"
    1589                 :      192172 :   (match_operand 0 "comparison_operator")
    1590                 :             : {
    1591                 :    98561000 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1592                 :    98561000 :   enum rtx_code code = GET_CODE (op);
    1593                 :      107017 : 
    1594                 :    98561000 :   if (inmode == CCFPmode)
    1595                 :     6900095 :     return ix86_trivial_fp_comparison_operator (op, mode);
    1596                 :             : 
    1597                 :    91767922 :   switch (code)
    1598                 :      107017 :     {
    1599                 :    71013459 :     case EQ: case NE:
    1600                 :    70906442 :       if (inmode == CCGZmode)
    1601                 :           0 :         return false;
    1602                 :      107017 :       return true;
    1603                 :     4521045 :     case GE: case LT:
    1604                 :     4414028 :       if (inmode == CCmode || inmode == CCGCmode
    1605                 :     2234470 :           || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
    1606                 :     3894661 :         return true;
    1607                 :      107017 :       return false;
    1608                 :      107017 :     case GEU: case LTU:
    1609                 :     7288539 :       if (inmode == CCCmode || inmode == CCGZmode)
    1610                 :             :         return true;
    1611                 :             :       /* FALLTHRU */
    1612                 :    70421204 :     case GTU: case LEU:
    1613                 :     9992600 :       if (inmode == CCmode)
    1614                 :    69284999 :         return true;
    1615                 :             :       return false;
    1616                 :    50047246 :     case ORDERED: case UNORDERED:
    1617                 :        3424 :       if (inmode == CCmode)
    1618                 :        3167 :         return true;
    1619                 :             :       return false;
    1620                 :     5910093 :     case GT: case LE:
    1621                 :     5910093 :       if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
    1622                 :     5177846 :         return true;
    1623                 :    50043822 :       return false;
    1624                 :             :     default:
    1625                 :             :       return false;
    1626                 :             :     }
    1627                 :      726651 : })
    1628                 :             : 
    1629                 :      726651 : ;; Return true if OP is a valid comparison operator
    1630                 :   112782624 : ;; testing carry flag to be set.
    1631                 :      726651 : (define_predicate "ix86_carry_flag_operator"
    1632                 :   211343624 :   (match_code "ltu,unlt")
    1633                 :    98561000 : {
    1634                 :      832762 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1635                 :      832762 :   enum rtx_code code = GET_CODE (op);
    1636                 :             : 
    1637                 :      832762 :   if (inmode == CCFPmode)
    1638                 :      738452 :     code = ix86_fp_compare_code_to_integer (code);
    1639                 :      820961 :   else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
    1640                 :             :     return false;
    1641                 :             : 
    1642                 :      622041 :   return code == LTU;
    1643                 :             : })
    1644                 :     1292512 : 
    1645                 :             : ;; Return true if OP is a valid comparison operator
    1646                 :     5023607 : ;; testing carry flag to be unset.
    1647                 :     1292512 : (define_predicate "ix86_carry_flag_unset_operator"
    1648                 :     3731095 :   (match_code "geu,ge")
    1649                 :             : {
    1650                 :      833904 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1651                 :      833904 :   enum rtx_code code = GET_CODE (op);
    1652                 :     2125274 : 
    1653                 :     1292512 :   if (inmode == CCFPmode)
    1654                 :          66 :     code = ix86_fp_compare_code_to_integer (code);
    1655                 :        1076 :   else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
    1656                 :      832762 :     return false;
    1657                 :    99393762 : 
    1658                 :      427616 :   return code == GEU;
    1659                 :             : })
    1660                 :             : 
    1661                 :             : ;; Return true if this comparison only requires testing one flag bit.
    1662                 :     2666959 : ;; VCOMX/VUCOMX set ZF, SF, OF, differently from COMI/UCOMI.
    1663                 :             : (define_predicate "ix86_trivial_fp_comparison_operator"
    1664                 :    11902737 :   (if_then_else (match_test "TARGET_AVX10_2")
    1665                 :      655441 :                 (match_code "gt,ge,unlt,unle,eq,uneq,ne,ltgt,ordered,unordered")
    1666                 :        1142 :                 (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered")))
    1667                 :        1142 : 
    1668                 :        1142 : (define_predicate "ix86_trivial_fp_comparison_operator_xf"
    1669                 :     1357206 :   (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered"))
    1670                 :             : 
    1671                 :     1357206 : ;; Return true if we know how to do this comparison.  Others require
    1672                 :        1142 : ;; testing more than one flag bit, and we let the generic middle-end
    1673                 :      411515 : ;; code do that.
    1674                 :      411163 : (define_predicate "ix86_fp_comparison_operator"
    1675                 :     2854215 :   (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
    1676                 :     2443842 :                              == IX86_FPCMP_ARITH")
    1677                 :      410373 :                (match_operand 0 "comparison_operator")
    1678                 :     9647293 :                (match_operand 0 "ix86_trivial_fp_comparison_operator")))
    1679                 :      410373 : 
    1680                 :     9236920 : (define_predicate "ix86_fp_comparison_operator_xf"
    1681                 :     1767579 :   (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
    1682                 :     1357206 :                              == IX86_FPCMP_ARITH")
    1683                 :             :                (match_operand 0 "comparison_operator")
    1684                 :             :                (match_operand 0 "ix86_trivial_fp_comparison_operator_xf")))
    1685                 :      410373 : 
    1686                 :      410373 : ;; Return true if we can perform this comparison on TImode operands.
    1687                 :             : (define_predicate "ix86_timode_comparison_operator"
    1688                 :      355417 :   (if_then_else (match_test "TARGET_64BIT")
    1689                 :             :                 (match_operand 0 "ordered_comparison_operator")
    1690                 :     2443842 :                 (match_operand 0 "bt_comparison_operator")))
    1691                 :             : 
    1692                 :     2443842 : ;; Return true if this is a valid second operand for a TImode comparison.
    1693                 :             : (define_predicate "ix86_timode_comparison_operand"
    1694                 :      142856 :   (if_then_else (match_test "TARGET_64BIT")
    1695                 :             :                 (match_operand 0 "x86_64_general_operand")
    1696                 :             :                 (match_operand 0 "nonimmediate_operand")))
    1697                 :             : 
    1698                 :     2007426 : ;; Nearly general operand, but accept any const_double, since we wish
    1699                 :             : ;; to be able to drop them into memory rather than have them get pulled
    1700                 :      506753 : ;; into registers.
    1701                 :     2514179 : (define_predicate "cmp_fp_expander_operand"
    1702                 :             :   (ior (match_code "const_double")
    1703                 :             :        (match_operand 0 "general_operand")))
    1704                 :             : 
    1705                 :     4967616 : ;; Return true if this is a valid binary floating-point operation.
    1706                 :             : (define_predicate "binary_fp_operator"
    1707                 :     4967616 :   (match_code "plus,minus,mult,div"))
    1708                 :             : 
    1709                 :     4959704 : ;; Return true if this is a multiply operation.
    1710                 :     4959704 : (define_predicate "mult_operator"
    1711                 :     4959704 :   (match_code "mult"))
    1712                 :     4959704 : 
    1713                 :     4959704 : ;; Return true if this is a division operation.
    1714                 :             : (define_predicate "div_operator"
    1715                 :             :   (match_code "div"))
    1716                 :             : 
    1717                 :     4959704 : ;; Return true if this is a and, ior or xor operation.
    1718                 :     4959704 : (define_predicate "logic_operator"
    1719                 :             :   (match_code "and,ior,xor"))
    1720                 :             : 
    1721                 :             : ;; Return true if this is a plus, minus, and, ior or xor operation.
    1722                 :    17461422 : (define_predicate "plusminuslogic_operator"
    1723                 :             :   (match_code "plus,minus,and,ior,xor"))
    1724                 :    17461422 : 
    1725                 :     3652996 : ;; Return true for ARITHMETIC_P.
    1726                 :             : (define_predicate "arith_or_logical_operator"
    1727                 :             :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
    1728                 :             :                mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
    1729                 :     2625291 : 
    1730                 :             : ;; Return true for COMMUTATIVE_P.
    1731                 :     2625291 : (define_predicate "commutative_operator"
    1732                 :      932022 :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
    1733                 :             : 
    1734                 :             : ;; Return true if OP is a binary operator that can be promoted to wider mode.
    1735                 :             : (define_predicate "promotable_binary_operator"
    1736                 :           0 :   (ior (match_code "plus,minus,and,ior,xor,ashift")
    1737                 :             :        (and (match_code "mult")
    1738                 :    24940001 :             (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
    1739                 :           0 : 
    1740                 :           0 : (define_predicate "compare_operator"
    1741                 :           0 :   (match_code "compare"))
    1742                 :           0 : 
    1743                 :     7623633 : (define_predicate "extract_operator"
    1744                 :             :   (match_code "zero_extract,sign_extract"))
    1745                 :     7623633 : 
    1746                 :           0 : ;; Return true if OP is a memory operand, aligned to
    1747                 :           0 : ;; less than its natural alignment.
    1748                 :           0 : (define_predicate "misaligned_operand"
    1749                 :             :   (and (match_code "mem")
    1750                 :     6209547 :        (match_test "MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)")))
    1751                 :     1543999 : 
    1752                 :       55675 : ;; Return true if OP is a parallel for an mov{d,q,dqa,ps,pd} vec_select,
    1753                 :             : ;; where one of the two operands of the vec_concat is const0_operand.
    1754                 :      506769 : (define_predicate "movq_parallel"
    1755                 :     1291269 :   (match_code "parallel")
    1756                 :      558625 : {
    1757                 :     1738544 :   unsigned nelt = XVECLEN (op, 0);
    1758                 :     1738544 :   unsigned nelt2 = nelt >> 1;
    1759                 :     1738544 :   unsigned i;
    1760                 :      558625 : 
    1761                 :     1291269 :   if (nelt < 2)
    1762                 :             :     return false;
    1763                 :             : 
    1764                 :             :   /* Validate that all of the elements are constants,
    1765                 :     8887854 :      lower halves of permute are lower halves of the first operand,
    1766                 :      502950 :      upper halves of permute come from any of the second operand.  */
    1767                 :    15145954 :   for (i = 0; i < nelt; ++i)
    1768                 :             :     {
    1769                 :     1999567 :       rtx er = XVECEXP (op, 0, i);
    1770                 :     6236539 :       unsigned HOST_WIDE_INT ei;
    1771                 :             : 
    1772                 :     6236539 :       if (!CONST_INT_P (er))
    1773                 :             :         return false;
    1774                 :     6236539 :       ei = INTVAL (er);
    1775                 :     1999567 :       if (i < nelt2 && ei != i)
    1776                 :     4236972 :         return false;
    1777                 :      862221 :       if (i >= nelt2 && (ei < nelt || ei >= nelt << 1))
    1778                 :     4236972 :         return false;
    1779                 :     4236972 :     }
    1780                 :     4236972 : 
    1781                 :     4236972 :   return true;
    1782                 :     4236972 : })
    1783                 :     4236972 : 
    1784                 :     4236972 : ;; Return true if OP is a vzeroall operation, known to be a PARALLEL.
    1785                 :     5472566 : (define_predicate "vzeroall_operation"
    1786                 :     4236972 :   (match_code "parallel")
    1787                 :     6708160 : {
    1788                 :     1235613 :   unsigned i, nregs = TARGET_64BIT ? 16 : 8;
    1789                 :           0 : 
    1790                 :        5190 :   if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
    1791                 :     4236972 :     return false;
    1792                 :     4236972 : 
    1793                 :       93268 :   for (i = 0; i < nregs; i++)
    1794                 :     4236972 :     {
    1795                 :       82888 :       rtx elt = XVECEXP (op, 0, i+1);
    1796                 :             : 
    1797                 :       82888 :       if (GET_CODE (elt) != SET
    1798                 :       82888 :           || GET_CODE (SET_DEST (elt)) != REG
    1799                 :     4319860 :           || GET_MODE (SET_DEST (elt)) != V8SImode
    1800                 :       82888 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    1801                 :      165776 :           || SET_SRC (elt) != CONST0_RTX (V8SImode))
    1802                 :             :         return false;
    1803                 :      922901 :     }
    1804                 :             :   return true;
    1805                 :      922901 : })
    1806                 :             : 
    1807                 :      326579 : ;; return true if OP is a vzeroall pattern.
    1808                 :      331769 : (define_predicate "vzeroall_pattern"
    1809                 :      326579 :   (and (match_code "parallel")
    1810                 :      336959 :        (match_code "unspec_volatile" "a")
    1811                 :        5340 :        (match_test "XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROALL")))
    1812                 :           0 : 
    1813                 :      326579 : ;; return true if OP is a vzeroupper pattern.
    1814                 :      326579 : (define_predicate "vzeroupper_pattern"
    1815                 :      326579 :   (and (match_code "parallel")
    1816                 :   252270086 :        (match_code "unspec" "b")
    1817                 :      837885 :        (match_test "XINT (XVECEXP (op, 0, 1), 1) == UNSPEC_CALLEE_ABI")
    1818                 :   251943507 :        (match_test "INTVAL (XVECEXP (XVECEXP (op, 0, 1), 0, 0)) == ABI_VZEROUPPER")))
    1819                 :           0 : 
    1820                 :      326579 : ;; Return true if OP is an addsub vec_merge operation
    1821                 :      326579 : (define_predicate "addsub_vm_operator"
    1822                 :             :   (match_code "vec_merge")
    1823                 :        4400 : {
    1824                 :        4400 :   rtx op0, op1;
    1825                 :    24944401 :   int swapped;
    1826                 :        4400 :   HOST_WIDE_INT mask;
    1827                 :    24940001 :   int nunits, elt;
    1828                 :             : 
    1829                 :        4400 :   op0 = XEXP (op, 0);
    1830                 :        4400 :   op1 = XEXP (op, 1);
    1831                 :             : 
    1832                 :             :   /* Sanity check.  */
    1833                 :        4400 :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1834                 :             :     swapped = 0;
    1835                 :        2469 :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1836                 :             :     swapped = 1;
    1837                 :             :   else
    1838                 :           0 :     gcc_unreachable ();
    1839                 :             : 
    1840                 :        4400 :   mask = INTVAL (XEXP (op, 2));
    1841                 :        4400 :   nunits = GET_MODE_NUNITS (mode);
    1842                 :             : 
    1843                 :       17446 :   for (elt = 0; elt < nunits; elt++)
    1844                 :             :     {
    1845                 :             :       /* bit clear: take from op0, set: take from op1  */
    1846                 :       13257 :       int bit = !(mask & (HOST_WIDE_INT_1U << elt));
    1847                 :             : 
    1848                 :       13257 :       if (bit != ((elt & 1) ^ swapped))
    1849                 :             :         return false;
    1850                 :             :     }
    1851                 :             : 
    1852                 :             :   return true;
    1853                 :             : })
    1854                 :             : 
    1855                 :             : ;; Return true if OP is an addsub vec_select/vec_concat operation
    1856                 :        4400 : (define_predicate "addsub_vs_operator"
    1857                 :             :   (and (match_code "vec_select")
    1858                 :        4400 :        (match_code "vec_concat" "0"))
    1859                 :        8589 : {
    1860                 :        4189 :   rtx op0, op1;
    1861                 :           0 :   bool swapped;
    1862                 :           0 :   int nunits, elt;
    1863                 :             : 
    1864                 :           0 :   op0 = XEXP (XEXP (op, 0), 0);
    1865                 :           0 :   op1 = XEXP (XEXP (op, 0), 1);
    1866                 :             : 
    1867                 :             :   /* Sanity check.  */
    1868                 :           0 :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1869                 :             :     swapped = false;
    1870                 :           0 :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1871                 :             :     swapped = true;
    1872                 :             :   else
    1873                 :           0 :     gcc_unreachable ();
    1874                 :             : 
    1875                 :           0 :   nunits = GET_MODE_NUNITS (mode);
    1876                 :           0 :   if (XVECLEN (XEXP (op, 1), 0) != nunits)
    1877                 :             :     return false;
    1878                 :             : 
    1879                 :             :   /* We already checked that permutation is suitable for addsub,
    1880                 :             :      so only look at the first element of the parallel.  */
    1881                 :           0 :   elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
    1882                 :             : 
    1883                 :           0 :   return elt == (swapped ? nunits : 0);
    1884                 :             : })
    1885                 :             : 
    1886                 :             : ;; Return true if OP is a parallel for an addsub vec_select.
    1887                 :           0 : (define_predicate "addsub_vs_parallel"
    1888                 :             :   (and (match_code "parallel")
    1889                 :           0 :        (match_code "const_int" "a"))
    1890                 :           0 : {
    1891                 :           0 :   int nelt = XVECLEN (op, 0);
    1892                 :         532 :   int elt, i;
    1893                 :             :   
    1894                 :         532 :   if (nelt < 2)
    1895                 :         532 :     return false;
    1896                 :             : 
    1897                 :             :   /* Check that the permutation is suitable for addsub.
    1898                 :             :      For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }.  */
    1899                 :         532 :   elt = INTVAL (XVECEXP (op, 0, 0));
    1900                 :         532 :   if (elt == 0)
    1901                 :             :     {
    1902                 :         428 :       for (i = 1; i < nelt; ++i)
    1903                 :         428 :         if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
    1904                 :             :           return false;
    1905                 :             :     }
    1906                 :         104 :   else if (elt == nelt)
    1907                 :             :     {
    1908                 :           0 :       for (i = 1; i < nelt; ++i)
    1909                 :           0 :         if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
    1910                 :             :           return false;
    1911                 :             :     }
    1912                 :             :   else
    1913                 :             :     return false;
    1914                 :             : 
    1915                 :             :   return true;
    1916                 :             : })
    1917                 :             : 
    1918                 :             : ;; Return true if OP is a constant pool in perm{w,d,b} which constains index
    1919                 :         532 : ;; match pmov{dw,wb,qd}.
    1920                 :             : (define_predicate "permvar_truncate_operand"
    1921                 :         532 :  (match_code "mem")
    1922                 :        1064 : {
    1923                 :           0 :   int nelt = GET_MODE_NUNITS (mode);
    1924                 :          16 :   int perm[128];
    1925                 :          16 :   int id;
    1926                 :             : 
    1927                 :          32 :   if (!INTEGRAL_MODE_P (mode) || !VECTOR_MODE_P (mode))
    1928                 :             :     return false;
    1929                 :             : 
    1930                 :          16 :   if (nelt < 2)
    1931                 :             :     return false;
    1932                 :             : 
    1933                 :          16 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1934                 :             :     return false;
    1935                 :             : 
    1936                 :          16 :   id = exact_log2 (nelt);
    1937                 :             : 
    1938                 :             :   /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
    1939                 :             :      For example V16HImode to V8HImode
    1940                 :             :      { 0 2 4 6 8 10 12 14 * * * * * * * * }.  */
    1941                 :         232 :   for (int i = 0; i != nelt / 2; i++)
    1942                 :         216 :     if ((perm[i] & ((1 << id) - 1)) != i * 2)
    1943                 :             :       return false;
    1944                 :             : 
    1945                 :             :   return true;
    1946                 :             : })
    1947                 :             : 
    1948                 :             : ;; Return true if OP is a constant pool in shufb which constains index
    1949                 :          33 : ;; match pmovdw.
    1950                 :             : (define_predicate "pshufb_truncv4siv4hi_operand"
    1951                 :          16 :  (match_code "mem")
    1952                 :          49 : {
    1953                 :          16 :   int perm[128];
    1954                 :             : 
    1955                 :           8 :   if (mode != E_V16QImode)
    1956                 :             :     return false;
    1957                 :           8 : 
    1958                 :           8 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1959                 :             :     return false;
    1960                 :             : 
    1961                 :             :   /* Check that the permutation is suitable for pmovdw.
    1962                 :             :      For example V4SImode to V4HImode
    1963                 :             :      { 0 1 4 5 8 9 12 13 * * * * * * * * }.
    1964                 :             :      index = i % 2 + (i / 2) * 4.  */
    1965                 :          58 :   for (int i = 0; i != 8; i++)
    1966                 :             :     {
    1967                 :             :       /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0;  */
    1968                 :          52 :       if (perm[i] & 128)
    1969                 :             :         return false;
    1970                 :             : 
    1971                 :          52 :       if ((perm[i] & 15) != ((i & 1) + (i & 0xFE) * 2))
    1972                 :             :         return false;
    1973                 :             :      }
    1974                 :             : 
    1975                 :             :   return true;
    1976                 :             : })
    1977                 :             : 
    1978                 :             : ;; Return true if OP is a constant pool in shufb which constains index
    1979                 :          11 : ;; match pmovdw.
    1980                 :             : (define_predicate "pshufb_truncv8hiv8qi_operand"
    1981                 :           8 :  (match_code "mem")
    1982                 :          17 : {
    1983                 :           6 :   int perm[128];
    1984                 :             : 
    1985                 :          11 :   if (mode != E_V16QImode)
    1986                 :             :     return false;
    1987                 :          11 : 
    1988                 :          11 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1989                 :             :     return false;
    1990                 :             : 
    1991                 :             :   /* Check that the permutation is suitable for pmovwb.
    1992                 :             :      For example V16QImode to V8QImode
    1993                 :             :      { 0 2 4 6 8 10 12 14 * * * * * * * * }.
    1994                 :             :      index = i % 2 + (i / 2) * 4.  */
    1995                 :          57 :   for (int i = 0; i != 8; i++)
    1996                 :             :     {
    1997                 :             :       /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0;  */
    1998                 :          52 :       if (perm[i] & 128)
    1999                 :             :         return false;
    2000                 :             : 
    2001                 :          52 :       if ((perm[i] & 15) != i * 2)
    2002                 :             :          return false;
    2003                 :             :     }
    2004                 :             : 
    2005                 :             :   return true;
    2006                 :             : })
    2007                 :             : 
    2008                 :             : ;; Return true if OP is a parallel for an pmovz{bw,wd,dq} vec_select,
    2009                 :          14 : ;; where one of the two operands of the vec_concat is const0_operand.
    2010                 :             : (define_predicate "pmovzx_parallel"
    2011                 :          11 :   (and (match_code "parallel")
    2012                 :          19 :        (match_code "const_int" "a"))
    2013                 :           5 : {
    2014                 :     1302488 :   int nelt = XVECLEN (op, 0);
    2015                 :     1302488 :   int elt, i;
    2016                 :             : 
    2017                 :     1302488 :   if (nelt < 2)
    2018                 :             :     return false;
    2019                 :             : 
    2020                 :             :   /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
    2021                 :             :      For example { 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23 }.  */
    2022                 :     1302488 :   elt = INTVAL (XVECEXP (op, 0, 0));
    2023                 :     1302488 :   if (elt == 0)
    2024                 :             :     {
    2025                 :     2957810 :       for (i = 1; i < nelt; ++i)
    2026                 :     2542878 :         if ((i & 1) != 0)
    2027                 :             :           {
    2028                 :     1607807 :             if (INTVAL (XVECEXP (op, 0, i)) < nelt)
    2029                 :             :               return false;
    2030                 :             :           }
    2031                 :      935071 :         else if (INTVAL (XVECEXP (op, 0, i)) != i / 2)
    2032                 :             :           return false;
    2033                 :             :     }
    2034                 :             :   else
    2035                 :             :     return false;
    2036                 :             : 
    2037                 :             :   return true;
    2038                 :             : })
    2039                 :             : 
    2040                 :             : ;; Return true if OP is a const vector with duplicate value.
    2041                 :     1302488 : (define_predicate "const_vector_duplicate_operand"
    2042                 :             :   (match_code "const_vector")
    2043                 :     1302488 : {
    2044                 :     2604976 :   rtx elt = XVECEXP (op, 0, 0);
    2045                 :           0 :   int i, nelt = XVECLEN (op, 0);
    2046                 :             : 
    2047                 :          96 :   for (i = 1; i < nelt; ++i)
    2048                 :          93 :     if (!rtx_equal_p (elt, XVECEXP (op, 0, i)))
    2049                 :           3 :       return false;
    2050                 :             :   return true;
    2051                 :             : })
    2052                 :             : 
    2053                 :             : ;; Return true if OP is a parallel for a vbroadcast permute.
    2054                 :           3 : (define_predicate "avx_vbroadcast_operand"
    2055                 :             :   (and (match_code "parallel")
    2056                 :           3 :        (match_code "const_int" "a"))
    2057                 :           6 : {
    2058                 :           3 :   rtx elt = XVECEXP (op, 0, 0);
    2059                 :      387742 :   int i, nelt = XVECLEN (op, 0);
    2060                 :             : 
    2061                 :             :   /* Don't bother checking there are the right number of operands,
    2062                 :      387742 :      merely that they're all identical.  */
    2063                 :      469535 :   for (i = 1; i < nelt; ++i)
    2064                 :      243393 :     if (XVECEXP (op, 0, i) != elt)
    2065                 :             :       return false;
    2066                 :             :   return true;
    2067                 :             : })
    2068                 :             : 
    2069                 :             : ;; Return true if OP is a parallel for a palignr permute.
    2070                 :      387742 : (define_predicate "palignr_operand"
    2071                 :             :   (and (match_code "parallel")
    2072                 :      387742 :        (match_code "const_int" "a"))
    2073                 :      775484 : {
    2074                 :           0 :   int elt = INTVAL (XVECEXP (op, 0, 0));
    2075                 :       26908 :   int i, nelt = XVECLEN (op, 0);
    2076                 :             : 
    2077                 :             :   /* Check that an order in the permutation is suitable for palignr.
    2078                 :       26908 :      For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm".  */
    2079                 :       59735 :   for (i = 1; i < nelt; ++i)
    2080                 :       56321 :     if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
    2081                 :             :       return false;
    2082                 :             :   return true;
    2083                 :             : })
    2084                 :             : 
    2085                 :             : ;; Return true if OP is a proper third operand to vpblendw256.
    2086                 :       26908 : (define_predicate "avx2_pblendw_operand"
    2087                 :             :   (match_code "const_int")
    2088                 :       26908 : {
    2089                 :       53816 :   HOST_WIDE_INT val = INTVAL (op);
    2090                 :           0 :   HOST_WIDE_INT low = val & 0xff;
    2091                 :        6616 :   return val == ((low << 8) | low);
    2092                 :             : })
    2093                 :             : 
    2094                 :        6616 : ;; Return true if OP is vector_operand or CONST_VECTOR.
    2095                 :        6616 : (define_predicate "general_vector_operand"
    2096                 :             :   (ior (match_operand 0 "vector_operand")
    2097                 :        6616 :        (match_code "const_vector")))
    2098                 :        6616 : 
    2099                 :             : ;; Return true if OP is either -1 constant or stored in register.
    2100                 :             : (define_predicate "register_or_constm1_operand"
    2101                 :             :   (ior (match_operand 0 "register_operand")
    2102                 :       12188 :        (and (match_code "const_int")
    2103                 :           0 :             (match_test "op == constm1_rtx"))))
    2104                 :       12188 : 
    2105                 :        2308 : ;; Return true if the vector ends with between 12 and 18 register saves using
    2106                 :             : ;; RAX as the base address.
    2107                 :             : (define_predicate "save_multiple"
    2108                 :      212511 :   (match_code "parallel")
    2109                 :        1324 : {
    2110                 :      212511 :   const unsigned len = XVECLEN (op, 0);
    2111                 :        1324 :   unsigned i;
    2112                 :             : 
    2113                 :             :   /* Starting from end of vector, count register saves.  */
    2114                 :      305344 :   for (i = 0; i < len; ++i)
    2115                 :             :     {
    2116                 :      305344 :       rtx src, dest, addr;
    2117                 :      305344 :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2118                 :             : 
    2119                 :      305344 :       if (GET_CODE (e) != SET)
    2120                 :             :         break;
    2121                 :             : 
    2122                 :      298299 :       src  = SET_SRC (e);
    2123                 :      298299 :       dest = SET_DEST (e);
    2124                 :             : 
    2125                 :      298299 :       if (!REG_P (src) || !MEM_P (dest))
    2126                 :             :         break;
    2127                 :             : 
    2128                 :       92833 :       addr = XEXP (dest, 0);
    2129                 :             : 
    2130                 :             :       /* Good if dest address is in RAX.  */
    2131                 :       92833 :       if (REG_P (addr) && REGNO (addr) == AX_REG)
    2132                 :        4202 :         continue;
    2133                 :             : 
    2134                 :             :       /* Good if dest address is offset of RAX.  */
    2135                 :      177262 :       if (GET_CODE (addr) == PLUS
    2136                 :       88631 :           && REG_P (XEXP (addr, 0))
    2137                 :      177262 :           && REGNO (XEXP (addr, 0)) == AX_REG)
    2138                 :       88631 :         continue;
    2139                 :             : 
    2140                 :             :       break;
    2141                 :             :     }
    2142                 :      212511 :   return (i >= 12 && i <= 18);
    2143                 :             : })
    2144                 :             : 
    2145                 :             : 
    2146                 :      212511 : ;; Return true if the vector ends with between 12 and 18 register loads using
    2147                 :             : ;; RSI as the base address.
    2148                 :      425022 : (define_predicate "restore_multiple"
    2149                 :      212511 :   (match_code "parallel")
    2150                 :           0 : {
    2151                 :     6856782 :   const unsigned len = XVECLEN (op, 0);
    2152                 :     6856782 :   unsigned i;
    2153                 :             : 
    2154                 :     6856782 :   /* Starting from end of vector, count register restores.  */
    2155                 :     6963360 :   for (i = 0; i < len; ++i)
    2156                 :             :     {
    2157                 :     6963360 :       rtx src, dest, addr;
    2158                 :     6963360 :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2159                 :             : 
    2160                 :     6963360 :       if (GET_CODE (e) != SET)
    2161                 :             :         break;
    2162                 :             : 
    2163                 :     3924105 :       src  = SET_SRC (e);
    2164                 :     3924105 :       dest = SET_DEST (e);
    2165                 :             : 
    2166                 :     3924105 :       if (!MEM_P (src) || !REG_P (dest))
    2167                 :             :         break;
    2168                 :             : 
    2169                 :     1169501 :       addr = XEXP (src, 0);
    2170                 :             : 
    2171                 :             :       /* Good if src address is in RSI.  */
    2172                 :     1169501 :       if (REG_P (addr) && REGNO (addr) == SI_REG)
    2173                 :        5137 :         continue;
    2174                 :             : 
    2175                 :             :       /* Good if src address is offset of RSI.  */
    2176                 :     1265805 :       if (GET_CODE (addr) == PLUS
    2177                 :      792125 :           && REG_P (XEXP (addr, 0))
    2178                 :     1880632 :           && REGNO (XEXP (addr, 0)) == SI_REG)
    2179                 :      101441 :         continue;
    2180                 :             : 
    2181                 :             :       break;
    2182                 :             :     }
    2183                 :     6856782 :   return (i >= 12 && i <= 18);
    2184                 :             : })
    2185                 :             : 
    2186                 :             : ;; Keylocker specific predicates
    2187                 :     6856782 : (define_predicate "encodekey128_operation"
    2188                 :             :   (match_code "parallel")
    2189                 :    13713564 : {
    2190                 :     6856782 :   unsigned i;
    2191                 :           0 :   rtx elt;
    2192                 :             : 
    2193                 :         107 :   if (XVECLEN (op, 0) != 8)
    2194                 :             :     return false;
    2195                 :         107 : 
    2196                 :         388 :   for(i = 0; i < 3; i++)
    2197                 :             :     {
    2198                 :         291 :       elt = XVECEXP (op, 0, i + 1);
    2199                 :         291 :       if (GET_CODE (elt) != SET
    2200                 :         291 :           || GET_CODE (SET_DEST (elt)) != REG
    2201                 :         291 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2202                 :         291 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2203                 :         291 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2204                 :         291 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2205                 :         291 :           || XVECLEN(SET_SRC (elt), 0) != 1
    2206                 :         582 :           || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
    2207                 :             :         return false;
    2208                 :             :     }
    2209                 :             : 
    2210                 :         388 :   for(i = 4; i < 7; i++)
    2211                 :             :     {
    2212                 :         291 :       elt = XVECEXP (op, 0, i);
    2213                 :         291 :       if (GET_CODE (elt) != CLOBBER
    2214                 :         291 :           || GET_MODE (elt) != VOIDmode
    2215                 :         291 :           || GET_CODE (XEXP (elt, 0)) != REG
    2216                 :         291 :           || GET_MODE (XEXP (elt, 0)) != V2DImode
    2217                 :         582 :           || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
    2218                 :             :         return false;
    2219                 :             :     }
    2220                 :             : 
    2221                 :          97 :   elt = XVECEXP (op, 0, 7);
    2222                 :          97 :   if (GET_CODE (elt) != CLOBBER
    2223                 :          97 :       || GET_MODE (elt) != VOIDmode
    2224                 :          97 :       || GET_CODE (XEXP (elt, 0)) != REG
    2225                 :          97 :       || GET_MODE (XEXP (elt, 0)) != CCmode
    2226                 :         194 :       || REGNO (XEXP (elt, 0)) != FLAGS_REG)
    2227                 :             :     return false;
    2228                 :             :   return true;
    2229                 :             : })
    2230                 :             : 
    2231                 :             : (define_predicate "encodekey256_operation"
    2232                 :         107 :   (match_code "parallel")
    2233                 :             : {
    2234                 :         334 :   unsigned i;
    2235                 :         107 :   rtx elt;
    2236                 :           0 : 
    2237                 :         120 :   if (XVECLEN (op, 0) != 9)
    2238                 :             :     return false;
    2239                 :             : 
    2240                 :         120 :   elt = SET_SRC (XVECEXP (op, 0, 0));
    2241                 :         111 :   elt = XVECEXP (elt, 0, 2);
    2242                 :         111 :   if (!REG_P (elt)
    2243                 :         111 :       || REGNO(elt) != GET_SSE_REGNO (1))
    2244                 :             :     return false;
    2245                 :             : 
    2246                 :         555 :   for(i = 0; i < 4; i++)
    2247                 :             :     {
    2248                 :         444 :       elt = XVECEXP (op, 0, i + 1);
    2249                 :         444 :       if (GET_CODE (elt) != SET
    2250                 :         444 :           || GET_CODE (SET_DEST (elt)) != REG
    2251                 :         444 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2252                 :         444 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2253                 :         444 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2254                 :         444 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2255                 :         444 :           || XVECLEN(SET_SRC (elt), 0) != 1
    2256                 :         888 :           || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
    2257                 :             :         return false;
    2258                 :             :     }
    2259                 :             : 
    2260                 :         444 :   for(i = 4; i < 7; i++)
    2261                 :             :     {
    2262                 :         333 :       elt = XVECEXP (op, 0, i + 1);
    2263                 :         333 :       if (GET_CODE (elt) != CLOBBER
    2264                 :         333 :           || GET_MODE (elt) != VOIDmode
    2265                 :         333 :           || GET_CODE (XEXP (elt, 0)) != REG
    2266                 :         333 :           || GET_MODE (XEXP (elt, 0)) != V2DImode
    2267                 :         666 :           || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
    2268                 :             :         return false;
    2269                 :             :     }
    2270                 :             : 
    2271                 :         111 :   elt = XVECEXP (op, 0, 8);
    2272                 :         111 :   if (GET_CODE (elt) != CLOBBER
    2273                 :         111 :       || GET_MODE (elt) != VOIDmode
    2274                 :         111 :       || GET_CODE (XEXP (elt, 0)) != REG
    2275                 :         111 :       || GET_MODE (XEXP (elt, 0)) != CCmode
    2276                 :         222 :       || REGNO (XEXP (elt, 0)) != FLAGS_REG)
    2277                 :             :     return false;
    2278                 :             :   return true;
    2279                 :             : })
    2280                 :             : 
    2281                 :             : 
    2282                 :         120 : (define_predicate "aeswidekl_operation"
    2283                 :             :   (match_code "parallel")
    2284                 :         240 : {
    2285                 :         120 :   unsigned i;
    2286                 :           0 :   rtx elt;
    2287                 :             : 
    2288                 :        5796 :   for (i = 0; i < 8; i++)
    2289                 :             :     {
    2290                 :         660 :       elt = XVECEXP (op, 0, i + 1);
    2291                 :        5168 :       if (GET_CODE (elt) != SET
    2292                 :        5168 :           || GET_CODE (SET_DEST (elt)) != REG
    2293                 :        5168 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2294                 :        5168 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2295                 :        5168 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2296                 :        5168 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2297                 :        5168 :           || XVECLEN (SET_SRC (elt), 0) != 1
    2298                 :        5168 :           || !REG_P (XVECEXP (SET_SRC (elt), 0, 0))
    2299                 :       10304 :           || REGNO (XVECEXP (SET_SRC (elt), 0, 0)) != GET_SSE_REGNO (i))
    2300                 :             :         return false;
    2301                 :             :     }
    2302                 :             :   return true;
    2303                 :             : })
    2304                 :             : 
    2305                 :             : ;; Return true if OP is a memory operand that can be also used in APX
    2306                 :         660 : ;; EVEX-encoded patterns (i.e. APX NDD/NF) with immediate operand.  With
    2307                 :             : ;; non-default address space, segment register or address size prefix,
    2308                 :        1320 : ;; APX EVEX-encoded instruction length can exceed the 15 byte size limit.
    2309                 :         660 : (define_predicate "apx_evex_memory_operand"
    2310                 :           0 :   (match_operand 0 "memory_operand")
    2311                 :             : {
    2312                 :             :   /* OK if immediate operand size < 4 bytes.  */
    2313                 :        1689 :   if (GET_MODE_SIZE (mode) < 4)
    2314                 :        1689 :     return true;
    2315                 :             : 
    2316                 :        1530 :   bool default_addr = ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (op));
    2317                 :        1698 :   bool address_size_prefix = TARGET_X32 && Pmode == SImode;
    2318                 :             : 
    2319                 :        1530 :   struct ix86_address parts;
    2320                 :        1530 :   int ok;
    2321                 :             : 
    2322                 :        1530 :   op = XEXP (op, 0);
    2323                 :        1530 :   ok = ix86_decompose_address (op, &parts);
    2324                 :        1530 :   gcc_assert (ok);
    2325                 :             : 
    2326                 :        1530 :   if (default_addr)
    2327                 :             :     {
    2328                 :             :       /* Default address space.  */
    2329                 :             : 
    2330                 :             :       /* Not OK with address size prefix, index register and disp.  */
    2331                 :         694 :       if (address_size_prefix
    2332                 :         168 :           && parts.index
    2333                 :          42 :           && parts.disp
    2334                 :          42 :           && parts.disp != const0_rtx)
    2335                 :             :         return false;
    2336                 :             :     }
    2337                 :             :   else
    2338                 :             :     {
    2339                 :             :       /* Non-default address space.  */
    2340                 :             : 
    2341                 :             :       /* Not OK without base register.  */
    2342                 :         836 :       if (!parts.base)
    2343                 :             :         return false;
    2344                 :             : 
    2345                 :             :       /* Not OK with disp and address size prefix.  */
    2346                 :         668 :       if (address_size_prefix && parts.disp)
    2347                 :             :         return false;
    2348                 :             :     }
    2349                 :             : 
    2350                 :             :   return true;
    2351                 :             : })
    2352                 :             : 
    2353                 :             : ;; Return true if OP is a memory operand which can be used in APX EVEX-encoded
    2354                 :        1900 : ;; ADD patterns (i.e. APX NDD/NF) for with register source operand.
    2355                 :             : ;; UNSPEC_GOTNTPOFF memory operand is allowed with APX EVEX-encoded ADD only if
    2356                 :        3589 : ;; R_X86_64_CODE_6_GOTTPOFF works.
    2357                 :        1689 : (define_predicate "apx_evex_add_memory_operand"
    2358                 :             :   (match_operand 0 "memory_operand")
    2359                 :             : {
    2360                 :             :   /* OK if "add %reg1, name@gottpoff(%rip), %reg2" or
    2361                 :             :    "{nf} add name@gottpoff(%rip), %reg1" are supported.  */
    2362                 :             :   if (HAVE_AS_R_X86_64_CODE_6_GOTTPOFF)
    2363                 :             :     return true;
    2364                 :             : 
    2365                 :             :   op = XEXP (op, 0);
    2366                 :             : 
    2367                 :             :   /* Disallow APX EVEX-encoded ADD with UNSPEC_GOTNTPOFF.  */
    2368                 :             :   if (GET_CODE (op) == CONST
    2369                 :             :       && GET_CODE (XEXP (op, 0)) == UNSPEC
    2370                 :             :       && XINT (XEXP (op, 0), 1) == UNSPEC_GOTNTPOFF)
    2371                 :             :     return false;
    2372                 :             : 
    2373                 :             :   return true;
    2374                 :             : })
    2375                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2376                 :             : /* (content generated from line coverage data) */
    2377                 :        1021 : /* ... */
    2378                 :             : /* ... */
    2379                 :        1021 : /* ... */
    2380                 :        1021 : /* ... */
    2381                 :             : /* ... */
    2382                 :             : /* ... */
    2383                 :             : /* ... */
    2384                 :   984080316 : /* ... */
    2385                 :             : /* ... */
    2386                 :   984080316 : /* ... */
    2387                 :             : /* ... */
    2388                 :             : /* ... */
    2389                 :             : /* ... */
    2390                 :           0 : /* ... */
    2391                 :           0 : /* ... */
    2392                 :           0 : /* ... */
    2393                 :           0 : /* ... */
    2394                 :           0 : /* ... */
    2395                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2396                 :   580375434 : /* (content generated from line coverage data) */
    2397                 :   580375434 : /* ... */
    2398                 :             : /* ... */
    2399                 :             : /* ... */
    2400                 :     7360218 : /* ... */
    2401                 :             : /* ... */
    2402                 :   133791192 : /* ... */
    2403                 :             : /* ... */
    2404                 :      133520 : /* ... */
    2405                 :             : /* ... */
    2406                 :     1620121 : /* ... */
    2407                 :             : /* ... */
    2408                 :     1361029 : /* ... */
    2409                 :             : /* ... */
    2410                 :    54922277 : /* ... */
    2411                 :             : /* ... */
    2412                 :    50069281 : /* ... */
    2413                 :             : /* ... */
    2414                 :   100794721 : /* ... */
    2415                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2416                 :    38952613 : /* (content generated from line coverage data) */
    2417                 :             : /* ... */
    2418                 :   118617793 : /* ... */
    2419                 :             : /* ... */
    2420                 :    72751863 : /* ... */
    2421                 :             : /* ... */
    2422                 :         806 : /* ... */
    2423                 :             : /* ... */
    2424                 :           0 : /* ... */
    2425                 :           0 : /* ... */
    2426                 :           0 : /* ... */
    2427                 :           0 : /* ... */
    2428                 :           0 : /* ... */
    2429                 :           0 : /* ... */
    2430                 :           0 : /* ... */
    2431                 :           0 : /* ... */
    2432                 :           0 : /* ... */
    2433                 :           0 : /* ... */
    2434                 :           0 : /* ... */
    2435                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2436                 :           0 : /* (content generated from line coverage data) */
    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                 :           0 : /* ... */
    2454                 :    38997713 : /* ... */
    2455                 :    38997713 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2456                 :             : /* (content generated from line coverage data) */
    2457                 :       22646 : /* ... */
    2458                 :             : /* ... */
    2459                 :             : /* ... */
    2460                 :           0 : /* ... */
    2461                 :           0 : /* ... */
    2462                 :           0 : /* ... */
    2463                 :           0 : /* ... */
    2464                 :     3281217 : /* ... */
    2465                 :     3281217 : /* ... */
    2466                 :             : /* ... */
    2467                 :             : /* ... */
    2468                 :        4856 : /* ... */
    2469                 :             : /* ... */
    2470                 :      342071 : /* ... */
    2471                 :             : /* ... */
    2472                 :     2590166 : /* ... */
    2473                 :             : /* ... */
    2474                 :      269462 : /* ... */
    2475                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2476                 :        1418 : /* (content generated from line coverage data) */
    2477                 :             : /* ... */
    2478                 :         236 : /* ... */
    2479                 :             : /* ... */
    2480                 :        4701 : /* ... */
    2481                 :             : /* ... */
    2482                 :           0 : /* ... */
    2483                 :           0 : /* ... */
    2484                 :   353307701 : /* ... */
    2485                 :   353307701 : /* ... */
    2486                 :             : /* ... */
    2487                 :             : /* ... */
    2488                 :     9482869 : /* ... */
    2489                 :             : /* ... */
    2490                 :     1367732 : /* ... */
    2491                 :             : /* ... */
    2492                 :     1544731 : /* ... */
    2493                 :             : /* ... */
    2494                 :       19198 : /* ... */
    2495                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2496                 :   195622526 : /* (content generated from line coverage data) */
    2497                 :             : /* ... */
    2498                 :      803412 : /* ... */
    2499                 :             : /* ... */
    2500                 :   139851631 : /* ... */
    2501                 :             : /* ... */
    2502                 :     3132854 : /* ... */
    2503                 :             : /* ... */
    2504                 :      385045 : /* ... */
    2505                 :             : /* ... */
    2506                 :     1073440 : /* ... */
    2507                 :             : /* ... */
    2508                 :           0 : /* ... */
    2509                 :           0 : /* ... */
    2510                 :           0 : /* ... */
    2511                 :           0 : /* ... */
    2512                 :           0 : /* ... */
    2513                 :           0 : /* ... */
    2514                 :           0 : /* ... */
    2515                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2516                 :           0 : /* (content generated from line coverage data) */
    2517                 :           0 : /* ... */
    2518                 :           0 : /* ... */
    2519                 :           0 : /* ... */
    2520                 :           0 : /* ... */
    2521                 :           0 : /* ... */
    2522                 :           0 : /* ... */
    2523                 :           0 : /* ... */
    2524                 :     8118251 : /* ... */
    2525                 :     8118251 : /* ... */
    2526                 :             : /* ... */
    2527                 :             : /* ... */
    2528                 :      987125 : /* ... */
    2529                 :             : /* ... */
    2530                 :           0 : /* ... */
    2531                 :             : /* ... */
    2532                 :           0 : /* ... */
    2533                 :             : /* ... */
    2534                 :           0 : /* ... */
    2535                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2536                 :           0 : /* (content generated from line coverage data) */
    2537                 :             : /* ... */
    2538                 :           0 : /* ... */
    2539                 :             : /* ... */
    2540                 :      142656 : /* ... */
    2541                 :             : /* ... */
    2542                 :        8523 : /* ... */
    2543                 :             : /* ... */
    2544                 :     6078024 : /* ... */
    2545                 :             : /* ... */
    2546                 :      150487 : /* ... */
    2547                 :             : /* ... */
    2548                 :      260626 : /* ... */
    2549                 :             : /* ... */
    2550                 :        3651 : /* ... */
    2551                 :             : /* ... */
    2552                 :           0 : /* ... */
    2553                 :             : /* ... */
    2554                 :           0 : /* ... */
    2555                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2556                 :           0 : /* (content generated from line coverage data) */
    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 : /* ... */
    2575                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2576                 :           0 : /* (content generated from line coverage data) */
    2577                 :           0 : /* ... */
    2578                 :           0 : /* ... */
    2579                 :           0 : /* ... */
    2580                 :           0 : /* ... */
    2581                 :           0 : /* ... */
    2582                 :             : /* ... */
    2583                 :             : /* ... */
    2584                 :        1337 : /* ... */
    2585                 :             : /* ... */
    2586                 :             : /* ... */
    2587                 :             : /* ... */
    2588                 :             : /* ... */
    2589                 :             : /* ... */
    2590                 :             : /* ... */
    2591                 :             : /* ... */
    2592                 :             : /* ... */
    2593                 :             : /* ... */
    2594                 :             : /* ... */
    2595                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2596                 :             : /* (content generated from line coverage data) */
    2597                 :             : /* ... */
    2598                 :             : /* ... */
    2599                 :             : /* ... */
    2600                 :             : /* ... */
    2601                 :             : /* ... */
    2602                 :             : /* ... */
    2603                 :             : /* ... */
    2604                 :             : /* ... */
    2605                 :             : /* ... */
    2606                 :             : /* ... */
    2607                 :             : /* ... */
    2608                 :             : /* ... */
    2609                 :             : /* ... */
    2610                 :             : /* ... */
    2611                 :             : /* ... */
    2612                 :             : /* ... */
    2613                 :             : /* ... */
    2614                 :             : /* ... */
    2615                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2616                 :             : /* (content generated from line coverage data) */
    2617                 :             : /* ... */
    2618                 :             : /* ... */
    2619                 :             : /* ... */
    2620                 :             : /* ... */
    2621                 :             : /* ... */
    2622                 :             : /* ... */
    2623                 :             : /* ... */
    2624                 :             : /* ... */
    2625                 :             : /* ... */
    2626                 :             : /* ... */
    2627                 :             : /* ... */
    2628                 :             : /* ... */
    2629                 :             : /* ... */
    2630                 :             : /* ... */
    2631                 :             : /* ... */
    2632                 :             : /* ... */
    2633                 :             : /* ... */
    2634                 :             : /* ... */
    2635                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2636                 :             : /* (content generated from line coverage data) */
    2637                 :             : /* ... */
    2638                 :             : /* ... */
    2639                 :             : /* ... */
    2640                 :             : /* ... */
    2641                 :             : /* ... */
    2642                 :             : /* ... */
    2643                 :             : /* ... */
    2644                 :             : /* ... */
    2645                 :             : /* ... */
    2646                 :             : /* ... */
    2647                 :             : /* ... */
    2648                 :             : /* ... */
    2649                 :             : /* ... */
    2650                 :             : /* ... */
    2651                 :             : /* ... */
    2652                 :             : /* ... */
    2653                 :             : /* ... */
    2654                 :             : /* ... */
    2655                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2656                 :             : /* (content generated from line coverage data) */
    2657                 :             : /* ... */
    2658                 :             : /* ... */
    2659                 :             : /* ... */
    2660                 :             : /* ... */
    2661                 :             : /* ... */
    2662                 :             : /* ... */
    2663                 :             : /* ... */
    2664                 :             : /* ... */
    2665                 :             : /* ... */
    2666                 :             : /* ... */
    2667                 :             : /* ... */
    2668                 :             : /* ... */
    2669                 :             : /* ... */
    2670                 :             : /* ... */
    2671                 :             : /* ... */
    2672                 :             : /* ... */
    2673                 :             : /* ... */
    2674                 :             : /* ... */
    2675                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2676                 :             : /* (content generated from line coverage data) */
    2677                 :             : /* ... */
    2678                 :             : /* ... */
    2679                 :             : /* ... */
    2680                 :             : /* ... */
    2681                 :             : /* ... */
    2682                 :             : /* ... */
    2683                 :             : /* ... */
    2684                 :             : /* ... */
    2685                 :             : /* ... */
    2686                 :             : /* ... */
    2687                 :             : /* ... */
    2688                 :             : /* ... */
    2689                 :             : /* ... */
    2690                 :             : /* ... */
    2691                 :             : /* ... */
    2692                 :             : /* ... */
    2693                 :             : /* ... */
    2694                 :             : /* ... */
    2695                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2696                 :             : /* (content generated from line coverage data) */
    2697                 :             : /* ... */
    2698                 :             : /* ... */
    2699                 :             : /* ... */
    2700                 :             : /* ... */
    2701                 :             : /* ... */
    2702                 :             : /* ... */
    2703                 :             : /* ... */
    2704                 :             : /* ... */
    2705                 :             : /* ... */
    2706                 :             : /* ... */
    2707                 :             : /* ... */
    2708                 :             : /* ... */
    2709                 :             : /* ... */
    2710                 :             : /* ... */
    2711                 :             : /* ... */
    2712                 :             : /* ... */
    2713                 :             : /* ... */
    2714                 :             : /* ... */
    2715                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2716                 :             : /* (content generated from line coverage data) */
    2717                 :             : /* ... */
    2718                 :             : /* ... */
    2719                 :             : /* ... */
    2720                 :             : /* ... */
    2721                 :             : /* ... */
    2722                 :             : /* ... */
    2723                 :             : /* ... */
    2724                 :             : /* ... */
    2725                 :             : /* ... */
    2726                 :             : /* ... */
    2727                 :             : /* ... */
    2728                 :             : /* ... */
    2729                 :             : /* ... */
    2730                 :             : /* ... */
    2731                 :             : /* ... */
    2732                 :             : /* ... */
    2733                 :             : /* ... */
    2734                 :             : /* ... */
    2735                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2736                 :             : /* (content generated from line coverage data) */
    2737                 :             : /* ... */
    2738                 :             : /* ... */
    2739                 :             : /* ... */
    2740                 :             : /* ... */
    2741                 :             : /* ... */
    2742                 :             : /* ... */
    2743                 :             : /* ... */
    2744                 :             : /* ... */
    2745                 :             : /* ... */
    2746                 :             : /* ... */
    2747                 :             : /* ... */
    2748                 :             : /* ... */
    2749                 :             : /* ... */
    2750                 :             : /* ... */
    2751                 :             : /* ... */
    2752                 :             : /* ... */
    2753                 :             : /* ... */
    2754                 :             : /* ... */
    2755                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2756                 :             : /* (content generated from line coverage data) */
    2757                 :             : /* ... */
    2758                 :             : /* ... */
    2759                 :             : /* ... */
    2760                 :             : /* ... */
    2761                 :             : /* ... */
    2762                 :             : /* ... */
    2763                 :             : /* ... */
    2764                 :             : /* ... */
    2765                 :             : /* ... */
    2766                 :             : /* ... */
    2767                 :             : /* ... */
    2768                 :             : /* ... */
    2769                 :             : /* ... */
    2770                 :             : /* ... */
    2771                 :             : /* ... */
    2772                 :             : /* ... */
    2773                 :             : /* ... */
    2774                 :             : /* ... */
    2775                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2776                 :             : /* (content generated from line coverage data) */
    2777                 :             : /* ... */
    2778                 :             : /* ... */
    2779                 :             : /* ... */
    2780                 :             : /* ... */
    2781                 :             : /* ... */
    2782                 :             : /* ... */
    2783                 :             : /* ... */
    2784                 :             : /* ... */
    2785                 :             : /* ... */
    2786                 :             : /* ... */
    2787                 :             : /* ... */
    2788                 :             : /* ... */
    2789                 :             : /* ... */
    2790                 :             : /* ... */
    2791                 :             : /* ... */
    2792                 :             : /* ... */
    2793                 :             : /* ... */
    2794                 :             : /* ... */
    2795                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2796                 :             : /* (content generated from line coverage data) */
    2797                 :             : /* ... */
    2798                 :             : /* ... */
    2799                 :             : /* ... */
    2800                 :             : /* ... */
    2801                 :             : /* ... */
    2802                 :             : /* ... */
    2803                 :             : /* ... */
    2804                 :             : /* ... */
    2805                 :             : /* ... */
    2806                 :             : /* ... */
    2807                 :             : /* ... */
    2808                 :             : /* ... */
    2809                 :             : /* ... */
    2810                 :             : /* ... */
    2811                 :             : /* ... */
    2812                 :             : /* ... */
    2813                 :             : /* ... */
    2814                 :             : /* ... */
    2815                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2816                 :             : /* (content generated from line coverage data) */
    2817                 :             : /* ... */
    2818                 :             : /* ... */
    2819                 :             : /* ... */
    2820                 :             : /* ... */
    2821                 :             : /* ... */
    2822                 :             : /* ... */
    2823                 :             : /* ... */
    2824                 :             : /* ... */
    2825                 :             : /* ... */
    2826                 :             : /* ... */
    2827                 :             : /* ... */
    2828                 :             : /* ... */
    2829                 :             : /* ... */
    2830                 :             : /* ... */
    2831                 :             : /* ... */
    2832                 :             : /* ... */
    2833                 :             : /* ... */
    2834                 :             : /* ... */
    2835                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2836                 :             : /* (content generated from line coverage data) */
    2837                 :             : /* ... */
    2838                 :             : /* ... */
    2839                 :             : /* ... */
    2840                 :             : /* ... */
    2841                 :             : /* ... */
    2842                 :             : /* ... */
    2843                 :             : /* ... */
    2844                 :             : /* ... */
    2845                 :             : /* ... */
    2846                 :             : /* ... */
    2847                 :  7192866965 : /* ... */
    2848                 :             : /* ... */
    2849                 :  7192866965 : /* ... */
    2850                 :             : /* ... */
    2851                 :             : /* ... */
    2852                 :             : /* ... */
    2853                 :   139162076 : /* ... */
    2854                 :             : /* ... */
    2855                 :    52657962 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2856                 :    21434207 : /* (content generated from line coverage data) */
    2857                 :             : /* ... */
    2858                 :    23286969 : /* ... */
    2859                 :     8959877 : /* ... */
    2860                 :      683852 : /* ... */
    2861                 :      829875 : /* ... */
    2862                 :      699251 : /* ... */
    2863                 :     1383184 : /* ... */
    2864                 :   216599105 : /* ... */
    2865                 :       81944 : /* ... */
    2866                 :        8657 : /* ... */
    2867                 :      851654 : /* ... */
    2868                 :    42988058 : /* ... */
    2869                 :   652633054 : /* ... */
    2870                 :   235936184 : /* ... */
    2871                 :  1481605887 : /* ... */
    2872                 :       13711 : /* ... */
    2873                 :     9482869 : /* ... */
    2874                 :     1367732 : /* ... */
    2875                 :           0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2876                 :     1544731 : /* (content generated from line coverage data) */
    2877                 :       14474 : /* ... */
    2878                 :   185087168 : /* ... */
    2879                 :      127611 : /* ... */
    2880                 :   139698403 : /* ... */
    2881                 :     2844058 : /* ... */
    2882                 :      342183 : /* ... */
    2883                 :             : /* ... */
    2884                 :       80515 : /* ... */
    2885                 :     6078024 : /* ... */
    2886                 :             : /* ... */
    2887                 :             : /* ... */
    2888                 :             : /* ... */
    2889                 :             : /* ... */
    2890                 :             : /* ... */
    2891                 :             : /* ... */
    2892                 :             : /* ... */
    2893                 :             : /* ... */
    2894                 :             : /* ... */
    2895                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2896                 :             : /* (content generated from line coverage data) */
    2897                 :             : /* ... */
    2898                 :             : /* ... */
    2899                 :             : /* ... */
    2900                 :             : /* ... */
    2901                 :             : /* ... */
    2902                 :             : /* ... */
    2903                 :             : /* ... */
    2904                 :             : /* ... */
    2905                 :             : /* ... */
    2906                 :             : /* ... */
    2907                 :             : /* ... */
    2908                 :             : /* ... */
    2909                 :             : /* ... */
    2910                 :             : /* ... */
    2911                 :             : /* ... */
    2912                 :             : /* ... */
    2913                 :             : /* ... */
    2914                 :             : /* ... */
    2915                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2916                 :             : /* (content generated from line coverage data) */
    2917                 :             : /* ... */
    2918                 :             : /* ... */
    2919                 :             : /* ... */
    2920                 :             : /* ... */
    2921                 :             : /* ... */
    2922                 :             : /* ... */
    2923                 :             : /* ... */
    2924                 :             : /* ... */
    2925                 :             : /* ... */
    2926                 :             : /* ... */
    2927                 :             : /* ... */
    2928                 :             : /* ... */
    2929                 :             : /* ... */
    2930                 :             : /* ... */
    2931                 :             : /* ... */
    2932                 :             : /* ... */
    2933                 :             : /* ... */
    2934                 :             : /* ... */
    2935                 :             : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2936                 :             : /* (content generated from line coverage data) */
    2937                 :             : /* ... */
    2938                 :             : /* ... */
    2939                 :             : /* ... */
    2940                 :             : /* ... */
    2941                 :             : /* ... */
    2942                 :             : /* ... */
    2943                 :             : /* ... */
    2944                 :             : /* ... */
    2945                 :             : /* ... */
    2946                 :             : /* ... */
    2947                 :             : /* ... */
    2948                 :             : /* ... */
    2949                 :             : /* ... */
    2950                 :             : /* ... */
    2951                 :             : /* ... */
    2952                 :             : /* ... */
    2953                 :     7006893 : /* ... */
    2954                 :             : /* ... */
    2955                 :     7006893 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2956                 :             : /* (content generated from line coverage data) */
    2957                 :     1394805 : /* ... */
    2958                 :     1394805 : /* ... */
        

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.