LCOV - code coverage report
Current view: top level - gcc/config/i386 - predicates.md (source / functions) Coverage Total Hit
Test: gcc.info Lines: 87.5 % 1460 1278
Test Date: 2026-11-14 16:39:50 Functions: 98.8 % 245 242
Legend: Lines:     hit not hit

            Line data    Source code
       1              : ;; Predicate definitions for IA-32 and x86-64.
       2              : ;; Copyright (C) 2004-2026 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    134130112 :        (match_test "ANY_FP_REGNO_P (REGNO (op))")))
      24        40554 : 
      25              : ;; Return true if OP is an i387 fp register.
      26              : (define_predicate "fp_register_operand"
      27              :   (and (match_code "reg")
      28      1546298 :        (match_test "STACK_REGNO_P (REGNO (op))")))
      29      1457623 : 
      30    441467120 : ;; True if the operand is a GENERAL class register.
      31              : (define_predicate "general_reg_operand"
      32              :   (and (match_code "reg")
      33    275472468 :        (match_test "GENERAL_REGNO_P (REGNO (op))")))
      34    207123731 : 
      35    459179307 : ;; True if the operand is an INDEX class register.
      36              : (define_predicate "index_reg_operand"
      37              :   (and (match_code "reg")
      38       674188 :        (match_test "INDEX_REGNO_P (REGNO (op))")))
      39       674113 : 
      40       674889 : ;; 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     57301459 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      44     63641742 :     (match_operand 0 "nonimmediate_operand")))
      45     79648204 : 
      46              : ;; True if the operand is a general operand with GENERAL class register.
      47              : (define_predicate "general_gr_operand"
      48     92927127 :   (if_then_else (match_code "reg")
      49     40369895 :     (match_test "GENERAL_REGNO_P (REGNO (op))")
      50    117877670 :     (match_operand 0 "general_operand")))
      51              : 
      52              : ;; True if the operand is an MMX register.
      53              : (define_predicate "mmx_reg_operand"
      54     39967602 :   (and (match_code "reg")
      55          192 :        (match_test "MMX_REGNO_P (REGNO (op))")))
      56     39967602 : 
      57              : ;; Match register operands, but include memory operands for
      58              : ;; !TARGET_MMX_WITH_SSE.
      59              : (define_predicate "register_mmxmem_operand"
      60       644131 :   (ior (match_operand 0 "register_operand")
      61           12 :        (and (not (match_test "TARGET_MMX_WITH_SSE"))
      62       644131 :             (match_operand 0 "memory_operand"))))
      63              : 
      64              : ;; True if the operand is an SSE register.
      65    160980807 : (define_predicate "sse_reg_operand"
      66              :   (and (match_code "reg")
      67    160980807 :        (match_test "SSE_REGNO_P (REGNO (op))")))
      68      1704657 : 
      69              : ;; Return true if op is a QImode register.
      70              : (define_predicate "any_QIreg_operand"
      71              :   (and (match_code "reg")
      72      8169940 :        (match_test "ANY_QI_REGNO_P (REGNO (op))")))
      73      3830314 : 
      74      9779868 : ;; Return true if op is one of QImode registers: %[abcd][hl].
      75              : (define_predicate "QIreg_operand"
      76              :   (and (match_code "reg")
      77      2308473 :        (match_test "QI_REGNO_P (REGNO (op))")))
      78      2178326 : 
      79      6179849 : ;; Return true if op is a QImode register operand other than %[abcd][hl].
      80              : (define_predicate "ext_QIreg_operand"
      81      3337385 :   (and (match_test "TARGET_64BIT")
      82      3337688 :        (match_code "reg")
      83       951179 :        (not (match_test "QI_REGNO_P (REGNO (op))"))))
      84      3591486 : 
      85              : ;; Return true if op is the AX register.
      86              : (define_predicate "ax_reg_operand"
      87              :   (and (match_code "reg")
      88     23228174 :        (match_test "REGNO (op) == AX_REG")))
      89            0 : 
      90    117413628 : ;; Return true if op is the flags register.
      91              : (define_special_predicate "flags_reg_operand"
      92              :   (and (match_code "reg")
      93    115364924 :        (match_test "REGNO (op) == FLAGS_REG")))
      94              : 
      95     41550772 : ;; True if the operand is a MASK register.
      96              : (define_predicate "mask_reg_operand"
      97      9742763 :   (and (match_code "reg")
      98         4552 :        (match_test "MASK_REGNO_P (REGNO (op))")))
      99      9747315 : 
     100              : ;; Return true if op is the block scale register.
     101              : (define_special_predicate "bsr0_operand"
     102              :   (and (match_code "reg")
     103          869 :        (match_test "REGNO (op) == BSR0_REG")))
     104              : 
     105          291 : ;; Match a DI, SI or HImode register operand.
     106              : (define_special_predicate "int248_register_operand"
     107       575193 :   (and (match_operand 0 "register_operand")
     108       862935 :        (ior (and (match_test "TARGET_64BIT")
     109       575193 :                  (match_test "GET_MODE (op) == DImode"))
     110       339333 :             (match_test "GET_MODE (op) == SImode")
     111       575193 :             (match_test "GET_MODE (op) == HImode"))))
     112              : 
     113              : ;; Match a DI, SI, HI or QImode nonimmediate_operand.
     114              : (define_special_predicate "int_nonimmediate_operand"
     115       386516 :   (and (match_operand 0 "nonimmediate_operand")
     116       451933 :        (ior (and (match_test "TARGET_64BIT")
     117       386516 :                  (match_test "GET_MODE (op) == DImode"))
     118       174509 :             (match_test "GET_MODE (op) == SImode")
     119              :             (match_test "GET_MODE (op) == HImode")
     120       386516 :             (match_test "GET_MODE (op) == QImode"))))
     121              : 
     122              : ;; Match register operands, but include memory operands for TARGET_SSE_MATH.
     123              : (define_predicate "register_ssemem_operand"
     124      2900547 :   (if_then_else
     125      2900547 :     (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     126      2900547 :     (match_operand 0 "nonimmediate_operand")
     127              :     (match_operand 0 "register_operand")))
     128              : 
     129      1082713 : ;; Match nonimmediate operands, but exclude memory operands
     130              : ;; for TARGET_SSE_MATH if TARGET_MIX_SSE_I387 is not enabled.
     131      1082713 : (define_predicate "nonimm_ssenomem_operand"
     132              :   (if_then_else
     133      1082713 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     134      2165426 :          (not (match_test "TARGET_MIX_SSE_I387")))
     135              :     (match_operand 0 "register_operand")
     136              :     (match_operand 0 "nonimmediate_operand")))
     137              : 
     138       772669 : ;; The above predicate, suitable for x87 arithmetic operators.
     139              : (define_predicate "x87nonimm_ssenomem_operand"
     140       772669 :   (if_then_else
     141       772669 :     (and (match_test "SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH")
     142      1545338 :          (not (match_test "TARGET_MIX_SSE_I387 && X87_ENABLE_ARITH (mode)")))
     143              :     (match_operand 0 "register_operand")
     144              :     (match_operand 0 "nonimmediate_operand")))
     145              : 
     146        35278 : ;; Match register operands, include memory operand for TARGET_SSE4_1.
     147              : (define_predicate "register_sse4nonimm_operand"
     148        35278 :   (if_then_else (match_test "TARGET_SSE4_1")
     149              :     (match_operand 0 "nonimmediate_operand")
     150              :     (match_operand 0 "register_operand")))
     151              : 
     152        14090 : ;; Return true if VALUE is symbol reference
     153              : (define_predicate "symbol_operand"
     154        14090 :   (match_code "symbol_ref"))
     155        14090 : 
     156              : ;; Return true if VALUE is an ENDBR opcode in immediate field.
     157              : (define_predicate "ix86_endbr_immediate_operand"
     158              :   (match_code "const_int")
     159   6480842843 : {
     160   6480842843 :   if (flag_cf_protection & CF_BRANCH)
     161              :      {
     162   1193121225 :        unsigned HOST_WIDE_INT imm = UINTVAL (op);
     163   1193121225 :        unsigned HOST_WIDE_INT val = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
     164              : 
     165   1193121225 :        if (imm == val)
     166              :          return true;
     167              : 
     168              :        /* NB: Encoding is byte based.  */
     169   1193121017 :        if (TARGET_64BIT)
     170   2300145680 :          for (; imm >= val; imm >>= 8)
     171   1296402688 :            if (imm == val)
     172              :              return true;
     173              :       }
     174              : 
     175              :   return false;
     176              : })
     177              : 
     178              : ;; Return true if VALUE can be stored in a sign extended immediate field.
     179   8403731057 : (define_predicate "x86_64_immediate_operand"
     180              :   (match_code "const_int,symbol_ref,label_ref,const")
     181   8403731057 : {
     182  11498609538 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     183              :     return false;
     184              : 
     185   5017766444 :   if (!TARGET_64BIT)
     186   5204830086 :     return immediate_operand (op, mode);
     187              : 
     188   4830703053 :   switch (GET_CODE (op))
     189              :     {
     190   3957165213 :     case CONST_INT:
     191   3957165213 :       {
     192   3957165213 :         HOST_WIDE_INT val = INTVAL (op);
     193   3957165213 :         return trunc_int_for_mode (val, SImode) == val;
     194              :       }
     195    705775626 :     case SYMBOL_REF:
     196              :       /* TLS symbols are not constant.  */
     197    705775626 :       if (SYMBOL_REF_TLS_MODEL (op))
     198              :         return false;
     199              : 
     200              :       /* Load the external function address via the GOT slot.  */
     201    705739484 :       if (ix86_force_load_from_GOT_p (op))
     202              :         return false;
     203              : 
     204              :       /* For certain code models, the symbolic references are known to fit.
     205              :          in CM_SMALL_PIC model we know it fits if it is local to the shared
     206              :          library.  Don't count TLS SYMBOL_REFs here, since they should fit
     207              :          only if inside of UNSPEC handled below.  */
     208    705739382 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
     209    705739382 :               || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
     210              : 
     211     23749986 :     case LABEL_REF:
     212              :       /* For certain code models, the code is near as well.  */
     213     23749986 :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
     214              :               || ix86_cmodel == CM_KERNEL);
     215              : 
     216    144012228 :     case CONST:
     217              :       /* We also may accept the offsetted memory references in certain
     218              :          special cases.  */
     219    144012228 :       if (GET_CODE (XEXP (op, 0)) == UNSPEC)
     220       736612 :         switch (XINT (XEXP (op, 0), 1))
     221              :           {
     222              :           case UNSPEC_GOTPCREL:
     223              :           case UNSPEC_DTPOFF:
     224              :           case UNSPEC_GOTNTPOFF:
     225              :           case UNSPEC_NTPOFF:
     226              :           case UNSPEC_SECREL32:
     227              :             return true;
     228              :           default:
     229              :             break;
     230              :           }
     231              : 
     232    143277126 :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     233              :         {
     234    143275616 :           rtx op1 = XEXP (XEXP (op, 0), 0);
     235    143275616 :           rtx op2 = XEXP (XEXP (op, 0), 1);
     236              : 
     237    143275616 :           if (ix86_cmodel == CM_LARGE && GET_CODE (op1) != UNSPEC)
     238              :             return false;
     239    143275611 :           if (!CONST_INT_P (op2))
     240              :             return false;
     241              : 
     242    143275611 :           HOST_WIDE_INT offset = INTVAL (op2);
     243    143275611 :           if (trunc_int_for_mode (offset, SImode) != offset)
     244              :             return false;
     245              : 
     246    143270208 :           switch (GET_CODE (op1))
     247              :             {
     248    142924337 :             case SYMBOL_REF:
     249              :               /* TLS symbols are not constant.  */
     250    142924337 :               if (SYMBOL_REF_TLS_MODEL (op1))
     251              :                 return false;
     252              : 
     253              :               /* Load the external function address via the GOT slot.  */
     254    142913801 :               if (ix86_force_load_from_GOT_p (op1))
     255              :                 return false;
     256              : 
     257              :               /* For CM_SMALL assume that latest object is 16MB before
     258              :                  end of 31bits boundary.  We may also accept pretty
     259              :                  large negative constants knowing that all objects are
     260              :                  in the positive half of address space.  */
     261    142913795 :               if ((ix86_cmodel == CM_SMALL
     262       266806 :                    || (ix86_cmodel == CM_MEDIUM
     263            0 :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     264    142913795 :                   && offset < 16*1024*1024)
     265              :                 return true;
     266              :               /* For CM_KERNEL we know that all object resist in the
     267              :                  negative half of 32bits address space.  We may not
     268              :                  accept negative offsets, since they may be just off
     269              :                  and we may accept pretty large positive ones.  */
     270       269751 :               if (ix86_cmodel == CM_KERNEL
     271            0 :                   && offset > 0)
     272              :                 return true;
     273              :               break;
     274              : 
     275         6026 :             case LABEL_REF:
     276              :               /* These conditions are similar to SYMBOL_REF ones, just the
     277              :                  constraints for code models differ.  */
     278         6026 :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     279         6026 :                   && offset < 16*1024*1024)
     280              :                 return true;
     281            0 :               if (ix86_cmodel == CM_KERNEL
     282            0 :                   && offset > 0)
     283              :                 return true;
     284              :               break;
     285              : 
     286       339845 :             case UNSPEC:
     287       339845 :               switch (XINT (op1, 1))
     288              :                 {
     289              :                 case UNSPEC_DTPOFF:
     290              :                 case UNSPEC_NTPOFF:
     291              :                   return true;
     292              :                 }
     293              :               break;
     294              : 
     295              :             default:
     296              :               break;
     297              :             }
     298              :         }
     299              :       break;
     300              : 
     301            0 :       default:
     302            0 :         gcc_unreachable ();
     303              :     }
     304              : 
     305              :   return false;
     306              : })
     307              : 
     308              : ;; Return true if VALUE can be stored in the zero extended immediate field.
     309   5508398301 : (define_predicate "x86_64_zext_immediate_operand"
     310              :   (match_code "const_int,symbol_ref,label_ref,const")
     311   5508398301 : {
     312    755826003 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     313   5017766695 :     return false;
     314   5017766695 : 
     315    755825855 :   switch (GET_CODE (op))
     316   5017766695 :     {
     317   5704606241 :     case CONST_INT:
     318    686839546 :       return !(INTVAL (op) & ~HOST_WIDE_INT_C (0xffffffff));
     319              : 
     320     62597302 :     case SYMBOL_REF:
     321   5017766695 :       /* TLS symbols are not constant.  */
     322   5080363997 :       if (SYMBOL_REF_TLS_MODEL (op))
     323    271442492 :         return false;
     324              : 
     325              :       /* Load the external function address via the GOT slot.  */
     326     62562031 :       if (ix86_force_load_from_GOT_p (op))
     327    755826003 :         return false;
     328              : 
     329              :      /* For certain code models, the symbolic references are known to fit.  */
     330     62561930 :       return (ix86_cmodel == CM_SMALL
     331     62561930 :               || (ix86_cmodel == CM_MEDIUM
     332          218 :                   && !SYMBOL_REF_FAR_ADDR_P (op)));
     333              : 
     334      2374807 :     case LABEL_REF:
     335              :       /* For certain code models, the code is near as well.  */
     336      2374807 :       return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
     337              : 
     338      4014200 :     case CONST:
     339              :       /* We also may accept the offsetted memory references in certain
     340              :          special cases.  */
     341      4014200 :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     342              :         {
     343      4009558 :           rtx op1 = XEXP (XEXP (op, 0), 0);
     344      4009558 :           rtx op2 = XEXP (XEXP (op, 0), 1);
     345              : 
     346      4009558 :           if (ix86_cmodel == CM_LARGE)
     347              :             return false;
     348      4009556 :           if (!CONST_INT_P (op2))
     349              :             return false;
     350              : 
     351      4009556 :           HOST_WIDE_INT offset = INTVAL (op2);
     352      4009556 :           if (trunc_int_for_mode (offset, SImode) != offset)
     353              :             return false;
     354              : 
     355      4006723 :           switch (GET_CODE (op1))
     356              :             {
     357      4006228 :             case SYMBOL_REF:
     358              :               /* TLS symbols are not constant.  */
     359      4006228 :               if (SYMBOL_REF_TLS_MODEL (op1))
     360              :                 return false;
     361              : 
     362              :               /* Load the external function address via the GOT slot.  */
     363      3996920 :               if (ix86_force_load_from_GOT_p (op1))
     364              :                 return false;
     365              : 
     366              :               /* For small code model we may accept pretty large positive
     367              :                  offsets, since one bit is available for free.  Negative
     368              :                  offsets are limited by the size of NULL pointer area
     369              :                  specified by the ABI.  */
     370      3996914 :               if ((ix86_cmodel == CM_SMALL
     371       234651 :                    || (ix86_cmodel == CM_MEDIUM
     372            0 :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     373      3996914 :                   && offset > -0x10000)
     374              :                 return true;
     375              :               /* ??? For the kernel, we may accept adjustment of
     376              :                  -0x10000000, since we know that it will just convert
     377              :                  negative address space to positive, but perhaps this
     378              :                  is not worthwhile.  */
     379              :               break;
     380              : 
     381            0 :             case LABEL_REF:
     382              :               /* These conditions are similar to SYMBOL_REF ones, just the
     383              :                  constraints for code models differ.  */
     384            0 :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     385            0 :                   && offset > -0x10000)
     386              :                 return true;
     387              :               break;
     388              : 
     389              :             default:
     390              :               return false;
     391              :             }
     392              :         }
     393              :       break;
     394              : 
     395            0 :     default:
     396            0 :       gcc_unreachable ();
     397              :     }
     398              :   return false;
     399              : })
     400              : 
     401              : ;; Return true if VALUE is a constant integer whose negation satisfies
     402   1008388345 : ;; x86_64_immediate_operand.
     403              : (define_predicate "x86_64_neg_const_int_operand"
     404   1008388345 :   (match_code "const_int")
     405              : {
     406    755860377 :   HOST_WIDE_INT val = -UINTVAL (op);
     407        16456 :   if (mode == DImode && trunc_int_for_mode (val, SImode) != val)
     408    755826003 :     return false;
     409        33777 :   if (flag_cf_protection & CF_BRANCH)
     410    755826003 :     {
     411        13799 :       unsigned HOST_WIDE_INT endbr = TARGET_64BIT ? 0xfa1e0ff3 : 0xfb1e0ff3;
     412        13799 :       if ((val & HOST_WIDE_INT_C (0xffffffff)) == endbr)
     413            0 :         return false;
     414    755826003 :     }
     415    755826003 :   return true;
     416     54755020 : })
     417              : 
     418              : ;; Return true if VALUE is a constant integer whose low and high words satisfy
     419        48322 : ;; x86_64_immediate_operand.
     420        34374 : (define_predicate "x86_64_hilo_int_operand"
     421        82696 :   (match_code "const_int,const_wide_int")
     422        34374 : {
     423     44285318 :   switch (GET_CODE (op))
     424              :     {
     425     44225897 :     case CONST_INT:
     426     44285318 :       return x86_64_immediate_operand (op, mode);
     427              : 
     428        59421 :     case CONST_WIDE_INT:
     429        59421 :       gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
     430        59421 :       return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
     431              :                                         DImode)
     432        59421 :               && x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op,
     433              :                                                                         1)),
     434              :                                            DImode));
     435              : 
     436            0 :     default:
     437            0 :       gcc_unreachable ();
     438              :     }
     439              : })
     440              : 
     441              : ;; Return true if VALUE is a constant integer whose value is
     442     44876390 : ;; x86_64_immediate_operand value zero extended from word mode to mode.
     443              : (define_predicate "x86_64_dwzext_immediate_operand"
     444     44876390 :   (match_code "const_int,const_wide_int")
     445              : {
     446         3742 :   if (ix86_endbr_immediate_operand (op, VOIDmode))
     447     44285318 :     return false;
     448     44285318 : 
     449         3742 :   switch (GET_CODE (op))
     450              :     {
     451         1624 :     case CONST_INT:
     452         1624 :       if (!TARGET_64BIT)
     453     44285318 :         return UINTVAL (op) <= HOST_WIDE_INT_UC (0xffffffff);
     454         1624 :       return UINTVAL (op) <= HOST_WIDE_INT_UC (0x7fffffff);
     455              : 
     456         2118 :     case CONST_WIDE_INT:
     457         5860 :       if (!TARGET_64BIT)
     458              :         return false;
     459         2118 :       return (CONST_WIDE_INT_NUNITS (op) == 2
     460         2118 :               && CONST_WIDE_INT_ELT (op, 1) == 0
     461         4236 :               && (trunc_int_for_mode (CONST_WIDE_INT_ELT (op, 0), SImode)
     462         2118 :                   == (HOST_WIDE_INT) CONST_WIDE_INT_ELT (op, 0)));
     463              : 
     464            0 :     default:
     465            0 :       gcc_unreachable ();
     466              :     }
     467              : })
     468              : 
     469              : ;; Return true if OP is general operand representable on x86_64.
     470         3742 : (define_predicate "x86_64_general_operand"
     471    150350915 :   (if_then_else (match_test "TARGET_64BIT")
     472         3742 :     (ior (match_operand 0 "nonimmediate_operand")
     473              :          (match_operand 0 "x86_64_immediate_operand"))
     474         3742 :     (match_operand 0 "general_operand")))
     475     63245969 : 
     476         3742 : ;; Return true if OP's both words are general operands representable
     477     63242227 : ;; on x86_64.
     478              : (define_predicate "x86_64_hilo_general_operand"
     479     63242227 :   (if_then_else (match_test "TARGET_64BIT")
     480         3742 :     (ior (match_operand 0 "nonimmediate_operand")
     481         3742 :          (match_operand 0 "x86_64_hilo_int_operand"))
     482              :     (match_operand 0 "general_operand")))
     483       282037 : 
     484              : ;; Return true if OP is non-VOIDmode general operand representable
     485    150632952 : ;; on x86_64.  This predicate is used in sign-extending conversion
     486              : ;; operations that require non-VOIDmode immediate operands.
     487    150350915 : (define_predicate "x86_64_sext_operand"
     488       282037 :   (and (match_test "GET_MODE (op) != VOIDmode")
     489              :        (match_operand 0 "x86_64_general_operand")))
     490              : 
     491              : ;; Return true if OP is non-VOIDmode general operand.  This predicate
     492        11347 : ;; is used in sign-extending conversion operations that require
     493              : ;; non-VOIDmode immediate operands.
     494        11347 : (define_predicate "sext_operand"
     495        11347 :   (and (match_test "GET_MODE (op) != VOIDmode")
     496              :        (match_operand 0 "general_operand")))
     497              : 
     498              : ;; Return true if OP is representable on x86_64 as zero-extended operand.
     499      3659824 : ;; This predicate is used in zero-extending conversion operations that
     500              : ;; require non-VOIDmode immediate operands.
     501      3659824 : (define_predicate "x86_64_zext_operand"
     502      3659824 :   (if_then_else (match_test "TARGET_64BIT")
     503              :     (ior (match_operand 0 "nonimmediate_operand")
     504              :          (and (match_operand 0 "x86_64_zext_immediate_operand")
     505       136001 :               (match_test "GET_MODE (op) != VOIDmode")))
     506              :     (match_operand 0 "nonimmediate_operand")))
     507              : 
     508              : ;; Return true if OP is general operand representable on x86_64
     509      2543560 : ;; as either sign extended or zero extended constant.
     510              : (define_predicate "x86_64_szext_general_operand"
     511      2543560 :   (if_then_else (match_test "TARGET_64BIT")
     512              :     (ior (match_operand 0 "nonimmediate_operand")
     513              :          (match_operand 0 "x86_64_immediate_operand")
     514              :          (match_operand 0 "x86_64_zext_immediate_operand"))
     515     30542821 :     (match_operand 0 "general_operand")))
     516              : 
     517     30542821 : ;; Return true if OP is nonmemory operand representable on x86_64.
     518              : (define_predicate "x86_64_nonmemory_operand"
     519     30542821 :   (if_then_else (match_test "TARGET_64BIT")
     520              :     (ior (match_operand 0 "register_operand")
     521              :          (match_operand 0 "x86_64_immediate_operand"))
     522              :     (match_operand 0 "nonmemory_operand")))
     523        19819 : 
     524              : ;; Return true if OP is nonmemory operand representable on x86_64.
     525        19819 : (define_predicate "x86_64_szext_nonmemory_operand"
     526        19819 :   (if_then_else (match_test "TARGET_64BIT")
     527              :     (ior (match_operand 0 "register_operand")
     528              :          (match_operand 0 "x86_64_immediate_operand")
     529              :          (match_operand 0 "x86_64_zext_immediate_operand"))
     530    180312472 :     (match_operand 0 "nonmemory_operand")))
     531              : 
     532              : ;; Return true when operand is PIC expression that can be computed by lea
     533              : ;; operation.
     534              : (define_predicate "pic_32bit_operand"
     535              :   (match_code "const,symbol_ref,label_ref")
     536              : {
     537    180312472 :   if (!flag_pic)
     538              :     return false;
     539              : 
     540              :   /* Rule out relocations that translate into 64bit constants.  */
     541     20912741 :   if (TARGET_64BIT && GET_CODE (op) == CONST)
     542              :     {
     543       185027 :       rtx tmp = XEXP (op, 0);
     544       185027 :       if (GET_CODE (tmp) == PLUS && CONST_INT_P (XEXP (tmp, 1)))
     545       183565 :         tmp = XEXP (tmp, 0);
     546       185027 :       if (GET_CODE (tmp) == UNSPEC
     547         1462 :           && (XINT (tmp, 1) == UNSPEC_GOTOFF
     548         1462 :               || XINT (tmp, 1) == UNSPEC_GOT))
     549              :         return false;
     550              :     }
     551              : 
     552     20911819 :   return symbolic_operand (op, mode);
     553              : })
     554              : 
     555              : ;; Return true if OP is nonmemory operand acceptable by movabs patterns.
     556   1322255601 : (define_predicate "x86_64_movabs_operand"
     557              :   (and (match_operand 0 "nonmemory_operand")
     558   1322255601 :        (not (match_operand 0 "pic_32bit_operand"))))
     559              : 
     560    180312472 : ;; Return true if OP is either a symbol reference or a sum of a symbol
     561    180312472 : ;; reference and a constant.
     562    180312472 : (define_predicate "symbolic_operand"
     563    180312472 :   (match_code "symbol_ref,label_ref,const")
     564              : {
     565     21653624 :   switch (GET_CODE (op))
     566              :     {
     567    180312472 :     case SYMBOL_REF:
     568    180312472 :     case LABEL_REF:
     569       555475 :       return true;
     570              : 
     571       221765 :     case CONST:
     572       221765 :       op = XEXP (op, 0);
     573    524583147 :       if (SYMBOL_REF_P (op)
     574       221765 :           || LABEL_REF_P (op)
     575    524583147 :           || (GET_CODE (op) == UNSPEC
     576         8401 :               && (XINT (op, 1) == UNSPEC_GOT
     577         8401 :                   || XINT (op, 1) == UNSPEC_GOTOFF
     578          697 :                   || XINT (op, 1) == UNSPEC_SECREL32
     579     21654321 :                   || XINT (op, 1) == UNSPEC_PCREL
     580          697 :                   || XINT (op, 1) == UNSPEC_GOTPCREL)))
     581              :         return true;
     582       214033 :       if (GET_CODE (op) != PLUS
     583       213364 :           || !CONST_INT_P (XEXP (op, 1)))
     584              :         return false;
     585              : 
     586       213364 :       op = XEXP (op, 0);
     587       213364 :       if (SYMBOL_REF_P (op)
     588       213364 :           || LABEL_REF_P (op))
     589              :         return true;
     590              :       /* Only @GOTOFF and @SECREL32 get offsets.  */
     591         2137 :       if (GET_CODE (op) != UNSPEC
     592         2137 :           || (XINT (op, 1) != UNSPEC_GOTOFF
     593            0 :               && XINT (op, 1) != UNSPEC_SECREL32))
     594              :         return false;
     595              : 
     596         2137 :       op = XVECEXP (op, 0, 0);
     597         2137 :       if (SYMBOL_REF_P (op)
     598         2137 :           || LABEL_REF_P (op))
     599         2137 :         return true;
     600              :       return false;
     601              : 
     602            0 :     default:
     603            0 :       gcc_unreachable ();
     604              :     }
     605              : })
     606              : 
     607              : ;; Return true if OP is a symbolic operand that resolves locally.
     608     31354819 : (define_predicate "local_symbolic_operand"
     609              :   (match_code "const,label_ref,symbol_ref")
     610     31354819 : {
     611      2925396 :   if (GET_CODE (op) == CONST
     612        16176 :       && GET_CODE (XEXP (op, 0)) == PLUS
     613         8529 :       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
     614         8529 :     op = XEXP (XEXP (op, 0), 0);
     615     21653624 : 
     616      2925396 :   if (LABEL_REF_P (op))
     617              :     return true;
     618              : 
     619      2879246 :   if (!SYMBOL_REF_P (op))
     620     21653624 :     return false;
     621      1297151 : 
     622      2869462 :   if (SYMBOL_REF_TLS_MODEL (op))
     623              :     return false;
     624              : 
     625      2925396 :   /* Dll-imported symbols are always external.  */
     626      2869462 :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     627              :     return false;
     628      2869462 :   if (SYMBOL_REF_LOCAL_P (op))
     629              :     return true;
     630              : 
     631              :   /* There is, however, a not insubstantial body of code in the rest of
     632              :      the compiler that assumes it can just stick the results of
     633              :      ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done.  */
     634              :   /* ??? This is a hack.  Should update the body of the compiler to
     635              :      always create a DECL an invoke targetm.encode_section_info.  */
     636        93664 :   if (strncmp (XSTR (op, 0), internal_label_prefix,
     637              :                internal_label_prefix_len) == 0)
     638            0 :     return true;
     639              : 
     640              :   return false;
     641              : })
     642              : 
     643              : (define_predicate "local_func_symbolic_operand"
     644      2934141 :   (match_operand 0 "local_symbolic_operand")
     645              : {
     646      2934141 :   if (GET_CODE (op) == CONST
     647            0 :       && GET_CODE (XEXP (op, 0)) == PLUS
     648            0 :       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
     649            0 :     op = XEXP (XEXP (op, 0), 0);
     650      2925396 : 
     651      2925408 :   if (SYMBOL_REF_P (op)
     652           12 :       && !SYMBOL_REF_FUNCTION_P (op))
     653            0 :     return false;
     654              : 
     655      2925396 :   return true;
     656      2925396 : })
     657      2821939 : 
     658              : ;; Test for a legitimate @GOTOFF operand.
     659           30 : ;;
     660              : ;; VxWorks does not impose a fixed gap between segments; the run-time
     661           42 : ;; gap can be different from the object-file gap.  We therefore can't
     662           12 : ;; use @GOTOFF unless we are absolutely sure that the symbol is in the
     663              : ;; same segment as the GOT.  Unfortunately, the flexibility of linker
     664              : ;; scripts means that we can't be sure of that in general, so assume
     665              : ;; @GOTOFF is not valid on VxWorks, except with the large code model.
     666      2934074 : ;; The comments above seem to apply only to VxWorks releases before 7.
     667              : (define_predicate "gotoff_operand"
     668      2934074 :   (and (ior (not (match_test "TARGET_VXWORKS_VAROFF"))
     669              :             (match_test "ix86_cmodel == CM_LARGE")
     670      2934074 :             (match_test "ix86_cmodel == CM_LARGE_PIC"))
     671              :        (match_operand 0 "local_symbolic_operand")))
     672              : 
     673              : ;; Test for various thread-local symbols.
     674        30008 : (define_special_predicate "tls_symbolic_operand"
     675              :   (and (match_code "symbol_ref")
     676        30008 :        (match_test "SYMBOL_REF_TLS_MODEL (op)")))
     677              : 
     678              : (define_special_predicate "tls_modbase_operand"
     679              :   (and (match_code "symbol_ref")
     680           72 :        (match_test "op == ix86_tls_module_base ()")))
     681              : 
     682          144 : (define_predicate "tls_address_pattern"
     683              :   (and (match_code "set,parallel,unspec,unspec_volatile")
     684    239701054 :        (match_test "ix86_tls_address_pattern_p (op)")))
     685            0 : 
     686    239701054 : ;; Test for a pc-relative call operand
     687              : (define_predicate "constant_call_address_operand"
     688    239701054 :   (match_code "symbol_ref")
     689    375898706 : {
     690    136197443 :   if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
     691    136197432 :       || flag_force_indirect_call
     692    272393580 :       || (TARGET_INDIRECT_BRANCH_REGISTER
     693         1022 :           && ix86_nopic_noplt_attribute_p (op)))
     694         1748 :     return false;
     695              :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     696    239701054 :     return false;
     697              :   return true;
     698              : })
     699              : 
     700              : ;; True for any non-virtual and non-eliminable register.  Used in places where
     701    141860373 : ;; instantiation of such a register may cause the pattern to not be recognized.
     702              : (define_predicate "register_no_elim_operand"
     703    136197652 :   (match_operand 0 "register_operand")
     704    278056277 : {
     705     98183869 :   if (SUBREG_P (op))
     706        58525 :     op = SUBREG_REG (op);
     707              : 
     708              :   /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
     709     20739210 :      because it is guaranteed to be reloaded into one.  */
     710     20739210 :   if (MEM_P (op))
     711              :     return true;
     712              : 
     713     20739210 :   return !(op == arg_pointer_rtx
     714     20710864 :            || op == frame_pointer_rtx
     715     20708596 :            || VIRTUAL_REGISTER_P (op));
     716              : })
     717              : 
     718              : ;; Similarly, but include the stack pointer.  This is used
     719     24725383 : ;; to prevent esp from being used as an index reg.
     720              : (define_predicate "register_no_SP_operand"
     721     24725383 :   (match_operand 0 "register_operand")
     722     20739210 : {
     723       329474 :   if (SUBREG_P (op))
     724         7899 :     op = SUBREG_REG (op);
     725              : 
     726       329474 :   /* Before reload, we can allow (SUBREG (MEM...)) as a register operand
     727              :      because it is guaranteed to be reloaded into one.  */
     728       329474 :   if (MEM_P (op))
     729              :     return true;
     730              : 
     731       329474 :   return !(op == arg_pointer_rtx
     732       329474 :            || op == frame_pointer_rtx
     733       329474 :            || op == stack_pointer_rtx
     734       329474 :            || VIRTUAL_REGISTER_P (op));
     735              : })
     736              : 
     737              : ;; P6 processors will jump to the address after the decrement when %esp
     738       366343 : ;; is used as a call operand, so they will execute return address as a code.
     739              : ;; See Pentium Pro errata 70, Pentium 2 errata A33 and Pentium 3 errata E17.
     740       366343 : 
     741       329474 : (define_predicate "call_register_operand"
     742      1839874 :   (if_then_else (match_test "TARGET_64BIT")
     743              :     (match_operand 0 "register_operand")
     744              :     (match_operand 0 "register_no_SP_operand")))
     745      1839874 : 
     746     17943786 : ;; Return false if this is any eliminable register.  Otherwise general_operand.
     747      1839874 : (define_predicate "general_no_elim_operand"
     748     17943786 :   (if_then_else (match_code "reg,subreg")
     749              :     (match_operand 0 "register_no_elim_operand")
     750              :     (match_operand 0 "general_operand")))
     751              : 
     752     11605363 : ;; Return false if this is any eliminable register.  Otherwise
     753              : ;; register_operand or a constant.
     754     11605363 : (define_predicate "nonmemory_no_elim_operand"
     755              :   (ior (match_operand 0 "register_no_elim_operand")
     756              :        (match_operand 0 "immediate_operand")))
     757              : 
     758       630486 : ;; Test for a valid operand for indirect branch.
     759              : (define_predicate "indirect_branch_operand"
     760       630486 :   (ior (match_operand 0 "register_operand")
     761       573590 :        (and (not (match_test "TARGET_INDIRECT_BRANCH_REGISTER"))
     762       573563 :             (not (match_test "TARGET_X32"))
     763              :             (match_operand 0 "memory_operand"))))
     764              : 
     765              : ;; Return true if OP is a memory operands that can be used in sibcalls.
     766        24051 : ;; Since sibcall never returns, we can only use call-clobbered register
     767              : ;; as GOT base.  Allow GOT slot here only with pseudo register as GOT
     768              : ;; base.  Properly handle sibcall over GOT slot with *sibcall_GOT_32
     769              : ;; and *sibcall_value_GOT_32 patterns.
     770              : (define_predicate "sibcall_memory_operand"
     771              :   (match_operand 0 "memory_operand")
     772              : {
     773        24051 :   op = XEXP (op, 0);
     774        24051 :   if (CONSTANT_P (op))
     775              :     return true;
     776        10510 :   if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
     777              :     {
     778         9492 :       int regno = REGNO (XEXP (op, 0));
     779         9492 :       if (!HARD_REGISTER_NUM_P (regno) || call_used_or_fixed_reg_p (regno))
     780              :         {
     781         7768 :           op = XEXP (op, 1);
     782         7768 :           if (GOT32_symbol_operand (op, VOIDmode))
     783              :             return true;
     784              :         }
     785              :     }
     786              :   return false;
     787              : })
     788              : 
     789              : ;; Return true if OP is a GOT memory operand.
     790      1352766 : (define_predicate "GOT_memory_operand"
     791              :   (and (match_operand 0 "memory_operand")
     792      1376817 :        (match_code "const" "0")
     793        24051 :        (match_code "unspec" "00")
     794          566 :        (match_test "XINT (XEXP (XEXP (op, 0), 0), 1) == UNSPEC_GOTPCREL")))
     795              : 
     796              : ;; Test for a valid operand for a call instruction.
     797          464 : ;; Allow constant call address operands in Pmode only.
     798     48696499 : (define_special_predicate "call_insn_operand"
     799          464 :   (ior (match_test "constant_call_address_operand
     800     54857579 :                      (op, mode == VOIDmode ? mode : Pmode)")
     801              :        (match_operand 0 "call_register_operand")
     802       841157 :        (match_test "satisfies_constraint_Bw (op)")))
     803              : 
     804              : ;; Similarly, but for tail calls, in which we cannot allow memory references.
     805              : (define_special_predicate "sibcall_insn_operand"
     806      1201394 :   (ior (match_test "constant_call_address_operand
     807      1362191 :                      (op, mode == VOIDmode ? mode : Pmode)")
     808      1201394 :        (match_operand 0 "register_no_elim_operand")
     809       123141 :        (match_test "satisfies_constraint_Bs (op)")))
     810              : 
     811              : ;; Return true if OP is a 32-bit GOT symbol operand.
     812              : (define_predicate "GOT32_symbol_operand"
     813         9680 :   (and (match_code "const")
     814              :        (match_code "unspec" "0")
     815         9680 :        (match_test "XINT (XEXP (op, 0), 1) == UNSPEC_GOT")))
     816            0 : 
     817              : ;; Return true if OP is a PLTOFF symbol operand.
     818              : (define_predicate "pltoff_symbol_operand"
     819              :   (and (match_code "const")
     820            6 :        (match_code "unspec" "0")
     821            6 :        (match_test "XINT (XEXP (op, 0), 1) == UNSPEC_PLTOFF")))
     822           12 : 
     823              : ;; Match exactly zero.
     824              : (define_predicate "const0_operand"
     825              :   (match_code "const_int,const_double,const_vector")
     826    139590134 : {
     827    139590134 :   if (mode == VOIDmode)
     828     21871690 :     mode = GET_MODE (op);
     829    139590134 :   return op == CONST0_RTX (mode);
     830              : })
     831              : 
     832              : ;; Match one or a vector with all elements equal to one.
     833    995320265 : (define_predicate "const1_operand"
     834              :   (match_code "const_int,const_double,const_vector")
     835    995320265 : {
     836     11765298 :   if (mode == VOIDmode)
     837     11702067 :     mode = GET_MODE (op);
     838    151355432 :   return op == CONST1_RTX (mode);
     839    139590134 : })
     840    139590134 : 
     841              : ;; Match exactly -1.
     842     13031500 : (define_predicate "constm1_operand"
     843              :   (and (match_code "const_int")
     844    152621634 :        (match_test "op == constm1_rtx")))
     845    139590134 : 
     846     63639032 : ;; Match 0 or -1.
     847     11765298 : (define_predicate "const0_or_m1_operand"
     848     11768212 :   (ior (match_operand 0 "const0_operand")
     849     11765298 :        (match_operand 0 "constm1_operand")))
     850         2914 : 
     851              : ;; Match exactly eight.
     852              : (define_predicate "const8_operand"
     853     11765298 :   (and (match_code "const_int")
     854     11765298 :        (match_test "INTVAL (op) == 8")))
     855        10164 : 
     856       205152 : ;; Match exactly 128.
     857              : (define_predicate "const128_operand"
     858     27763969 :   (and (match_code "const_int")
     859    245312257 :        (match_test "INTVAL (op) == 128")))
     860     27763969 : 
     861    194406262 : ;; Match exactly 0x0FFFFFFFF in anddi as a zero-extension operation
     862              : (define_predicate "const_32bit_mask"
     863      2951681 :   (and (match_code "const_int")
     864      1955874 :        (match_test "trunc_int_for_mode (INTVAL (op), DImode)
     865      4907555 :                     == HOST_WIDE_INT_C (0xffffffff)")))
     866              : 
     867              : ;; Match 2, 4, or 8.  Used for leal multiplicands.
     868              : (define_predicate "const248_operand"
     869       304267 :   (match_code "const_int")
     870              : {
     871       304267 :   HOST_WIDE_INT i = INTVAL (op);
     872       304267 :   return i == 2 || i == 4 || i == 8;
     873              : })
     874              : 
     875              : ;; Match 1, 2, or 3.  Used for lea shift amounts.
     876      1041624 : (define_predicate "const123_operand"
     877              :   (match_code "const_int")
     878      1041624 : {
     879      1278483 :   HOST_WIDE_INT i = INTVAL (op);
     880       236859 :   return i == 1 || i == 2 || i == 3;
     881              : })
     882              : 
     883       236859 : ;; Match 1, 2, 4, or 8
     884       245263 : (define_predicate "const1248_operand"
     885              :   (match_code "const_int")
     886       245263 : {
     887       236859 :   HOST_WIDE_INT i = INTVAL (op);
     888       110168 :   return i == 1 || i == 2 || i == 4 || i == 8;
     889              : })
     890              : 
     891       110168 : ;; Match 3, 5, or 9.  Used for leal multiplicands.
     892       546676 : (define_predicate "const359_operand"
     893              :   (match_code "const_int")
     894       546676 : {
     895       594038 :   HOST_WIDE_INT i = INTVAL (op);
     896        47362 :   return i == 3 || i == 5 || i == 9;
     897              : })
     898              : 
     899        47362 : ;; Match 4 or 8 to 11.  Used for embedded rounding.
     900       227715 : (define_predicate "const_4_or_8_to_11_operand"
     901              :   (match_code "const_int")
     902       227715 : {
     903       307856 :   HOST_WIDE_INT i = INTVAL (op);
     904        80141 :   return i == 4 || (i >= 8 && i <= 11);
     905              : })
     906              : 
     907        80141 : ;; Match 4 or 8. Used for SAE.
     908        80143 : (define_predicate "const48_operand"
     909              :   (match_code "const_int")
     910        80143 : {
     911        80141 :   HOST_WIDE_INT i = INTVAL (op);
     912        65849 :   return i == 4 || i == 8;
     913              : })
     914              : 
     915        65849 : ;; Match 0 or 1.
     916        65849 : (define_predicate "const_0_to_1_operand"
     917              :   (and (match_code "const_int")
     918        65849 :        (ior (match_test "op == const0_rtx")
     919       300807 :             (match_test "op == const1_rtx"))))
     920              : 
     921              : ;; Match 0 to 3.
     922              : (define_predicate "const_0_to_3_operand"
     923      7877825 :   (and (match_code "const_int")
     924     14968400 :        (match_test "IN_RANGE (INTVAL (op), 0, 3)")))
     925      7877825 : 
     926              : ;; Match 0 to 7.
     927              : (define_predicate "const_0_to_7_operand"
     928       790410 :   (and (match_code "const_int")
     929      1580805 :        (match_test "IN_RANGE (INTVAL (op), 0, 7)")))
     930       790410 : 
     931              : ;; Match 0 to 15.
     932              : (define_predicate "const_0_to_15_operand"
     933        81953 :   (and (match_code "const_int")
     934       163890 :        (match_test "IN_RANGE (INTVAL (op), 0, 15)")))
     935        81953 : 
     936              : ;; Match 0 to 31.
     937              : (define_predicate "const_0_to_31_operand"
     938        57234 :   (and (match_code "const_int")
     939       112182 :        (match_test "IN_RANGE (INTVAL (op), 0, 31)")))
     940        57234 : 
     941              : ;; Match 0 to 63.
     942              : (define_predicate "const_0_to_63_operand"
     943        30848 :   (and (match_code "const_int")
     944        59602 :        (match_test "IN_RANGE (INTVAL (op), 0, 63)")))
     945        30848 : 
     946              : ;; Match 0 to 127.
     947              : (define_predicate "const_0_to_127_operand"
     948         9933 :   (and (match_code "const_int")
     949        18762 :        (match_test "IN_RANGE (INTVAL (op), 0, 127)")))
     950         9933 : 
     951              : ;; Match 0 to 255.
     952              : (define_predicate "const_0_to_255_operand"
     953      8937757 :   (and (match_code "const_int")
     954     17849551 :        (match_test "IN_RANGE (INTVAL (op), 0, 255)")))
     955      8937757 : 
     956              : ;; Match (0 to 255) * 8
     957              : (define_predicate "const_0_to_255_mul_8_operand"
     958       510199 :   (match_code "const_int")
     959              : {
     960       510199 :   unsigned HOST_WIDE_INT val = INTVAL (op);
     961       510199 :   return val <= 255*8 && val % 8 == 0;
     962              : })
     963              : 
     964              : ;; Match 1 to 255 except multiples of 8
     965       510201 : (define_predicate "const_0_to_255_not_mul_8_operand"
     966              :   (match_code "const_int")
     967       510201 : {
     968            9 :   unsigned HOST_WIDE_INT val = INTVAL (op);
     969       918111 :   return val <= 255 && val % 8 != 0;
     970              : })
     971              : 
     972       918125 : ;; Return true if OP is CONST_INT >= 1 and <= 31 (a valid operand
     973       918125 : ;; for shift & compare patterns, as shifting by 0 does not change flags).
     974              : (define_predicate "const_1_to_31_operand"
     975       918125 :   (and (match_code "const_int")
     976       695560 :        (match_test "IN_RANGE (INTVAL (op), 1, 31)")))
     977              : 
     978              : ;; Return true if OP is CONST_INT >= 1 and <= 63 (a valid operand
     979              : ;; for 64bit shift & compare patterns, as shifting by 0 does not change flags).
     980       304572 : (define_predicate "const_1_to_63_operand"
     981              :   (and (match_code "const_int")
     982       304572 :        (match_test "IN_RANGE (INTVAL (op), 1, 63)")))
     983              : 
     984              : ;; Match 2 or 3.
     985              : (define_predicate "const_2_to_3_operand"
     986        73373 :   (and (match_code "const_int")
     987       146746 :        (match_test "IN_RANGE (INTVAL (op), 2, 3)")))
     988        73373 : 
     989              : ;; Match 4 to 5.
     990              : (define_predicate "const_4_to_5_operand"
     991         5339 :   (and (match_code "const_int")
     992        10678 :        (match_test "IN_RANGE (INTVAL (op), 4, 5)")))
     993         5339 : 
     994              : ;; Match 4 to 7.
     995              : (define_predicate "const_4_to_7_operand"
     996      1109537 :   (and (match_code "const_int")
     997      2219074 :        (match_test "IN_RANGE (INTVAL (op), 4, 7)")))
     998      1109537 : 
     999              : ;; Match 6 to 7.
    1000              : (define_predicate "const_6_to_7_operand"
    1001          701 :   (and (match_code "const_int")
    1002         1402 :        (match_test "IN_RANGE (INTVAL (op), 6, 7)")))
    1003          701 : 
    1004              : ;; Match 8 to 9.
    1005              : (define_predicate "const_8_to_9_operand"
    1006          513 :   (and (match_code "const_int")
    1007         1026 :        (match_test "IN_RANGE (INTVAL (op), 8, 9)")))
    1008          513 : 
    1009              : ;; Match 8 to 11.
    1010              : (define_predicate "const_8_to_11_operand"
    1011        35204 :   (and (match_code "const_int")
    1012        70408 :        (match_test "IN_RANGE (INTVAL (op), 8, 11)")))
    1013        35204 : 
    1014              : ;; Match 8 to 15.
    1015              : (define_predicate "const_8_to_15_operand"
    1016        39521 :   (and (match_code "const_int")
    1017        79042 :        (match_test "IN_RANGE (INTVAL (op), 8, 15)")))
    1018        39521 : 
    1019              : ;; Match 10 to 11.
    1020              : (define_predicate "const_10_to_11_operand"
    1021          267 :   (and (match_code "const_int")
    1022          534 :        (match_test "IN_RANGE (INTVAL (op), 10, 11)")))
    1023          267 : 
    1024              : ;; Match 12 to 13.
    1025              : (define_predicate "const_12_to_13_operand"
    1026          266 :   (and (match_code "const_int")
    1027          532 :        (match_test "IN_RANGE (INTVAL (op), 12, 13)")))
    1028          266 : 
    1029              : ;; Match 12 to 15.
    1030              : (define_predicate "const_12_to_15_operand"
    1031        23618 :   (and (match_code "const_int")
    1032        47236 :        (match_test "IN_RANGE (INTVAL (op), 12, 15)")))
    1033        23618 : 
    1034              : ;; Match 14 to 15.
    1035              : (define_predicate "const_14_to_15_operand"
    1036          266 :   (and (match_code "const_int")
    1037          532 :        (match_test "IN_RANGE (INTVAL (op), 14, 15)")))
    1038          266 : 
    1039              : ;; Match 16 to 19.
    1040              : (define_predicate "const_16_to_19_operand"
    1041          927 :   (and (match_code "const_int")
    1042         1854 :        (match_test "IN_RANGE (INTVAL (op), 16, 19)")))
    1043          927 : 
    1044              : ;; Match 16 to 31.
    1045              : (define_predicate "const_16_to_31_operand"
    1046        10187 :   (and (match_code "const_int")
    1047        20374 :        (match_test "IN_RANGE (INTVAL (op), 16, 31)")))
    1048        10187 : 
    1049              : ;; Match 20 to 23.
    1050              : (define_predicate "const_20_to_23_operand"
    1051          532 :   (and (match_code "const_int")
    1052         1064 :        (match_test "IN_RANGE (INTVAL (op), 20, 23)")))
    1053          532 : 
    1054              : ;; Match 24 to 27.
    1055              : (define_predicate "const_24_to_27_operand"
    1056          532 :   (and (match_code "const_int")
    1057         1064 :        (match_test "IN_RANGE (INTVAL (op), 24, 27)")))
    1058          532 : 
    1059              : ;; Match 28 to 31.
    1060              : (define_predicate "const_28_to_31_operand"
    1061          532 :   (and (match_code "const_int")
    1062         1064 :        (match_test "IN_RANGE (INTVAL (op), 28, 31)")))
    1063          532 : 
    1064              : (define_predicate "cmpps_imm_operand"
    1065              :   (ior (match_operand 0 "const_0_to_7_operand")
    1066         4063 :        (and (match_test "TARGET_AVX")
    1067              :             (match_operand 0 "const_0_to_31_operand"))))
    1068        60925 : 
    1069              : ;; True if this is a constant appropriate for an increment or decrement.
    1070    102949525 : (define_predicate "incdec_operand"
    1071              :   (match_code "const_int")
    1072              : {
    1073              :   /* On Pentium4, the inc and dec operations causes extra dependency on flag
    1074              :      registers, since carry flag is not set.  */
    1075    102949525 :   if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
    1076              :     return false;
    1077      2681901 :   return op == const1_rtx || op == constm1_rtx;
    1078              : })
    1079              : 
    1080              : ;; True for registers, or const_int_operand, used to vec_setm expander.
    1081    128487608 : (define_predicate "vec_setm_sse41_operand"
    1082              :   (ior (and (match_operand 0 "register_operand")
    1083    231438011 :             (match_test "TARGET_SSE4_1"))
    1084    102949525 :        (match_code "const_int")))
    1085              : 
    1086              : (define_predicate "vec_setm_avx2_operand"
    1087              :   (ior (and (match_operand 0 "register_operand")
    1088         1049 :             (match_test "TARGET_AVX2"))
    1089            0 :        (match_code "const_int")))
    1090         1353 : 
    1091              : (define_predicate "vec_setm_mmx_operand"
    1092              :   (ior (and (match_operand 0 "register_operand")
    1093           22 :             (match_test "TARGET_SSE4_1")
    1094          260 :             (match_test "TARGET_MMX_WITH_SSE"))
    1095          260 :        (match_code "const_int")))
    1096              : 
    1097              : ;; True for registers, or 1 or -1.  Used to optimize double-word shifts.
    1098              : (define_predicate "reg_or_pm1_operand"
    1099      4461479 :   (ior (match_operand 0 "register_operand")
    1100              :        (and (match_code "const_int")
    1101      4461479 :             (ior (match_test "op == const1_rtx")
    1102       259904 :                  (match_test "op == constm1_rtx")))))
    1103       243559 : 
    1104              : ;; True for expressions valid for 3-operand ternlog instructions.
    1105              : (define_predicate "ternlog_operand"
    1106              :   (and (match_code "not,and,ior,xor")
    1107      2345732 :        (match_test "ix86_ternlog_operand_p (op)")))
    1108       257428 : 
    1109     66665981 : ;; True if OP is acceptable as operand of DImode shift expander.
    1110              : (define_predicate "shiftdi_operand"
    1111      1387587 :   (if_then_else (match_test "TARGET_64BIT")
    1112      3733319 :     (match_operand 0 "nonimmediate_operand")
    1113      2345732 :     (match_operand 0 "register_operand")))
    1114      1387587 : 
    1115      2992636 : (define_predicate "ashldi_input_operand"
    1116       646904 :   (if_then_else (match_test "TARGET_64BIT")
    1117       646904 :     (match_operand 0 "nonimmediate_operand")
    1118              :     (match_operand 0 "reg_or_pm1_operand")))
    1119      2345732 : 
    1120       588003 : ;; Return true if OP is a vector load from the constant pool with just
    1121              : ;; the first element nonzero.
    1122              : (define_predicate "zero_extended_scalar_load_operand"
    1123              :   (match_code "mem")
    1124              : {
    1125       588003 :   unsigned n_elts;
    1126       588003 :   op = avoid_constant_pool_reference (op);
    1127              : 
    1128       588003 :   if (!CONST_VECTOR_P (op))
    1129              :     return false;
    1130              : 
    1131        98696 :   n_elts = CONST_VECTOR_NUNITS (op);
    1132              : 
    1133       194661 :   for (n_elts--; n_elts > 0; n_elts--)
    1134              :     {
    1135       143699 :       rtx elt = CONST_VECTOR_ELT (op, n_elts);
    1136       287398 :       if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
    1137              :         return false;
    1138              :     }
    1139              :   return true;
    1140              : })
    1141              : 
    1142              : /* Return true if operand is a float vector constant that is all ones. */
    1143      1968781 : (define_predicate "float_vector_all_ones_operand"
    1144              :   (match_code "const_vector,mem")
    1145       588003 : {
    1146      2019743 :   mode = GET_MODE (op);
    1147        50962 :   if (!FLOAT_MODE_P (mode)
    1148     13544345 :       || (MEM_P (op)
    1149     11644039 :           && (!SYMBOL_REF_P (XEXP (op, 0))
    1150      1656302 :               || !CONSTANT_POOL_ADDRESS_P (XEXP (op, 0)))))
    1151     16374127 :     return false;
    1152              : 
    1153      3303775 :   if (MEM_P (op))
    1154              :     {
    1155      1403469 :       op = get_pool_constant (XEXP (op, 0));
    1156      1403469 :       if (!CONST_VECTOR_P (op))
    1157              :         return false;
    1158              : 
    1159      1403465 :       if (GET_MODE (op) != mode
    1160         5948 :          && INTEGRAL_MODE_P (GET_MODE (op))
    1161         5948 :          && op == CONSTM1_RTX (GET_MODE (op)))
    1162              :         return true;
    1163              :     }
    1164              : 
    1165      3303771 :   rtx first = XVECEXP (op, 0, 0);
    1166     10759196 :   for (int i = 1; i != GET_MODE_NUNITS (GET_MODE (op)); i++)
    1167              :     {
    1168      4559210 :       rtx tmp = XVECEXP (op, 0, i);
    1169      4559210 :       if (!rtx_equal_p (tmp, first))
    1170              :         return false;
    1171              :     }
    1172       820388 :   if (GET_MODE (first) == E_SFmode)
    1173              :     {
    1174       458167 :       long l;
    1175       458167 :       REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (first), l);
    1176       458167 :       return (l & 0xffffffff) == 0xffffffff;
    1177              :     }
    1178       362221 :   else if (GET_MODE (first) == E_DFmode)
    1179              :     {
    1180       355255 :       long l[2];
    1181       355255 :       REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (first), l);
    1182       355255 :       return ((l[0] & 0xffffffff) == 0xffffffff
    1183       355255 :              && (l[1] & 0xffffffff) == 0xffffffff);
    1184              :     }
    1185              :   else
    1186              :     return false;
    1187              : })
    1188              : 
    1189              : /* Return true if operand is an integral vector constant that is all ones. */
    1190     55943390 : (define_predicate "vector_all_ones_operand"
    1191              :   (and (match_code "const_vector")
    1192     69714888 :        (match_test "INTEGRAL_MODE_P (GET_MODE (op))")
    1193     11936381 :        (match_test "op == CONSTM1_RTX (GET_MODE (op))")))
    1194      1113153 : 
    1195     16374127 : /* Return true if operand is a vector constant that is all ones. */
    1196     16374127 : (define_predicate "int_float_vector_all_ones_operand"
    1197              :   (ior (match_operand 0 "vector_all_ones_operand")
    1198      9119055 :        (match_operand 0 "float_vector_all_ones_operand")
    1199            0 :        (match_test "op == constm1_rtx")))
    1200      9119055 : 
    1201     16374127 : /* Return true if operand is an 128/256bit all ones vector
    1202         3078 :    that zero-extends to 256/512bit.  */
    1203              : (define_predicate "vector_all_ones_zero_extend_half_operand"
    1204     12191049 :   (match_code "const_vector")
    1205              : {
    1206    175986226 :   mode = GET_MODE (op);
    1207     12191049 :   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
    1208    186542624 :       || (GET_MODE_SIZE (mode) != 32
    1209     10248581 :           && GET_MODE_SIZE (mode) != 64))
    1210              :     return false;
    1211              : 
    1212       478353 :   int nelts = CONST_VECTOR_NUNITS (op);
    1213       551996 :   for (int i = 0; i != nelts; i++)
    1214              :     {
    1215       550988 :       rtx elt = CONST_VECTOR_ELT (op, i);
    1216       550988 :       if (i < nelts / 2
    1217      1083159 :           && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
    1218              :         return false;
    1219        84749 :       if (i >= nelts / 2
    1220       103566 :           && elt != CONST0_RTX (GET_MODE_INNER (mode)))
    1221              :         return false;
    1222              :     }
    1223              :   return true;
    1224              : })
    1225              : 
    1226              : /* Return true if operand is an 128bit all ones vector
    1227    177390201 :    that zero extends to 512bit.  */
    1228              : (define_predicate "vector_all_ones_zero_extend_quarter_operand"
    1229     12191049 :   (match_code "const_vector")
    1230    177391209 : {
    1231         1008 :   mode = GET_MODE (op);
    1232     12190041 :   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT
    1233     10555390 :       || GET_MODE_SIZE (mode) != 64)
    1234              :     return false;
    1235     12190041 : 
    1236       170317 :   int nelts = CONST_VECTOR_NUNITS (op);
    1237       184299 :   for (int i = 0; i != nelts; i++)
    1238              :     {
    1239       184207 :       rtx elt = CONST_VECTOR_ELT (op, i);
    1240       184207 :       if (i < nelts / 4
    1241       364860 :           && elt != CONSTM1_RTX (GET_MODE_INNER (mode)))
    1242              :         return false;
    1243        16666 :       if (i >= nelts / 4
    1244        20220 :           && elt != CONST0_RTX (GET_MODE_INNER (mode)))
    1245              :         return false;
    1246              :     }
    1247              :   return true;
    1248              : })
    1249              : 
    1250              : ; Return true when OP is operand acceptable for vector memory operand.
    1251    177389193 : ; Only AVX can have misaligned memory operand.
    1252              : (define_predicate "vector_memory_operand"
    1253     12190041 :   (and (match_operand 0 "memory_operand")
    1254    178481102 :        (ior (match_test "TARGET_AVX")
    1255      1091909 :             (match_test "MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode)"))))
    1256              : 
    1257              : ; Return true when OP is register_operand or vector_memory_operand.
    1258              : (define_predicate "vector_operand"
    1259     20416873 :   (ior (match_operand 0 "register_operand")
    1260              :        (match_operand 0 "vector_memory_operand")))
    1261     20416873 : 
    1262              : ; Return true when OP is register_operand, vector_memory_operand
    1263              : ; or const_vector.
    1264              : (define_predicate "vector_or_const_vector_operand"
    1265        94903 :   (ior (match_operand 0 "register_operand")
    1266              :        (match_operand 0 "vector_memory_operand")
    1267        94903 :        (match_code "const_vector")))
    1268        45320 : 
    1269              : (define_predicate "bcst_mem_operand"
    1270              :   (and (match_code "vec_duplicate")
    1271        14397 :        (and (match_test "TARGET_AVX512F")
    1272    167157075 :             (ior (match_test "TARGET_AVX512VL")
    1273         9064 :                  (match_test "GET_MODE_SIZE (GET_MODE (op)) == 64")))
    1274       151436 :        (match_test "VALID_BCST_MODE_P (GET_MODE_INNER (GET_MODE (op)))")
    1275        13457 :        (match_test "GET_MODE (XEXP (op, 0))
    1276        40360 :                     == GET_MODE_INNER (GET_MODE (op))")
    1277    167171313 :        (match_test "memory_operand (XEXP (op, 0), GET_MODE (XEXP (op, 0)))")))
    1278         5324 : 
    1279              : ; Return true when OP is bcst_mem_operand or vector_memory_operand.
    1280              : (define_predicate "bcst_vector_operand"
    1281              :   (ior (match_operand 0 "vector_operand")
    1282      5398333 :        (match_operand 0 "bcst_mem_operand")))
    1283              : 
    1284      5398333 : ;; Return true when OP is either nonimmediate operand, or any
    1285              : ;; CONST_VECTOR.
    1286              : (define_predicate "nonimmediate_or_const_vector_operand"
    1287              :   (ior (match_operand 0 "nonimmediate_operand")
    1288        93070 :        (match_code "const_vector")))
    1289              : 
    1290        93070 : (define_predicate "nonimmediate_or_const_vec_dup_operand"
    1291        15319 :   (ior (match_operand 0 "nonimmediate_operand")
    1292           46 :        (match_test "const_vec_duplicate_p (op)")))
    1293           46 : 
    1294              : ;; Return true when OP is either register operand, or any
    1295           94 : ;; CONST_VECTOR.
    1296              : (define_predicate "reg_or_const_vector_operand"
    1297           94 :   (ior (match_operand 0 "register_operand")
    1298              :        (match_code "const_vector")))
    1299          275 : 
    1300          173 : ;; Return true when OP is CONST_VECTOR which can be converted to a
    1301              : ;; sign extended 32-bit integer.
    1302              : (define_predicate "x86_64_const_vector_operand"
    1303              :   (match_code "const_vector")
    1304       158528 : {
    1305       158528 :   if (mode == VOIDmode)
    1306            0 :     mode = GET_MODE (op);
    1307       158528 :   else if (GET_MODE (op) != mode)
    1308              :     return false;
    1309       373515 :   if (GET_MODE_SIZE (mode) > UNITS_PER_WORD)
    1310              :     return false;
    1311       115512 :   HOST_WIDE_INT val = ix86_convert_const_vector_to_integer (op, mode);
    1312       115512 :   return trunc_int_for_mode (val, SImode) == val;
    1313              : })
    1314              : 
    1315              : (define_predicate "nonimmediate_or_x86_64_const_vector_operand"
    1316       982139 :   (ior (match_operand 0 "nonimmediate_operand")
    1317              :        (match_operand 0 "x86_64_const_vector_operand")))
    1318       158528 : 
    1319      1063902 : ;; Return true when OP is nonimmediate or standard SSE constant.
    1320        81763 : (define_predicate "nonimmediate_or_sse_const_operand"
    1321              :   (ior (match_operand 0 "nonimmediate_operand")
    1322     25350722 :        (match_test "standard_sse_constant_p (op, mode)")))
    1323      2848901 : 
    1324         6681 : ;; Return true if OP is a register or a zero.
    1325              : (define_predicate "reg_or_0_operand"
    1326         6681 :   (ior (match_operand 0 "register_operand")
    1327       397529 :        (match_operand 0 "const0_operand")))
    1328              : 
    1329       397529 : ; Return true when OP is a nonimmediate or zero.
    1330     95357689 : (define_predicate "nonimm_or_0_operand"
    1331              :   (ior (match_operand 0 "nonimmediate_operand")
    1332    117859510 :        (match_operand 0 "const0_operand")))
    1333    127734580 : 
    1334              : ; Return true when OP is a nonimmediate or zero or all ones.
    1335    127734580 : (define_predicate "nonimm_or_0_or_1s_operand"
    1336              :   (ior (match_operand 0 "nonimmediate_operand")
    1337              :        (match_operand 0 "const0_operand")
    1338              :        (match_operand 0 "int_float_vector_all_ones_operand")))
    1339        82261 : 
    1340              : ;; Return true for RTX codes that force SImode address.
    1341        82261 : (define_predicate "SImode_address_operand"
    1342              :   (match_code "subreg,zero_extend,and"))
    1343              : 
    1344              : ;; Return true if op is a valid address for LEA, and does not contain
    1345    275797950 : ;; a segment override.  Defined as a special predicate to allow
    1346              : ;; mode-less const_int operands pass to address_operand.
    1347    275797950 : (define_special_predicate "address_no_seg_operand"
    1348    183196716 :   (match_test "address_operand (op, VOIDmode)")
    1349     67104977 : {
    1350     67483560 :   struct ix86_address parts;
    1351     67483560 :   int ok;
    1352       378583 : 
    1353     67143257 :   if (!CONST_INT_P (op)
    1354     64175551 :       && mode != VOIDmode
    1355     64175551 :       && GET_MODE (op) != mode)
    1356       378583 :     return false;
    1357       378583 : 
    1358     67104913 :   ok = ix86_decompose_address (op, &parts);
    1359     67104913 :   gcc_assert (ok);
    1360     67104913 :   return parts.seg == ADDR_SPACE_GENERIC;
    1361     67104977 : })
    1362              : 
    1363              : ;; Return true if op if a valid base register, displacement or
    1364    116091739 : ;; sum of base register and displacement for VSIB addressing.
    1365              : (define_predicate "vsib_address_operand"
    1366    116130019 :   (match_test "address_operand (op, VOIDmode)")
    1367        77321 : {
    1368        37570 :   struct ix86_address parts;
    1369        38280 :   int ok;
    1370        38280 :   rtx disp;
    1371              : 
    1372        38280 :   ok = ix86_decompose_address (op, &parts);
    1373        38280 :   gcc_assert (ok);
    1374        64148 :   if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
    1375        25868 :     return false;
    1376              : 
    1377              :   /* VSIB addressing doesn't support (%rip).  */
    1378        38260 :   if (parts.disp)
    1379     26175277 :     {
    1380         6329 :       disp = parts.disp;
    1381         6329 :       if (GET_CODE (disp) == CONST)
    1382              :         {
    1383          148 :           disp = XEXP (disp, 0);
    1384          148 :           if (GET_CODE (disp) == PLUS)
    1385          148 :             disp = XEXP (disp, 0);
    1386          148 :           if (GET_CODE (disp) == UNSPEC)
    1387            0 :             switch (XINT (disp, 1))
    1388              :               {
    1389              :               case UNSPEC_GOTPCREL:
    1390              :               case UNSPEC_PCREL:
    1391              :               case UNSPEC_GOTNTPOFF:
    1392              :                 return false;
    1393              :               }
    1394              :         }
    1395         6329 :       if (TARGET_64BIT
    1396         6329 :           && flag_pic
    1397            0 :           && (SYMBOL_REF_P (disp)
    1398            0 :               || LABEL_REF_P (disp)))
    1399            0 :         return false;
    1400              :     }
    1401              : 
    1402              :   return true;
    1403              : })
    1404              : 
    1405              : (define_predicate "vsib_mem_operator"
    1406        39061 :   (match_code "mem"))
    1407              : 
    1408        39061 : ;; Return true if the rtx is known to be at least 32 bits aligned.
    1409              : (define_predicate "aligned_operand"
    1410              :   (match_operand 0 "general_operand")
    1411              : {
    1412     26175277 :   struct ix86_address parts;
    1413     26175277 :   int ok;
    1414              : 
    1415              :   /* Registers and immediate operands are always "aligned".  */
    1416     26175277 :   if (!MEM_P (op))
    1417              :     return true;
    1418              : 
    1419              :   /* All patterns using aligned_operand on memory operands ends up
    1420              :      in promoting memory operand to 64bit and thus causing memory mismatch.  */
    1421      8263039 :   if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
    1422              :     return false;
    1423              : 
    1424              :   /* Don't even try to do any aligned optimizations with volatiles.  */
    1425       124497 :   if (MEM_VOLATILE_P (op))
    1426              :     return false;
    1427              : 
    1428       118532 :   if (MEM_ALIGN (op) >= 32)
    1429              :     return true;
    1430              : 
    1431        46092 :   op = XEXP (op, 0);
    1432              : 
    1433              :   /* Pushes and pops are only valid on the stack pointer.  */
    1434        46092 :   if (GET_CODE (op) == PRE_DEC
    1435        46092 :       || GET_CODE (op) == POST_INC)
    1436              :     return true;
    1437              : 
    1438              :   /* Decode the address.  */
    1439        46092 :   ok = ix86_decompose_address (op, &parts);
    1440        46092 :   gcc_assert (ok);
    1441              : 
    1442        46092 :   if (parts.base && SUBREG_P (parts.base))
    1443            0 :     parts.base = SUBREG_REG (parts.base);
    1444        46092 :   if (parts.index && SUBREG_P (parts.index))
    1445            0 :     parts.index = SUBREG_REG (parts.index);
    1446              : 
    1447              :   /* Look for some component that isn't known to be aligned.  */
    1448        46092 :   if (parts.index)
    1449              :     {
    1450         3340 :       if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
    1451              :         return false;
    1452              :     }
    1453        42752 :   if (parts.base)
    1454              :     {
    1455        35771 :       if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
    1456              :         return false;
    1457              :     }
    1458        13335 :   if (parts.disp)
    1459              :     {
    1460        13335 :       if (!CONST_INT_P (parts.disp)
    1461         6460 :           || (INTVAL (parts.disp) & 3))
    1462        13037 :         return false;
    1463              :     }
    1464              : 
    1465              :   /* Didn't find one -- this must be an aligned address.  */
    1466              :   return true;
    1467              : })
    1468              : 
    1469              : ;; Return true if OP is memory operand with a displacement.
    1470     26684023 : (define_predicate "memory_displacement_operand"
    1471              :   (match_operand 0 "memory_operand")
    1472     52859300 : {
    1473     26175277 :   struct ix86_address parts;
    1474            0 :   int ok;
    1475              : 
    1476            0 :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1477            0 :   gcc_assert (ok);
    1478            0 :   return parts.disp != NULL_RTX;
    1479              : })
    1480              : 
    1481              : ;; Return true if OP is memory operand with a displacement only.
    1482            0 : (define_predicate "memory_displacement_only_operand"
    1483              :   (match_operand 0 "memory_operand")
    1484            0 : {
    1485            0 :   struct ix86_address parts;
    1486     39688588 :   int ok;
    1487              : 
    1488     39688588 :   if (TARGET_64BIT)
    1489     39688588 :     return false;
    1490              : 
    1491     19119002 :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1492     19119002 :   gcc_assert (ok);
    1493              : 
    1494     19119002 :   if (parts.base || parts.index)
    1495              :     return false;
    1496              : 
    1497       239553 :   return parts.disp != NULL_RTX;
    1498              : })
    1499              : 
    1500              : ;; Return true if OP is memory operand that cannot be represented
    1501     61420385 : ;; by the modRM array.
    1502              : (define_predicate "long_memory_operand"
    1503    101108973 :   (and (match_operand 0 "memory_operand")
    1504     39688588 :        (match_test "memory_address_length (op, false)")))
    1505              : 
    1506              : ;; Return true if OP is a comparison operator that can be issued by fcmov.
    1507              : (define_predicate "fcmov_comparison_operator"
    1508        70177 :   (match_operand 0 "comparison_operator")
    1509              : {
    1510            0 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1511        70177 :   enum rtx_code code = GET_CODE (op);
    1512              : 
    1513        70177 :   if (inmode == CCFPmode)
    1514         9926 :     code = ix86_fp_compare_code_to_integer (code);
    1515              : 
    1516              :   /* i387 supports just limited amount of conditional codes.  */
    1517        70177 :   switch (code)
    1518              :     {
    1519         2414 :     case GEU: case LTU:
    1520         2414 :       if (inmode == CCCmode || inmode == CCGZmode)
    1521              :         return true;
    1522              :       /* FALLTHRU */
    1523         7848 :     case GTU: case LEU:
    1524         7848 :       if (inmode == CCmode || inmode == CCFPmode)
    1525              :         return true;
    1526              :       return false;
    1527              :     case ORDERED: case UNORDERED:
    1528              :     case EQ: case NE:
    1529              :       return true;
    1530              :     default:
    1531              :       return false;
    1532              :     }
    1533              : })
    1534              : 
    1535              : ;; Return true if OP is a comparison that can be used in the CMPSS/CMPPS insns.
    1536        70177 : ;; The first set are supported directly; the second set can't be done with
    1537              : ;; full IEEE support, i.e. NaNs.
    1538       140354 : 
    1539        70177 : (define_predicate "sse_comparison_operator"
    1540              :   (ior (match_code "eq,ne,lt,le,unordered,unge,ungt,ordered")
    1541       402521 :        (and (match_test "TARGET_AVX")
    1542       402521 :             (match_code "ge,gt,uneq,unle,unlt,ltgt"))))
    1543       516667 : 
    1544              : ;; SSE2 doesn't have quiet vector compare for UNLT/UNLE/UNGT/UNGE, so reject
    1545       516667 : ;; them in the packed FP vec_cmp expanders when trapping math is in effect
    1546       105000 : ;; and NaNs are honored
    1547              : 
    1548       105000 : (define_predicate "ix86_fp_vec_cmp_operator"
    1549              :   (and (match_operand 0 "comparison_operator")
    1550              :        (ior (not (match_code "unlt,unle,ungt,unge"))
    1551         8455 :             (match_test "TARGET_AVX")
    1552        15508 :             (not (match_test "flag_trapping_math"))
    1553         7721 :             (not (match_test "HONOR_NANS (GET_MODE (XEXP (op, 0)))")))))
    1554              : 
    1555              : (define_predicate "ix86_comparison_int_operator"
    1556              :   (match_code "ne,eq,ge,gt,le,lt"))
    1557       218048 : 
    1558              : (define_predicate "ix86_comparison_uns_operator"
    1559       218048 :   (match_code "ne,eq,geu,gtu,leu,ltu"))
    1560              : 
    1561       218048 : (define_predicate "bt_comparison_operator"
    1562       218048 :   (match_code "ne,eq"))
    1563       218048 : 
    1564       218048 : (define_predicate "shr_comparison_operator"
    1565       218048 :   (match_code "gtu,leu"))
    1566       218048 : 
    1567       218048 : (define_predicate "add_comparison_operator"
    1568              :   (match_code "geu,ltu"))
    1569              : 
    1570              : (define_predicate "ieee_maxmin_comparison_operator"
    1571       218048 :   (match_code "lt,gt"))
    1572       218048 : 
    1573              : ;; Return true if OP is a valid comparison operator in valid mode.
    1574              : (define_predicate "ix86_comparison_operator"
    1575              :   (match_operand 0 "comparison_operator")
    1576       113932 : {
    1577    101695697 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1578       113932 :   enum rtx_code code = GET_CODE (op);
    1579              : 
    1580    101809629 :   if (inmode == CCFPmode)
    1581      6972795 :     return ix86_trivial_fp_comparison_operator (op, mode);
    1582       113932 : 
    1583     94722902 :   switch (code)
    1584       113932 :     {
    1585     72791858 :     case EQ: case NE:
    1586     72677926 :       if (inmode == CCGZmode)
    1587            0 :         return false;
    1588              :       return true;
    1589      4349092 :     case GE: case LT:
    1590      4349092 :       if (inmode == CCmode || inmode == CCGCmode
    1591      2493994 :           || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
    1592      3837050 :         return true;
    1593              :       return false;
    1594      7741902 :     case GEU: case LTU:
    1595      7741902 :       if (inmode == CCCmode || inmode == CCGZmode)
    1596              :         return true;
    1597     63681983 :       /* FALLTHRU */
    1598     10881689 :     case GTU: case LEU:
    1599     10881689 :       if (inmode == CCmode)
    1600      9651325 :         return true;
    1601     52409939 :       return false;
    1602         3520 :     case ORDERED: case UNORDERED:
    1603         3520 :       if (inmode == CCmode)
    1604         3337 :         return true;
    1605     52409939 :       return false;
    1606     52409939 :     case GT: case LE:
    1607      6307205 :       if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
    1608      5529375 :         return true;
    1609              :       return false;
    1610       834232 :     default:
    1611              :       return false;
    1612       834232 :     }
    1613              : })
    1614       834232 : 
    1615       834232 : ;; Return true if OP is a valid comparison operator
    1616    117356701 : ;; testing carry flag to be set.
    1617              : (define_predicate "ix86_carry_flag_operator"
    1618    218218166 :   (match_code "ltu,unlt")
    1619    101695697 : {
    1620      1724248 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1621       834232 :   enum rtx_code code = GET_CODE (op);
    1622              : 
    1623       890016 :   if (inmode == CCFPmode)
    1624        14883 :     code = ix86_fp_compare_code_to_integer (code);
    1625      1364020 :   else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
    1626              :     return false;
    1627      1364020 : 
    1628       696518 :   return code == LTU;
    1629      1364020 : })
    1630      1364020 : 
    1631      1364020 : ;; Return true if OP is a valid comparison operator
    1632      3755349 : ;; testing carry flag to be unset.
    1633              : (define_predicate "ix86_carry_flag_unset_operator"
    1634      3755349 :   (match_code "geu,ge")
    1635      1364020 : {
    1636      1364020 :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1637       892395 :   enum rtx_code code = GET_CODE (op);
    1638       890016 : 
    1639         2379 :   if (inmode == CCFPmode)
    1640           93 :     code = ix86_fp_compare_code_to_integer (code);
    1641              :   else if (inmode != CCmode && inmode != CCCmode && inmode != CCGZmode)
    1642         1346 :     return false;
    1643       890016 : 
    1644       438294 :   return code == GEU;
    1645         1346 : })
    1646         1346 : 
    1647              : ;; Return true if this comparison only requires testing one flag bit.
    1648      2606881 : ;; VCOMX/VUCOMX set ZF, SF, OF, differently from COMI/UCOMI.
    1649              : (define_predicate "ix86_trivial_fp_comparison_operator"
    1650     12092621 :   (if_then_else (match_test "TARGET_AVX10_2")
    1651       674884 :                 (match_code "gt,ge,unlt,unle,eq,uneq,ne,ltgt,ordered,unordered")
    1652         2379 :                 (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered")))
    1653         2379 : 
    1654         2379 : (define_predicate "ix86_trivial_fp_comparison_operator_xf"
    1655    103075577 :   (match_code "gt,ge,unlt,unle,uneq,ltgt,ordered,unordered"))
    1656              : 
    1657      1379880 : ;; Return true if we know how to do this comparison.  Others require
    1658         2379 : ;; testing more than one flag bit, and we let the generic middle-end
    1659       415353 : ;; code do that.
    1660       414736 : (define_predicate "ix86_fp_comparison_operator"
    1661      2928298 :   (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
    1662      2928298 :                              == IX86_FPCMP_ARITH")
    1663       412974 :                (match_operand 0 "comparison_operator")
    1664      9901093 :                (match_operand 0 "ix86_trivial_fp_comparison_operator")))
    1665       412974 : 
    1666      9901093 : (define_predicate "ix86_fp_comparison_operator_xf"
    1667      1792854 :   (if_then_else (match_test "ix86_fp_comparison_strategy (GET_CODE (op))
    1668      1379880 :                              == IX86_FPCMP_ARITH")
    1669              :                (match_operand 0 "comparison_operator")
    1670              :                (match_operand 0 "ix86_trivial_fp_comparison_operator_xf")))
    1671       412974 : 
    1672       850738 : ;; Return true if we can perform this comparison on TImode operands.
    1673              : (define_predicate "ix86_timode_comparison_operator"
    1674       437764 :   (if_then_else (match_test "TARGET_64BIT")
    1675              :                 (match_operand 0 "ordered_comparison_operator")
    1676      2515324 :                 (match_operand 0 "bt_comparison_operator")))
    1677              : 
    1678      2515324 : ;; Return true if this is a valid second operand for a TImode comparison.
    1679              : (define_predicate "ix86_timode_comparison_operand"
    1680       157686 :   (if_then_else (match_test "TARGET_64BIT")
    1681              :                 (match_operand 0 "x86_64_general_operand")
    1682              :                 (match_operand 0 "nonimmediate_operand")))
    1683              : 
    1684      2047434 : ;; Nearly general operand, but accept any const_double, since we wish
    1685              : ;; to be able to drop them into memory rather than have them get pulled
    1686       518961 : ;; into registers.
    1687      2566395 : (define_predicate "cmp_fp_expander_operand"
    1688              :   (ior (match_code "const_double")
    1689              :        (match_operand 0 "general_operand")))
    1690              : 
    1691      5012001 : ;; Return true if this is a valid binary floating-point operation.
    1692              : (define_predicate "binary_fp_operator"
    1693      5012001 :   (match_code "plus,minus,mult,div"))
    1694              : 
    1695      5002898 : ;; Return true if this is a multiply operation.
    1696      5002898 : (define_predicate "mult_operator"
    1697      5002898 :   (match_code "mult"))
    1698      5002898 : 
    1699      5002898 : ;; Return true if this is a division operation.
    1700              : (define_predicate "div_operator"
    1701              :   (match_code "div"))
    1702              : 
    1703      5002898 : ;; Return true if this is an and, ior or xor operation.
    1704      5002898 : (define_predicate "logic_operator"
    1705              :   (match_code "and,ior,xor"))
    1706              : 
    1707              : ;; Return true if this is an and operation.
    1708     17140219 : (define_predicate "and_operator"
    1709              :   (match_code "and"))
    1710     17140219 : 
    1711      3457147 : ;; Return true if this is a plus, minus, and, ior or xor operation.
    1712              : (define_predicate "plusminuslogic_operator"
    1713              :   (match_code "plus,minus,and,ior,xor"))
    1714              : 
    1715      2772029 : ;; Return true for ARITHMETIC_P.
    1716              : (define_predicate "arith_or_logical_operator"
    1717      2772029 :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax,compare,minus,div,
    1718       958005 :                mod,udiv,umod,ashift,rotate,ashiftrt,lshiftrt,rotatert"))
    1719              : 
    1720              : ;; Return true for COMMUTATIVE_P.
    1721              : (define_predicate "commutative_operator"
    1722            0 :   (match_code "plus,mult,and,ior,xor,smin,smax,umin,umax"))
    1723              : 
    1724            0 : ;; Return true if OP is a binary operator that can be promoted to wider mode.
    1725              : (define_predicate "promotable_binary_operator"
    1726            0 :   (ior (match_code "plus,minus,and,ior,xor,ashift")
    1727            0 :        (and (match_code "mult")
    1728     25738785 :             (match_test "TARGET_TUNE_PROMOTE_HIMODE_IMUL"))))
    1729            0 : 
    1730              : (define_predicate "compare_operator"
    1731              :   (match_code "compare"))
    1732              : 
    1733      7612611 : (define_predicate "extract_high_operator"
    1734            0 :   (match_code "zero_extract,sign_extract,ashiftrt,lshiftrt")
    1735      7612611 : {
    1736            0 :   return (const8_operand (XEXP (op, 1), VOIDmode)
    1737       144867 :           && (BINARY_P (op) || const8_operand (XEXP (op, 2), VOIDmode)));
    1738          100 : })
    1739              : 
    1740       144967 : ;; Return true if OP is a memory operand, aligned to
    1741            0 : ;; less than its natural alignment.
    1742              : (define_predicate "misaligned_operand"
    1743       144867 :   (and (match_code "mem")
    1744      6326649 :        (match_test "MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)")))
    1745      1602907 : 
    1746       144867 : ;; Return true if OP is a parallel for an mov{d,q,dqa,ps,pd} vec_select,
    1747       545435 : ;; where one of the two operands of the vec_concat is const0_operand.
    1748       144867 : (define_predicate "movq_parallel"
    1749      2105877 :   (match_code "parallel")
    1750       540836 : {
    1751      1961010 :   unsigned nelt = XVECLEN (op, 0);
    1752      1961010 :   unsigned nelt2 = nelt >> 1;
    1753      2105877 :   unsigned i;
    1754       144867 : 
    1755      1475004 :   if (nelt < 2)
    1756              :     return false;
    1757              : 
    1758       540836 :   /* Validate that all of the elements are constants,
    1759       540836 :      lower halves of permute are lower halves of the first operand,
    1760              :      upper halves of permute come from any of the second operand.  */
    1761     15848615 :   for (i = 0; i < nelt; ++i)
    1762              :     {
    1763      6860720 :       rtx er = XVECEXP (op, 0, i);
    1764      2482774 :       unsigned HOST_WIDE_INT ei;
    1765      4377946 : 
    1766      2482774 :       if (!CONST_INT_P (er))
    1767      4377946 :         return false;
    1768      6860720 :       ei = INTVAL (er);
    1769      2482774 :       if (i < nelt2 && ei != i)
    1770      4377946 :         return false;
    1771      1221653 :       if (i >= nelt2 && (ei < nelt || ei >= nelt << 1))
    1772      4377946 :         return false;
    1773      4377946 :     }
    1774      4377946 : 
    1775      4377946 :   return true;
    1776      4377946 : })
    1777      4377946 : 
    1778      4377946 : ;; Return true if OP is a vzeroall operation, known to be a PARALLEL.
    1779      5798120 : (define_predicate "vzeroall_operation"
    1780      4377946 :   (match_code "parallel")
    1781      7218294 : {
    1782      1420193 :   unsigned i, nregs = TARGET_64BIT ? 16 : 8;
    1783            0 : 
    1784         3896 :   if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
    1785      4377946 :     return false;
    1786      4377946 : 
    1787        69976 :   for (i = 0; i < nregs; i++)
    1788              :     {
    1789        62184 :       rtx elt = XVECEXP (op, 0, i+1);
    1790              : 
    1791      4440130 :       if (GET_CODE (elt) != SET
    1792      4440130 :           || GET_CODE (SET_DEST (elt)) != REG
    1793        62184 :           || GET_MODE (SET_DEST (elt)) != V8SImode
    1794        62184 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    1795       124368 :           || SET_SRC (elt) != CONST0_RTX (V8SImode))
    1796       994155 :         return false;
    1797              :     }
    1798       994155 :   return true;
    1799              : })
    1800       339150 : 
    1801       339150 : ;; return true if OP is a vzeroall pattern.
    1802       343046 : (define_predicate "vzeroall_pattern"
    1803       339150 :   (and (match_code "parallel")
    1804       346942 :        (match_code "unspec_volatile" "a")
    1805         4009 :        (match_test "XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROALL")))
    1806            0 : 
    1807       339150 : ;; return true if OP is a vzeroupper pattern.
    1808       339150 : (define_predicate "vzeroupper_pattern"
    1809       339150 :   (and (match_code "parallel")
    1810      4242109 :        (match_code "unspec" "b")
    1811         4642 :        (match_test "XINT (XVECEXP (op, 0, 1), 1) == UNSPEC_CALLEE_ABI")
    1812      4242109 :        (match_test "INTVAL (XVECEXP (XVECEXP (op, 0, 1), 0, 0)) == ABI_VZEROUPPER")))
    1813            0 : 
    1814       339150 : ;; Return true if OP is an addsub vec_merge operation
    1815              : (define_predicate "addsub_vm_operator"
    1816              :   (match_code "vec_merge")
    1817         8485 : {
    1818     25747270 :   rtx op0, op1;
    1819         8485 :   int swapped;
    1820     25738785 :   HOST_WIDE_INT mask;
    1821         8485 :   int nunits, elt;
    1822              : 
    1823         8485 :   op0 = XEXP (op, 0);
    1824         8485 :   op1 = XEXP (op, 1);
    1825              : 
    1826              :   /* Sanity check.  */
    1827         8485 :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1828              :     swapped = 0;
    1829         4328 :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1830              :     swapped = 1;
    1831              :   else
    1832            0 :     gcc_unreachable ();
    1833              : 
    1834         8485 :   mask = INTVAL (XEXP (op, 2));
    1835         8485 :   nunits = GET_MODE_NUNITS (mode);
    1836              : 
    1837        32835 :   for (elt = 0; elt < nunits; elt++)
    1838              :     {
    1839              :       /* bit clear: take from op0, set: take from op1  */
    1840        24593 :       int bit = !(mask & (HOST_WIDE_INT_1U << elt));
    1841              : 
    1842        24593 :       if (bit != ((elt & 1) ^ swapped))
    1843              :         return false;
    1844              :     }
    1845              : 
    1846              :   return true;
    1847              : })
    1848              : 
    1849              : ;; Return true if OP is an addsub vec_select/vec_concat operation
    1850         8485 : (define_predicate "addsub_vs_operator"
    1851              :   (and (match_code "vec_select")
    1852         8485 :        (match_code "vec_concat" "0"))
    1853        16727 : {
    1854         8242 :   rtx op0, op1;
    1855            0 :   bool swapped;
    1856            0 :   int nunits, elt;
    1857              : 
    1858            0 :   op0 = XEXP (XEXP (op, 0), 0);
    1859            0 :   op1 = XEXP (XEXP (op, 0), 1);
    1860              : 
    1861              :   /* Sanity check.  */
    1862            0 :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    1863              :     swapped = false;
    1864            0 :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    1865              :     swapped = true;
    1866              :   else
    1867            0 :     gcc_unreachable ();
    1868              : 
    1869            0 :   nunits = GET_MODE_NUNITS (mode);
    1870            0 :   if (XVECLEN (XEXP (op, 1), 0) != nunits)
    1871              :     return false;
    1872              : 
    1873              :   /* We already checked that permutation is suitable for addsub,
    1874              :      so only look at the first element of the parallel.  */
    1875            0 :   elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
    1876              : 
    1877            0 :   return elt == (swapped ? nunits : 0);
    1878              : })
    1879              : 
    1880              : ;; Return true if OP is a parallel for an addsub vec_select.
    1881            0 : (define_predicate "addsub_vs_parallel"
    1882              :   (and (match_code "parallel")
    1883            0 :        (match_code "const_int" "a"))
    1884            0 : {
    1885            0 :   int nelt = XVECLEN (op, 0);
    1886          492 :   int elt, i;
    1887              : 
    1888          492 :   if (nelt < 2)
    1889          492 :     return false;
    1890              : 
    1891              :   /* Check that the permutation is suitable for addsub.
    1892              :      For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }.  */
    1893          492 :   elt = INTVAL (XVECEXP (op, 0, 0));
    1894          492 :   if (elt == 0)
    1895              :     {
    1896          446 :       for (i = 1; i < nelt; ++i)
    1897          438 :         if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
    1898              :           return false;
    1899              :     }
    1900           54 :   else if (elt == nelt)
    1901              :     {
    1902            0 :       for (i = 1; i < nelt; ++i)
    1903            0 :         if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
    1904              :           return false;
    1905              :     }
    1906              :   else
    1907              :     return false;
    1908              : 
    1909              :   return true;
    1910              : })
    1911              : 
    1912              : ;; Return true if OP is a constant pool in perm{w,d,b} which contains index
    1913          492 : ;; match pmov{dw,wb,qd}.
    1914              : (define_predicate "permvar_truncate_operand"
    1915          492 :  (match_code "mem")
    1916          984 : {
    1917            0 :   int nelt = GET_MODE_NUNITS (mode);
    1918           16 :   int perm[128];
    1919           16 :   int id;
    1920              : 
    1921           32 :   if (!INTEGRAL_MODE_P (mode) || !VECTOR_MODE_P (mode))
    1922              :     return false;
    1923              : 
    1924           16 :   if (nelt < 2)
    1925              :     return false;
    1926              : 
    1927           16 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1928              :     return false;
    1929              : 
    1930           16 :   id = exact_log2 (nelt);
    1931              : 
    1932              :   /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
    1933              :      For example V16HImode to V8HImode
    1934              :      { 0 2 4 6 8 10 12 14 * * * * * * * * }.  */
    1935          232 :   for (int i = 0; i != nelt / 2; i++)
    1936          216 :     if ((perm[i] & ((1 << id) - 1)) != i * 2)
    1937              :       return false;
    1938              : 
    1939              :   return true;
    1940              : })
    1941              : 
    1942              : ;; Return true if OP is a constant pool in shufb which contains index
    1943           49 : ;; match pmovdw.
    1944              : (define_predicate "pshufb_truncv4siv4hi_operand"
    1945           16 :  (match_code "mem")
    1946           65 : {
    1947           16 :   int perm[128];
    1948              : 
    1949            8 :   if (mode != E_V16QImode)
    1950              :     return false;
    1951            8 : 
    1952            8 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1953              :     return false;
    1954              : 
    1955              :   /* Check that the permutation is suitable for pmovdw.
    1956              :      For example V4SImode to V4HImode
    1957              :      { 0 1 4 5 8 9 12 13 * * * * * * * * }.
    1958              :      index = i % 2 + (i / 2) * 4.  */
    1959           58 :   for (int i = 0; i != 8; i++)
    1960              :     {
    1961              :       /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0;  */
    1962           52 :       if (perm[i] & 128)
    1963              :         return false;
    1964              : 
    1965           52 :       if ((perm[i] & 15) != ((i & 1) + (i & 0xFE) * 2))
    1966              :         return false;
    1967              :      }
    1968              : 
    1969              :   return true;
    1970              : })
    1971              : 
    1972              : ;; Return true if OP is a constant pool in shufb which contains index
    1973           11 : ;; match pmovdw.
    1974              : (define_predicate "pshufb_truncv8hiv8qi_operand"
    1975            8 :  (match_code "mem")
    1976           17 : {
    1977            6 :   int perm[128];
    1978              : 
    1979           11 :   if (mode != E_V16QImode)
    1980              :     return false;
    1981           11 : 
    1982           11 :   if (!ix86_extract_perm_from_pool_constant (&perm[0], op))
    1983              :     return false;
    1984              : 
    1985              :   /* Check that the permutation is suitable for pmovwb.
    1986              :      For example V16QImode to V8QImode
    1987              :      { 0 2 4 6 8 10 12 14 * * * * * * * * }.
    1988              :      index = i % 2 + (i / 2) * 4.  */
    1989           57 :   for (int i = 0; i != 8; i++)
    1990              :     {
    1991              :       /* if (SRC2[(i * 8)+7] = 1) then DEST[(i*8)+7..(i*8)+0] := 0;  */
    1992           52 :       if (perm[i] & 128)
    1993              :         return false;
    1994              : 
    1995           52 :       if ((perm[i] & 15) != i * 2)
    1996              :          return false;
    1997              :     }
    1998              : 
    1999              :   return true;
    2000              : })
    2001              : 
    2002              : ;; Return true if OP is a parallel for an pmovz{bw,wd,dq} vec_select,
    2003           14 : ;; where one of the two operands of the vec_concat is const0_operand.
    2004              : (define_predicate "pmovzx_parallel"
    2005           11 :   (and (match_code "parallel")
    2006           19 :        (match_code "const_int" "a"))
    2007            5 : {
    2008      1491533 :   int nelt = XVECLEN (op, 0);
    2009      1491533 :   int elt, i;
    2010              : 
    2011      1491533 :   if (nelt < 2)
    2012              :     return false;
    2013              : 
    2014              :   /* Check that the permutation is suitable for pmovz{bw,wd,dq}.
    2015              :      For example { 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23 }.  */
    2016      1491531 :   elt = INTVAL (XVECEXP (op, 0, 0));
    2017      1491531 :   if (elt == 0)
    2018              :     {
    2019      3448698 :       for (i = 1; i < nelt; ++i)
    2020      2958357 :         if ((i & 1) != 0)
    2021              :           {
    2022      1895946 :             if (INTVAL (XVECEXP (op, 0, i)) < nelt)
    2023              :               return false;
    2024              :           }
    2025      1062411 :         else if (INTVAL (XVECEXP (op, 0, i)) != i / 2)
    2026              :           return false;
    2027              :     }
    2028              :   else
    2029              :     return false;
    2030              : 
    2031              :   return true;
    2032              : })
    2033              : 
    2034              : ;; Return true if OP is a parallel for an insertps vec_select,
    2035      1491533 : ;; where one of the two operands of the vec_concat is const0_operand.
    2036              : (define_predicate "insertps_parallel"
    2037      1491533 :   (and (match_code "parallel")
    2038      2983066 :        (match_code "const_int" "a"))
    2039            0 : {
    2040        12632 :   int i;
    2041              : 
    2042        12632 :   if (XVECLEN (op, 0) != 4)
    2043        12632 :     return false;
    2044              : 
    2045              :   /* One element in [0..3], and the other 3 in [4..7].  */
    2046              :   bool found = false;
    2047        40817 :   for (i = 0; i < 4; ++i)
    2048        39216 :     if (INTVAL (XVECEXP (op, 0, i)) < 4)
    2049              :       {
    2050        23663 :         if (found)
    2051              :           return false;
    2052              :         found = true;
    2053              :       }
    2054              : 
    2055              :   return found;
    2056              : })
    2057              : 
    2058              : ;; Return true if OP is a const vector with duplicate value.
    2059        12632 : (define_predicate "const_vector_duplicate_operand"
    2060              :   (match_code "const_vector")
    2061        12632 : {
    2062        25264 :   rtx elt = XVECEXP (op, 0, 0);
    2063            0 :   int i, nelt = XVECLEN (op, 0);
    2064              : 
    2065           96 :   for (i = 1; i < nelt; ++i)
    2066           93 :     if (!rtx_equal_p (elt, XVECEXP (op, 0, i)))
    2067            3 :       return false;
    2068              :   return true;
    2069              : })
    2070              : 
    2071              : ;; Return true if OP is a parallel for a vbroadcast permute.
    2072            3 : (define_predicate "avx_vbroadcast_operand"
    2073              :   (and (match_code "parallel")
    2074            3 :        (match_code "const_int" "a"))
    2075            6 : {
    2076            3 :   rtx elt = XVECEXP (op, 0, 0);
    2077       392192 :   int i, nelt = XVECLEN (op, 0);
    2078              : 
    2079              :   /* Don't bother checking there are the right number of operands,
    2080       392192 :      merely that they're all identical.  */
    2081       496661 :   for (i = 1; i < nelt; ++i)
    2082       281032 :     if (XVECEXP (op, 0, i) != elt)
    2083              :       return false;
    2084              :   return true;
    2085              : })
    2086              : 
    2087              : ;; Return true if OP is a parallel for a vbroadcastf128 permute.
    2088       392192 : (define_predicate "avx_vbroadcast128_operand"
    2089              :   (and (match_code "parallel")
    2090       392192 :        (match_code "const_int" "a"))
    2091       784384 : {
    2092            0 :   int i, nelt = XVECLEN (op, 0);
    2093      1408574 :   int half = nelt / 2;
    2094              : 
    2095      2347981 :   for (i = 0; i < nelt; ++i)
    2096      1408574 :     {
    2097      2347831 :       int index = INTVAL (XVECEXP (op, 0, i));
    2098      2347831 :       if ((i < half && index != i)
    2099      1097927 :           || (i >= half && index != (i - half)))
    2100              :         return false;
    2101              :     }
    2102              : 
    2103              :   return true;
    2104              : })
    2105              : 
    2106              : ;; Return true if OP is a parallel for a palignr permute.
    2107      1408574 : (define_predicate "palignr_operand"
    2108              :   (and (match_code "parallel")
    2109      1408574 :        (match_code "const_int" "a"))
    2110      2817148 : {
    2111            0 :   int elt = INTVAL (XVECEXP (op, 0, 0));
    2112        27137 :   int i, nelt = XVECLEN (op, 0);
    2113              : 
    2114              :   /* Check that an order in the permutation is suitable for palignr.
    2115        27137 :      For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm".  */
    2116        63406 :   for (i = 1; i < nelt; ++i)
    2117        59029 :     if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
    2118              :       return false;
    2119              :   return true;
    2120              : })
    2121              : 
    2122              : ;; Return true if OP is a proper third operand to vpblendw256.
    2123        27137 : (define_predicate "avx2_pblendw_operand"
    2124              :   (match_code "const_int")
    2125        27137 : {
    2126        54274 :   HOST_WIDE_INT val = INTVAL (op);
    2127            0 :   HOST_WIDE_INT low = val & 0xff;
    2128         7033 :   return val == ((low << 8) | low);
    2129              : })
    2130              : 
    2131         7033 : ;; Return true if OP is vector_operand or CONST_VECTOR.
    2132         7033 : (define_predicate "general_vector_operand"
    2133              :   (ior (match_operand 0 "vector_operand")
    2134         7033 :        (match_code "const_vector")))
    2135         7033 : 
    2136              : ;; Return true if OP is either -1 constant or stored in register.
    2137              : (define_predicate "register_or_constm1_operand"
    2138              :   (ior (match_operand 0 "register_operand")
    2139        13096 :        (and (match_code "const_int")
    2140            0 :             (match_test "op == constm1_rtx"))))
    2141        13096 : 
    2142         2440 : ;; Return true if the vector ends with between 12 and 18 register saves using
    2143              : ;; RAX as the base address.
    2144              : (define_predicate "save_multiple"
    2145       228417 :   (match_code "parallel")
    2146         1324 : {
    2147       228417 :   const unsigned len = XVECLEN (op, 0);
    2148         1324 :   unsigned i;
    2149              : 
    2150              :   /* Starting from end of vector, count register saves.  */
    2151       321126 :   for (i = 0; i < len; ++i)
    2152              :     {
    2153       321126 :       rtx src, dest, addr;
    2154       321126 :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2155              : 
    2156       321126 :       if (GET_CODE (e) != SET)
    2157              :         break;
    2158              : 
    2159       314081 :       src  = SET_SRC (e);
    2160       314081 :       dest = SET_DEST (e);
    2161              : 
    2162       314081 :       if (!REG_P (src) || !MEM_P (dest))
    2163              :         break;
    2164              : 
    2165        92709 :       addr = XEXP (dest, 0);
    2166              : 
    2167              :       /* Good if dest address is in RAX.  */
    2168        92709 :       if (REG_P (addr) && REGNO (addr) == AX_REG)
    2169         4202 :         continue;
    2170              : 
    2171              :       /* Good if dest address is offset of RAX.  */
    2172       177014 :       if (GET_CODE (addr) == PLUS
    2173        88507 :           && REG_P (XEXP (addr, 0))
    2174       177014 :           && REGNO (XEXP (addr, 0)) == AX_REG)
    2175        88507 :         continue;
    2176              : 
    2177              :       break;
    2178              :     }
    2179       228417 :   return (i >= 12 && i <= 18);
    2180              : })
    2181              : 
    2182              : 
    2183       228417 : ;; Return true if the vector ends with between 12 and 18 register loads using
    2184              : ;; RSI as the base address.
    2185       456834 : (define_predicate "restore_multiple"
    2186       228417 :   (match_code "parallel")
    2187            0 : {
    2188      7926693 :   const unsigned len = XVECLEN (op, 0);
    2189      7926693 :   unsigned i;
    2190              : 
    2191      7926693 :   /* Starting from end of vector, count register restores.  */
    2192      8033021 :   for (i = 0; i < len; ++i)
    2193              :     {
    2194      8033021 :       rtx src, dest, addr;
    2195      8033021 :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2196              : 
    2197      8033021 :       if (GET_CODE (e) != SET)
    2198              :         break;
    2199              : 
    2200      4504878 :       src  = SET_SRC (e);
    2201      4504878 :       dest = SET_DEST (e);
    2202              : 
    2203      4504878 :       if (!MEM_P (src) || !REG_P (dest))
    2204              :         break;
    2205              : 
    2206      1387323 :       addr = XEXP (src, 0);
    2207              : 
    2208              :       /* Good if src address is in RSI.  */
    2209      1387323 :       if (REG_P (addr) && REGNO (addr) == SI_REG)
    2210         5129 :         continue;
    2211              : 
    2212              :       /* Good if src address is offset of RSI.  */
    2213      1483393 :       if (GET_CODE (addr) == PLUS
    2214       941849 :           && REG_P (XEXP (addr, 0))
    2215      2258429 :           && REGNO (XEXP (addr, 0)) == SI_REG)
    2216       101199 :         continue;
    2217              : 
    2218              :       break;
    2219              :     }
    2220      7926693 :   return (i >= 12 && i <= 18);
    2221              : })
    2222              : 
    2223              : ;; Keylocker specific predicates
    2224      7926693 : (define_predicate "encodekey128_operation"
    2225              :   (match_code "parallel")
    2226     15853386 : {
    2227      7926693 :   unsigned i;
    2228            0 :   rtx elt;
    2229              : 
    2230          108 :   if (XVECLEN (op, 0) != 8)
    2231              :     return false;
    2232          108 : 
    2233          392 :   for(i = 0; i < 3; i++)
    2234              :     {
    2235          294 :       elt = XVECEXP (op, 0, i + 1);
    2236          294 :       if (GET_CODE (elt) != SET
    2237          294 :           || GET_CODE (SET_DEST (elt)) != REG
    2238          294 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2239          294 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2240          294 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2241          294 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2242          294 :           || XVECLEN(SET_SRC (elt), 0) != 1
    2243          588 :           || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
    2244              :         return false;
    2245              :     }
    2246              : 
    2247          392 :   for(i = 4; i < 7; i++)
    2248              :     {
    2249          294 :       elt = XVECEXP (op, 0, i);
    2250          294 :       if (GET_CODE (elt) != CLOBBER
    2251          294 :           || GET_MODE (elt) != VOIDmode
    2252          294 :           || GET_CODE (XEXP (elt, 0)) != REG
    2253          294 :           || GET_MODE (XEXP (elt, 0)) != V2DImode
    2254          588 :           || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
    2255              :         return false;
    2256              :     }
    2257              : 
    2258           98 :   elt = XVECEXP (op, 0, 7);
    2259           98 :   if (GET_CODE (elt) != CLOBBER
    2260           98 :       || GET_MODE (elt) != VOIDmode
    2261           98 :       || GET_CODE (XEXP (elt, 0)) != REG
    2262           98 :       || GET_MODE (XEXP (elt, 0)) != CCmode
    2263          196 :       || REGNO (XEXP (elt, 0)) != FLAGS_REG)
    2264            0 :     return false;
    2265              :   return true;
    2266              : })
    2267              : 
    2268              : (define_predicate "encodekey256_operation"
    2269          108 :   (match_code "parallel")
    2270              : {
    2271          337 :   unsigned i;
    2272          108 :   rtx elt;
    2273            0 : 
    2274          121 :   if (XVECLEN (op, 0) != 9)
    2275              :     return false;
    2276              : 
    2277          121 :   elt = SET_SRC (XVECEXP (op, 0, 0));
    2278          112 :   elt = XVECEXP (elt, 0, 2);
    2279          112 :   if (!REG_P (elt)
    2280          112 :       || REGNO(elt) != GET_SSE_REGNO (1))
    2281              :     return false;
    2282              : 
    2283          560 :   for(i = 0; i < 4; i++)
    2284              :     {
    2285          448 :       elt = XVECEXP (op, 0, i + 1);
    2286          448 :       if (GET_CODE (elt) != SET
    2287          448 :           || GET_CODE (SET_DEST (elt)) != REG
    2288          448 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2289          448 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2290          448 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2291          448 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2292          448 :           || XVECLEN(SET_SRC (elt), 0) != 1
    2293          896 :           || XVECEXP(SET_SRC (elt), 0, 0) != const0_rtx)
    2294              :         return false;
    2295              :     }
    2296              : 
    2297          448 :   for(i = 4; i < 7; i++)
    2298              :     {
    2299          336 :       elt = XVECEXP (op, 0, i + 1);
    2300          336 :       if (GET_CODE (elt) != CLOBBER
    2301          336 :           || GET_MODE (elt) != VOIDmode
    2302          336 :           || GET_CODE (XEXP (elt, 0)) != REG
    2303          336 :           || GET_MODE (XEXP (elt, 0)) != V2DImode
    2304          672 :           || REGNO (XEXP (elt, 0)) != GET_SSE_REGNO (i))
    2305              :         return false;
    2306              :     }
    2307              : 
    2308          112 :   elt = XVECEXP (op, 0, 8);
    2309          112 :   if (GET_CODE (elt) != CLOBBER
    2310          112 :       || GET_MODE (elt) != VOIDmode
    2311          112 :       || GET_CODE (XEXP (elt, 0)) != REG
    2312          112 :       || GET_MODE (XEXP (elt, 0)) != CCmode
    2313          224 :       || REGNO (XEXP (elt, 0)) != FLAGS_REG)
    2314            0 :     return false;
    2315              :   return true;
    2316              : })
    2317              : 
    2318              : 
    2319          121 : (define_predicate "aeswidekl_operation"
    2320              :   (match_code "parallel")
    2321          242 : {
    2322          121 :   unsigned i;
    2323            0 :   rtx elt;
    2324              : 
    2325         5796 :   for (i = 0; i < 8; i++)
    2326              :     {
    2327          660 :       elt = XVECEXP (op, 0, i + 1);
    2328         5168 :       if (GET_CODE (elt) != SET
    2329         5168 :           || GET_CODE (SET_DEST (elt)) != REG
    2330         5168 :           || GET_MODE (SET_DEST (elt)) != V2DImode
    2331         5168 :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2332         5168 :           || GET_CODE (SET_SRC (elt)) != UNSPEC_VOLATILE
    2333         5168 :           || GET_MODE (SET_SRC (elt)) != V2DImode
    2334         5168 :           || XVECLEN (SET_SRC (elt), 0) != 1
    2335         5168 :           || !REG_P (XVECEXP (SET_SRC (elt), 0, 0))
    2336        10304 :           || REGNO (XVECEXP (SET_SRC (elt), 0, 0)) != GET_SSE_REGNO (i))
    2337              :         return false;
    2338              :     }
    2339              :   return true;
    2340              : })
    2341              : 
    2342              : ;; Return true if OP is a memory operand that can be also used in APX
    2343          660 : ;; EVEX-encoded patterns (i.e. APX NDD/NF) with immediate operand.  With
    2344              : ;; non-default address space, segment register or address size prefix,
    2345         1320 : ;; APX EVEX-encoded instruction length can exceed the 15 byte size limit.
    2346          660 : (define_predicate "apx_evex_memory_operand"
    2347            0 :   (match_operand 0 "memory_operand")
    2348              : {
    2349              :   /* OK if immediate operand size < 4 bytes.  */
    2350         1686 :   if (GET_MODE_SIZE (mode) < 4)
    2351         1686 :     return true;
    2352              : 
    2353         1527 :   bool default_addr = ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (op));
    2354         1695 :   bool address_size_prefix = TARGET_X32 && Pmode == SImode;
    2355              : 
    2356         1527 :   struct ix86_address parts;
    2357         1527 :   int ok;
    2358              : 
    2359         1527 :   op = XEXP (op, 0);
    2360         1527 :   ok = ix86_decompose_address (op, &parts);
    2361         1527 :   gcc_assert (ok);
    2362              : 
    2363         1527 :   if (default_addr)
    2364              :     {
    2365              :       /* Default address space.  */
    2366              : 
    2367              :       /* Not OK with address size prefix, index register and disp.  */
    2368          691 :       if (address_size_prefix
    2369          168 :           && parts.index
    2370           42 :           && parts.disp
    2371           42 :           && parts.disp != const0_rtx)
    2372           42 :         return false;
    2373              :     }
    2374              :   else
    2375              :     {
    2376              :       /* Non-default address space.  */
    2377              : 
    2378              :       /* Not OK without base register.  */
    2379          836 :       if (!parts.base)
    2380              :         return false;
    2381              : 
    2382              :       /* Not OK with disp and address size prefix.  */
    2383          668 :       if (address_size_prefix && parts.disp)
    2384            0 :         return false;
    2385              :     }
    2386              : 
    2387              :   return true;
    2388              : })
    2389              : 
    2390              : ;; Return true if OP is a memory operand which can be used in APX EVEX-encoded
    2391         1806 : ;; ADD patterns (i.e. APX NDD/NF) for with register source operand.
    2392              : ;; UNSPEC_GOTNTPOFF memory operand is allowed with APX EVEX-encoded ADD only if
    2393         3492 : ;; R_X86_64_CODE_6_GOTTPOFF works.
    2394         1686 : (define_predicate "apx_evex_add_memory_operand"
    2395              :   (match_operand 0 "memory_operand")
    2396              : {
    2397              :   /* OK if "add %reg1, name@gottpoff(%rip), %reg2" or
    2398              :    "{nf} add name@gottpoff(%rip), %reg1" are supported.  */
    2399              :   if (HAVE_AS_R_X86_64_CODE_6_GOTTPOFF)
    2400              :     return true;
    2401              : 
    2402              :   op = XEXP (op, 0);
    2403              : 
    2404              :   /* Disallow APX EVEX-encoded ADD with UNSPEC_GOTNTPOFF.  */
    2405              :   if (GET_CODE (op) == CONST
    2406              :       && GET_CODE (XEXP (op, 0)) == UNSPEC
    2407              :       && XINT (XEXP (op, 0), 1) == UNSPEC_GOTNTPOFF)
    2408              :     return false;
    2409              : 
    2410              :   return true;
    2411              : })
    2412              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2413              : /* (content generated from coverage data) */
    2414          848 : /* BEGIN: function "_Z27apx_evex_add_memory_operandP7rtx_def12machine_mode" */
    2415              : /* ... */
    2416          848 : /* ... */
    2417          848 : /* ... */
    2418              : /* END: function "_Z27apx_evex_add_memory_operandP7rtx_def12machine_mode" */
    2419              : /* ... */
    2420              : /* ... */
    2421   1011280090 : /* BEGIN: function "_Z19lookup_constraint_1PKc" */
    2422              : /* ... */
    2423   1011280090 : /* ... */
    2424              : /* ... */
    2425              : /* ... */
    2426              : /* ... */
    2427            0 : /* ... */
    2428            0 : /* ... */
    2429            0 : /* ... */
    2430            0 : /* ... */
    2431            0 : /* ... */
    2432            0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2433    597216877 : /* (content generated from coverage data) */
    2434    597216877 : /* ... */
    2435              : /* ... */
    2436              : /* ... */
    2437      8640824 : /* ... */
    2438              : /* ... */
    2439    136428649 : /* ... */
    2440              : /* ... */
    2441       137478 : /* ... */
    2442              : /* ... */
    2443      1721782 : /* ... */
    2444              : /* ... */
    2445      1402851 : /* ... */
    2446              : /* ... */
    2447     57184414 : /* ... */
    2448              : /* ... */
    2449     52147303 : /* ... */
    2450              : /* ... */
    2451    102017165 : /* ... */
    2452              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2453     40203422 : /* (content generated from coverage data) */
    2454              : /* ... */
    2455    121183987 : /* ... */
    2456              : /* ... */
    2457     76148175 : /* ... */
    2458              : /* ... */
    2459          827 : /* ... */
    2460              : /* ... */
    2461            0 : /* ... */
    2462            0 : /* ... */
    2463            0 : /* ... */
    2464            0 : /* ... */
    2465            0 : /* ... */
    2466            0 : /* ... */
    2467            0 : /* ... */
    2468            0 : /* ... */
    2469            0 : /* ... */
    2470            0 : /* ... */
    2471            0 : /* ... */
    2472            0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2473            0 : /* (content generated from coverage data) */
    2474            0 : /* ... */
    2475            0 : /* ... */
    2476            0 : /* ... */
    2477            0 : /* ... */
    2478            0 : /* ... */
    2479            0 : /* ... */
    2480            0 : /* ... */
    2481            0 : /* ... */
    2482            0 : /* ... */
    2483            0 : /* ... */
    2484            0 : /* ... */
    2485            0 : /* ... */
    2486            0 : /* ... */
    2487            0 : /* ... */
    2488            0 : /* ... */
    2489            0 : /* ... */
    2490            0 : /* ... */
    2491     40946102 : /* ... */
    2492     40946102 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2493              : /* (content generated from coverage data) */
    2494        23352 : /* ... */
    2495              : /* ... */
    2496              : /* ... */
    2497            0 : /* ... */
    2498            0 : /* ... */
    2499            0 : /* ... */
    2500            0 : /* ... */
    2501      3388483 : /* ... */
    2502      3388483 : /* ... */
    2503              : /* ... */
    2504              : /* ... */
    2505         5554 : /* ... */
    2506              : /* ... */
    2507       342572 : /* ... */
    2508              : /* ... */
    2509      2655709 : /* ... */
    2510              : /* ... */
    2511       299802 : /* ... */
    2512              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2513         1418 : /* (content generated from coverage data) */
    2514              : /* ... */
    2515          240 : /* ... */
    2516              : /* ... */
    2517         5121 : /* ... */
    2518              : /* ... */
    2519            0 : /* ... */
    2520            0 : /* ... */
    2521    360964246 : /* ... */
    2522    360964246 : /* ... */
    2523              : /* ... */
    2524              : /* ... */
    2525      5662139 : /* ... */
    2526              : /* ... */
    2527      4062141 : /* ... */
    2528              : /* ... */
    2529      1383959 : /* ... */
    2530              : /* ... */
    2531      1399200 : /* ... */
    2532              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2533        19926 : /* (content generated from coverage data) */
    2534              : /* ... */
    2535    197521686 : /* ... */
    2536              : /* ... */
    2537      1190865 : /* ... */
    2538              : /* ... */
    2539    142827522 : /* ... */
    2540              : /* ... */
    2541      3184013 : /* ... */
    2542              : /* ... */
    2543      2457793 : /* ... */
    2544              : /* ... */
    2545      1226778 : /* ... */
    2546              : /* ... */
    2547            0 : /* ... */
    2548            0 : /* ... */
    2549            0 : /* ... */
    2550            0 : /* ... */
    2551            0 : /* ... */
    2552            0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2553            0 : /* (content generated from coverage data) */
    2554            0 : /* ... */
    2555            0 : /* ... */
    2556            0 : /* ... */
    2557            0 : /* ... */
    2558            0 : /* ... */
    2559            0 : /* ... */
    2560            0 : /* ... */
    2561            0 : /* ... */
    2562            0 : /* ... */
    2563      8764382 : /* ... */
    2564      8764382 : /* ... */
    2565              : /* ... */
    2566              : /* ... */
    2567            0 : /* ... */
    2568              : /* ... */
    2569            0 : /* ... */
    2570              : /* ... */
    2571            0 : /* ... */
    2572              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2573            0 : /* (content generated from coverage data) */
    2574              : /* ... */
    2575            0 : /* ... */
    2576              : /* ... */
    2577       223760 : /* ... */
    2578              : /* ... */
    2579         8292 : /* ... */
    2580              : /* ... */
    2581      6230605 : /* ... */
    2582              : /* ... */
    2583       159298 : /* ... */
    2584              : /* ... */
    2585       271942 : /* ... */
    2586              : /* ... */
    2587         3543 : /* ... */
    2588              : /* ... */
    2589       513357 : /* ... */
    2590              : /* ... */
    2591            0 : /* ... */
    2592            0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2593            0 : /* (content generated from coverage data) */
    2594            0 : /* ... */
    2595            0 : /* ... */
    2596            0 : /* ... */
    2597            0 : /* ... */
    2598            0 : /* ... */
    2599            0 : /* ... */
    2600            0 : /* ... */
    2601            0 : /* ... */
    2602            0 : /* ... */
    2603            0 : /* ... */
    2604            0 : /* ... */
    2605            0 : /* ... */
    2606            0 : /* ... */
    2607            0 : /* ... */
    2608            0 : /* ... */
    2609            0 : /* ... */
    2610            0 : /* ... */
    2611            0 : /* ... */
    2612            0 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2613            0 : /* (content generated from coverage data) */
    2614            0 : /* ... */
    2615            0 : /* ... */
    2616            0 : /* ... */
    2617            0 : /* ... */
    2618            0 : /* ... */
    2619              : /* ... */
    2620              : /* ... */
    2621         1337 : /* ... */
    2622              : /* END: function "_Z19lookup_constraint_1PKc" */
    2623              : /* ... */
    2624              : /* ... */
    2625              : /* ... */
    2626              : /* ... */
    2627              : /* ... */
    2628              : /* ... */
    2629              : /* ... */
    2630              : /* ... */
    2631              : /* ... */
    2632              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2633              : /* (content generated from coverage data) */
    2634              : /* ... */
    2635              : /* ... */
    2636              : /* ... */
    2637              : /* ... */
    2638              : /* ... */
    2639              : /* ... */
    2640              : /* ... */
    2641              : /* ... */
    2642              : /* ... */
    2643              : /* ... */
    2644              : /* ... */
    2645              : /* ... */
    2646              : /* ... */
    2647              : /* ... */
    2648              : /* ... */
    2649              : /* ... */
    2650              : /* ... */
    2651              : /* ... */
    2652              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2653              : /* (content generated from coverage data) */
    2654              : /* ... */
    2655              : /* ... */
    2656              : /* ... */
    2657              : /* ... */
    2658              : /* ... */
    2659              : /* ... */
    2660              : /* ... */
    2661              : /* ... */
    2662              : /* ... */
    2663              : /* ... */
    2664              : /* ... */
    2665              : /* ... */
    2666              : /* ... */
    2667              : /* ... */
    2668              : /* ... */
    2669              : /* ... */
    2670              : /* ... */
    2671              : /* ... */
    2672              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2673              : /* (content generated from coverage data) */
    2674              : /* ... */
    2675              : /* ... */
    2676              : /* ... */
    2677              : /* ... */
    2678              : /* ... */
    2679              : /* ... */
    2680              : /* ... */
    2681              : /* ... */
    2682              : /* ... */
    2683              : /* ... */
    2684              : /* ... */
    2685              : /* ... */
    2686              : /* ... */
    2687              : /* ... */
    2688              : /* ... */
    2689              : /* ... */
    2690              : /* ... */
    2691              : /* ... */
    2692              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2693              : /* (content generated from coverage data) */
    2694              : /* ... */
    2695              : /* ... */
    2696              : /* ... */
    2697              : /* ... */
    2698              : /* ... */
    2699              : /* ... */
    2700              : /* ... */
    2701              : /* ... */
    2702              : /* ... */
    2703              : /* ... */
    2704              : /* ... */
    2705              : /* ... */
    2706              : /* ... */
    2707              : /* ... */
    2708              : /* ... */
    2709              : /* ... */
    2710              : /* ... */
    2711              : /* ... */
    2712              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2713              : /* (content generated from coverage data) */
    2714              : /* ... */
    2715              : /* ... */
    2716              : /* ... */
    2717              : /* ... */
    2718              : /* ... */
    2719              : /* ... */
    2720              : /* ... */
    2721              : /* ... */
    2722              : /* ... */
    2723              : /* ... */
    2724              : /* ... */
    2725              : /* ... */
    2726              : /* ... */
    2727              : /* ... */
    2728              : /* ... */
    2729              : /* ... */
    2730              : /* ... */
    2731              : /* ... */
    2732              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2733              : /* (content generated from coverage data) */
    2734              : /* ... */
    2735              : /* ... */
    2736              : /* ... */
    2737              : /* ... */
    2738              : /* ... */
    2739              : /* ... */
    2740              : /* ... */
    2741              : /* ... */
    2742              : /* ... */
    2743              : /* ... */
    2744              : /* ... */
    2745              : /* ... */
    2746              : /* ... */
    2747              : /* ... */
    2748              : /* ... */
    2749              : /* ... */
    2750              : /* ... */
    2751              : /* ... */
    2752              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2753              : /* (content generated from coverage data) */
    2754              : /* ... */
    2755              : /* ... */
    2756              : /* ... */
    2757              : /* ... */
    2758              : /* ... */
    2759              : /* ... */
    2760              : /* ... */
    2761              : /* ... */
    2762              : /* ... */
    2763              : /* ... */
    2764              : /* ... */
    2765              : /* ... */
    2766              : /* ... */
    2767              : /* ... */
    2768              : /* ... */
    2769              : /* ... */
    2770              : /* ... */
    2771              : /* ... */
    2772              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2773              : /* (content generated from coverage data) */
    2774              : /* ... */
    2775              : /* ... */
    2776              : /* ... */
    2777              : /* ... */
    2778              : /* ... */
    2779              : /* ... */
    2780              : /* ... */
    2781              : /* ... */
    2782              : /* ... */
    2783              : /* ... */
    2784              : /* ... */
    2785              : /* ... */
    2786              : /* ... */
    2787              : /* ... */
    2788              : /* ... */
    2789              : /* ... */
    2790              : /* ... */
    2791              : /* ... */
    2792              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2793              : /* (content generated from coverage data) */
    2794              : /* ... */
    2795              : /* ... */
    2796              : /* ... */
    2797              : /* ... */
    2798              : /* ... */
    2799              : /* ... */
    2800              : /* ... */
    2801              : /* ... */
    2802              : /* ... */
    2803              : /* ... */
    2804              : /* ... */
    2805              : /* ... */
    2806              : /* ... */
    2807              : /* ... */
    2808              : /* ... */
    2809              : /* ... */
    2810              : /* ... */
    2811              : /* ... */
    2812              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2813              : /* (content generated from coverage data) */
    2814              : /* ... */
    2815              : /* ... */
    2816              : /* ... */
    2817              : /* ... */
    2818              : /* ... */
    2819              : /* ... */
    2820              : /* ... */
    2821              : /* ... */
    2822              : /* ... */
    2823              : /* ... */
    2824              : /* ... */
    2825              : /* ... */
    2826              : /* ... */
    2827              : /* ... */
    2828              : /* ... */
    2829              : /* ... */
    2830              : /* ... */
    2831              : /* ... */
    2832              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2833              : /* (content generated from coverage data) */
    2834              : /* ... */
    2835              : /* ... */
    2836              : /* ... */
    2837              : /* ... */
    2838              : /* ... */
    2839              : /* ... */
    2840              : /* ... */
    2841              : /* ... */
    2842              : /* ... */
    2843              : /* ... */
    2844              : /* ... */
    2845              : /* ... */
    2846              : /* ... */
    2847              : /* ... */
    2848              : /* ... */
    2849              : /* ... */
    2850              : /* ... */
    2851              : /* ... */
    2852              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2853              : /* (content generated from coverage data) */
    2854              : /* ... */
    2855              : /* ... */
    2856              : /* ... */
    2857              : /* ... */
    2858              : /* ... */
    2859              : /* ... */
    2860              : /* ... */
    2861              : /* ... */
    2862              : /* ... */
    2863              : /* ... */
    2864              : /* ... */
    2865              : /* ... */
    2866              : /* ... */
    2867              : /* ... */
    2868              : /* ... */
    2869              : /* ... */
    2870              : /* ... */
    2871              : /* ... */
    2872              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2873              : /* (content generated from coverage data) */
    2874              : /* ... */
    2875              : /* ... */
    2876              : /* ... */
    2877              : /* ... */
    2878              : /* ... */
    2879              : /* ... */
    2880              : /* ... */
    2881              : /* ... */
    2882              : /* ... */
    2883              : /* ... */
    2884   7432392204 : /* BEGIN: function "_Z26reg_class_for_constraint_114constraint_num" */
    2885              : /* ... */
    2886   7432392204 : /* ... */
    2887              : /* ... */
    2888              : /* ... */
    2889              : /* ... */
    2890    138747013 : /* ... */
    2891              : /* ... */
    2892     54637075 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2893     23976153 : /* (content generated from coverage data) */
    2894              : /* ... */
    2895     25088101 : /* ... */
    2896     10075775 : /* ... */
    2897       776358 : /* ... */
    2898       978567 : /* ... */
    2899       821673 : /* ... */
    2900      1418311 : /* ... */
    2901    219051601 : /* ... */
    2902        81699 : /* ... */
    2903         8637 : /* ... */
    2904       928688 : /* ... */
    2905     45360487 : /* ... */
    2906    673492642 : /* ... */
    2907    243189555 : /* ... */
    2908   1517617704 : /* ... */
    2909        14330 : /* ... */
    2910      5661690 : /* ... */
    2911      4061709 : /* ... */
    2912      1327476 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2913            0 : /* (content generated from coverage data) */
    2914      1399196 : /* ... */
    2915        14123 : /* ... */
    2916    186842524 : /* ... */
    2917       326374 : /* ... */
    2918    142543808 : /* ... */
    2919      2787091 : /* ... */
    2920      2324941 : /* ... */
    2921       138524 : /* ... */
    2922      6229378 : /* ... */
    2923              : /* ... */
    2924              : /* ... */
    2925              : /* ... */
    2926              : /* END: function "_Z26reg_class_for_constraint_114constraint_num" */
    2927              : /* ... */
    2928              : /* ... */
    2929              : /* ... */
    2930              : /* ... */
    2931              : /* ... */
    2932              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2933              : /* (content generated from coverage data) */
    2934              : /* ... */
    2935              : /* ... */
    2936              : /* ... */
    2937              : /* ... */
    2938              : /* ... */
    2939              : /* ... */
    2940              : /* ... */
    2941              : /* ... */
    2942              : /* ... */
    2943              : /* ... */
    2944              : /* ... */
    2945              : /* ... */
    2946              : /* ... */
    2947              : /* ... */
    2948              : /* ... */
    2949              : /* ... */
    2950              : /* ... */
    2951              : /* ... */
    2952              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2953              : /* (content generated from coverage data) */
    2954              : /* ... */
    2955              : /* ... */
    2956              : /* ... */
    2957              : /* ... */
    2958              : /* ... */
    2959              : /* ... */
    2960              : /* ... */
    2961              : /* ... */
    2962              : /* ... */
    2963              : /* ... */
    2964              : /* ... */
    2965              : /* ... */
    2966              : /* ... */
    2967              : /* ... */
    2968              : /* ... */
    2969              : /* ... */
    2970              : /* ... */
    2971              : /* ... */
    2972              : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2973              : /* (content generated from coverage data) */
    2974              : /* ... */
    2975              : /* ... */
    2976              : /* ... */
    2977              : /* ... */
    2978              : /* ... */
    2979              : /* ... */
    2980              : /* ... */
    2981              : /* ... */
    2982              : /* ... */
    2983              : /* ... */
    2984              : /* ... */
    2985              : /* ... */
    2986              : /* ... */
    2987              : /* ... */
    2988              : /* ... */
    2989              : /* ... */
    2990      7361713 : /* END: function "_Z32insn_const_int_ok_for_constraintl14constraint_num" */
    2991              : /* ... */
    2992      7361713 : /* /home/worker/buildworker/tiber-lcov/build/gcc/config/i386/predicates.md not long enough */
    2993              : /* (content generated from coverage data) */
    2994      1384233 : /* ... */
    2995      1384233 : /* ... */
        

Generated by: LCOV version 2.5.0-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.