LCOV - code coverage report
Current view: top level - objdir/gcc - insn-preds.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2 2 100.0 %
Date: 2020-03-28 11:57:23 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Generated automatically by the program 'build/genpreds'
       2                 :            :    from the machine description file '../../gcc/config/i386/i386.md'.  */
       3                 :            : 
       4                 :            : #define IN_TARGET_CODE 1
       5                 :            : #include "config.h"
       6                 :            : #include "system.h"
       7                 :            : #include "coretypes.h"
       8                 :            : #include "backend.h"
       9                 :            : #include "predict.h"
      10                 :            : #include "tree.h"
      11                 :            : #include "rtl.h"
      12                 :            : #include "alias.h"
      13                 :            : #include "varasm.h"
      14                 :            : #include "stor-layout.h"
      15                 :            : #include "calls.h"
      16                 :            : #include "memmodel.h"
      17                 :            : #include "tm_p.h"
      18                 :            : #include "insn-config.h"
      19                 :            : #include "recog.h"
      20                 :            : #include "output.h"
      21                 :            : #include "flags.h"
      22                 :            : #include "df.h"
      23                 :            : #include "resource.h"
      24                 :            : #include "diagnostic-core.h"
      25                 :            : #include "reload.h"
      26                 :            : #include "regs.h"
      27                 :            : #include "emit-rtl.h"
      28                 :            : #include "tm-constrs.h"
      29                 :            : #include "target.h"
      30                 :            : 
      31                 :            : int
      32                 :   79882000 : any_fp_register_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      33                 :            : {
      34                 :   79882000 :   return ((GET_CODE (op) == REG) && (
      35                 :            : #line 23 "../../gcc/config/i386/predicates.md"
      36                 :            : (ANY_FP_REGNO_P (REGNO (op))))) && (
      37                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
      38                 :            : }
      39                 :            : 
      40                 :            : int
      41                 :            : fp_register_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      42                 :            : {
      43                 :            :   return ((GET_CODE (op) == REG) && (
      44                 :            : #line 28 "../../gcc/config/i386/predicates.md"
      45                 :            : (STACK_REGNO_P (REGNO (op))))) && (
      46                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
      47                 :            : }
      48                 :            : 
      49                 :            : int
      50                 :            : general_reg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      51                 :            : {
      52                 :            :   return ((GET_CODE (op) == REG) && (
      53                 :            : #line 33 "../../gcc/config/i386/predicates.md"
      54                 :            : (GENERAL_REGNO_P (REGNO (op))))) && (
      55                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
      56                 :            : }
      57                 :            : 
      58                 :            : int
      59                 :            : nonimmediate_gr_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      60                 :            : {
      61                 :            :   return (GET_CODE (op) == REG) ? ((
      62                 :            : #line 38 "../../gcc/config/i386/predicates.md"
      63                 :            : (GENERAL_REGNO_P (REGNO (op)))) && (
      64                 :            : (mode == VOIDmode || GET_MODE (op) == mode))) : (nonimmediate_operand (op, mode));
      65                 :            : }
      66                 :            : 
      67                 :            : int
      68                 :            : general_gr_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      69                 :            : {
      70                 :            :   return (GET_CODE (op) == REG) ? ((
      71                 :            : #line 44 "../../gcc/config/i386/predicates.md"
      72                 :            : (GENERAL_REGNO_P (REGNO (op)))) && (
      73                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode))) : (general_operand (op, mode));
      74                 :            : }
      75                 :            : 
      76                 :            : int
      77                 :            : mmx_reg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      78                 :            : {
      79                 :            :   return ((GET_CODE (op) == REG) && (
      80                 :            : #line 50 "../../gcc/config/i386/predicates.md"
      81                 :            : (MMX_REGNO_P (REGNO (op))))) && (
      82                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
      83                 :            : }
      84                 :            : 
      85                 :            : int
      86                 :            : register_mmxmem_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      87                 :            : {
      88                 :            :   return (register_operand (op, mode)) || ((!(
      89                 :            : #line 56 "../../gcc/config/i386/predicates.md"
      90                 :            : (TARGET_MMX_WITH_SSE))) && (memory_operand (op, mode)));
      91                 :            : }
      92                 :            : 
      93                 :            : int
      94                 :            : sse_reg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
      95                 :            : {
      96                 :            :   return ((GET_CODE (op) == REG) && (
      97                 :            : #line 62 "../../gcc/config/i386/predicates.md"
      98                 :            : (SSE_REGNO_P (REGNO (op))))) && (
      99                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     100                 :            : }
     101                 :            : 
     102                 :            : int
     103                 :            : any_QIreg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     104                 :            : {
     105                 :            :   return ((GET_CODE (op) == REG) && (
     106                 :            : #line 67 "../../gcc/config/i386/predicates.md"
     107                 :            : (ANY_QI_REGNO_P (REGNO (op))))) && (
     108                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     109                 :            : }
     110                 :            : 
     111                 :            : int
     112                 :            : QIreg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     113                 :            : {
     114                 :            :   return ((GET_CODE (op) == REG) && (
     115                 :            : #line 72 "../../gcc/config/i386/predicates.md"
     116                 :            : (QI_REGNO_P (REGNO (op))))) && (
     117                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     118                 :            : }
     119                 :            : 
     120                 :            : int
     121                 :            : ext_QIreg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     122                 :            : {
     123                 :            :   return ((
     124                 :            : #line 76 "../../gcc/config/i386/predicates.md"
     125                 :            : (TARGET_64BIT)) && ((GET_CODE (op) == REG) && (!(
     126                 :            : #line 78 "../../gcc/config/i386/predicates.md"
     127                 :            : (QI_REGNO_P (REGNO (op))))))) && (
     128                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     129                 :            : }
     130                 :            : 
     131                 :            : int
     132                 :            : ax_reg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     133                 :            : {
     134                 :            :   return ((GET_CODE (op) == REG) && (
     135                 :            : #line 83 "../../gcc/config/i386/predicates.md"
     136                 :            : (REGNO (op) == AX_REG))) && (
     137                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     138                 :            : }
     139                 :            : 
     140                 :            : int
     141                 :            : flags_reg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     142                 :            : {
     143                 :            :   return ((GET_CODE (op) == REG) && (
     144                 :            : #line 88 "../../gcc/config/i386/predicates.md"
     145                 :            : (REGNO (op) == FLAGS_REG))) && (
     146                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     147                 :            : }
     148                 :            : 
     149                 :            : int
     150                 :            : ext_register_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     151                 :            : {
     152                 :            :   return (register_operand (op, mode)) && (((
     153                 :            : #line 93 "../../gcc/config/i386/predicates.md"
     154                 :            : (TARGET_64BIT)) && (
     155                 :            : #line 94 "../../gcc/config/i386/predicates.md"
     156                 :            : (GET_MODE (op) == DImode))) || ((
     157                 :            : #line 95 "../../gcc/config/i386/predicates.md"
     158                 :            : (GET_MODE (op) == SImode)) || (
     159                 :            : #line 96 "../../gcc/config/i386/predicates.md"
     160                 :            : (GET_MODE (op) == HImode))));
     161                 :            : }
     162                 :            : 
     163                 :            : int
     164                 :            : int_nonimmediate_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     165                 :            : {
     166                 :            :   return (nonimmediate_operand (op, mode)) && (((
     167                 :            : #line 101 "../../gcc/config/i386/predicates.md"
     168                 :            : (TARGET_64BIT)) && (
     169                 :            : #line 102 "../../gcc/config/i386/predicates.md"
     170                 :            : (GET_MODE (op) == DImode))) || ((
     171                 :            : #line 103 "../../gcc/config/i386/predicates.md"
     172                 :            : (GET_MODE (op) == SImode)) || ((
     173                 :            : #line 104 "../../gcc/config/i386/predicates.md"
     174                 :            : (GET_MODE (op) == HImode)) || (
     175                 :            : #line 105 "../../gcc/config/i386/predicates.md"
     176                 :            : (GET_MODE (op) == QImode)))));
     177                 :            : }
     178                 :            : 
     179                 :            : int
     180                 :            : register_ssemem_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     181                 :            : {
     182                 :            :   return (
     183                 :            : #line 110 "../../gcc/config/i386/predicates.md"
     184                 :            : (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)) ? (nonimmediate_operand (op, mode)) : (register_operand (op, mode));
     185                 :            : }
     186                 :            : 
     187                 :            : int
     188                 :            : nonimm_ssenomem_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     189                 :            : {
     190                 :            :   return ((
     191                 :            : #line 118 "../../gcc/config/i386/predicates.md"
     192                 :            : (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)) && (!(
     193                 :            : #line 119 "../../gcc/config/i386/predicates.md"
     194                 :            : (TARGET_MIX_SSE_I387)))) ? (register_operand (op, mode)) : (nonimmediate_operand (op, mode));
     195                 :            : }
     196                 :            : 
     197                 :            : int
     198                 :            : x87nonimm_ssenomem_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     199                 :            : {
     200                 :            :   return ((
     201                 :            : #line 126 "../../gcc/config/i386/predicates.md"
     202                 :            : (SSE_FLOAT_MODE_P (mode) && TARGET_SSE_MATH)) && (!(
     203                 :            : #line 127 "../../gcc/config/i386/predicates.md"
     204                 :            : (TARGET_MIX_SSE_I387 && X87_ENABLE_ARITH (mode))))) ? (register_operand (op, mode)) : (nonimmediate_operand (op, mode));
     205                 :            : }
     206                 :            : 
     207                 :            : int
     208                 :            : register_sse4nonimm_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     209                 :            : {
     210                 :            :   return (
     211                 :            : #line 133 "../../gcc/config/i386/predicates.md"
     212                 :            : (TARGET_SSE4_1)) ? (nonimmediate_operand (op, mode)) : (register_operand (op, mode));
     213                 :            : }
     214                 :            : 
     215                 :            : int
     216                 :            : symbol_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     217                 :            : {
     218                 :            :   return (GET_CODE (op) == SYMBOL_REF) && (
     219                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     220                 :            : }
     221                 :            : 
     222                 :            : static inline int
     223                 :            : x86_64_immediate_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     224                 :            : #line 144 "../../gcc/config/i386/predicates.md"
     225                 :            : {
     226                 :            :   if (!TARGET_64BIT)
     227                 :            :     return immediate_operand (op, mode);
     228                 :            : 
     229                 :            :   switch (GET_CODE (op))
     230                 :            :     {
     231                 :            :     case CONST_INT:
     232                 :            :       {
     233                 :            :         HOST_WIDE_INT val = INTVAL (op);
     234                 :            :         return trunc_int_for_mode (val, SImode) == val;
     235                 :            :       }
     236                 :            :     case SYMBOL_REF:
     237                 :            :       /* TLS symbols are not constant.  */
     238                 :            :       if (SYMBOL_REF_TLS_MODEL (op))
     239                 :            :         return false;
     240                 :            : 
     241                 :            :       /* Load the external function address via the GOT slot.  */
     242                 :            :       if (ix86_force_load_from_GOT_p (op))
     243                 :            :         return false;
     244                 :            : 
     245                 :            :       /* For certain code models, the symbolic references are known to fit.
     246                 :            :          in CM_SMALL_PIC model we know it fits if it is local to the shared
     247                 :            :          library.  Don't count TLS SYMBOL_REFs here, since they should fit
     248                 :            :          only if inside of UNSPEC handled below.  */
     249                 :            :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_KERNEL
     250                 :            :               || (ix86_cmodel == CM_MEDIUM && !SYMBOL_REF_FAR_ADDR_P (op)));
     251                 :            : 
     252                 :            :     case LABEL_REF:
     253                 :            :       /* For certain code models, the code is near as well.  */
     254                 :            :       return (ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM
     255                 :            :               || ix86_cmodel == CM_KERNEL);
     256                 :            : 
     257                 :            :     case CONST:
     258                 :            :       /* We also may accept the offsetted memory references in certain
     259                 :            :          special cases.  */
     260                 :            :       if (GET_CODE (XEXP (op, 0)) == UNSPEC)
     261                 :            :         switch (XINT (XEXP (op, 0), 1))
     262                 :            :           {
     263                 :            :           case UNSPEC_GOTPCREL:
     264                 :            :           case UNSPEC_DTPOFF:
     265                 :            :           case UNSPEC_GOTNTPOFF:
     266                 :            :           case UNSPEC_NTPOFF:
     267                 :            :             return true;
     268                 :            :           default:
     269                 :            :             break;
     270                 :            :           }
     271                 :            : 
     272                 :            :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     273                 :            :         {
     274                 :            :           rtx op1 = XEXP (XEXP (op, 0), 0);
     275                 :            :           rtx op2 = XEXP (XEXP (op, 0), 1);
     276                 :            : 
     277                 :            :           if (ix86_cmodel == CM_LARGE && GET_CODE (op1) != UNSPEC)
     278                 :            :             return false;
     279                 :            :           if (!CONST_INT_P (op2))
     280                 :            :             return false;
     281                 :            : 
     282                 :            :           HOST_WIDE_INT offset = INTVAL (op2);
     283                 :            :           if (trunc_int_for_mode (offset, SImode) != offset)
     284                 :            :             return false;
     285                 :            : 
     286                 :            :           switch (GET_CODE (op1))
     287                 :            :             {
     288                 :            :             case SYMBOL_REF:
     289                 :            :               /* TLS symbols are not constant.  */
     290                 :            :               if (SYMBOL_REF_TLS_MODEL (op1))
     291                 :            :                 return false;
     292                 :            : 
     293                 :            :               /* Load the external function address via the GOT slot.  */
     294                 :            :               if (ix86_force_load_from_GOT_p (op1))
     295                 :            :                 return false;
     296                 :            : 
     297                 :            :               /* For CM_SMALL assume that latest object is 16MB before
     298                 :            :                  end of 31bits boundary.  We may also accept pretty
     299                 :            :                  large negative constants knowing that all objects are
     300                 :            :                  in the positive half of address space.  */
     301                 :            :               if ((ix86_cmodel == CM_SMALL
     302                 :            :                    || (ix86_cmodel == CM_MEDIUM
     303                 :            :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     304                 :            :                   && offset < 16*1024*1024)
     305                 :            :                 return true;
     306                 :            :               /* For CM_KERNEL we know that all object resist in the
     307                 :            :                  negative half of 32bits address space.  We may not
     308                 :            :                  accept negative offsets, since they may be just off
     309                 :            :                  and we may accept pretty large positive ones.  */
     310                 :            :               if (ix86_cmodel == CM_KERNEL
     311                 :            :                   && offset > 0)
     312                 :            :                 return true;
     313                 :            :               break;
     314                 :            : 
     315                 :            :             case LABEL_REF:
     316                 :            :               /* These conditions are similar to SYMBOL_REF ones, just the
     317                 :            :                  constraints for code models differ.  */
     318                 :            :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     319                 :            :                   && offset < 16*1024*1024)
     320                 :            :                 return true;
     321                 :            :               if (ix86_cmodel == CM_KERNEL
     322                 :            :                   && offset > 0)
     323                 :            :                 return true;
     324                 :            :               break;
     325                 :            : 
     326                 :            :             case UNSPEC:
     327                 :            :               switch (XINT (op1, 1))
     328                 :            :                 {
     329                 :            :                 case UNSPEC_DTPOFF:
     330                 :            :                 case UNSPEC_NTPOFF:
     331                 :            :                   return true;
     332                 :            :                 }
     333                 :            :               break;
     334                 :            : 
     335                 :            :             default:
     336                 :            :               break;
     337                 :            :             }
     338                 :            :         }
     339                 :            :       break;
     340                 :            : 
     341                 :            :       default:
     342                 :            :         gcc_unreachable ();
     343                 :            :     }
     344                 :            : 
     345                 :            :   return false;
     346                 :            : }
     347                 :            : 
     348                 :            : int
     349                 :            : x86_64_immediate_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     350                 :            : {
     351                 :            :   switch (GET_CODE (op))
     352                 :            :     {
     353                 :            :     case CONST_INT:
     354                 :            :     case SYMBOL_REF:
     355                 :            :     case LABEL_REF:
     356                 :            :     case CONST:
     357                 :            :       break;
     358                 :            :     default:
     359                 :            :       return false;
     360                 :            :     }
     361                 :            :   return (
     362                 :            : (x86_64_immediate_operand_1 (op, mode))) && (
     363                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
     364                 :            : }
     365                 :            : 
     366                 :            : static inline int
     367                 :            : x86_64_zext_immediate_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     368                 :            : #line 270 "../../gcc/config/i386/predicates.md"
     369                 :            : {
     370                 :            :   switch (GET_CODE (op))
     371                 :            :     {
     372                 :            :     case CONST_INT:
     373                 :            :       return !(INTVAL (op) & ~(HOST_WIDE_INT) 0xffffffff);
     374                 :            : 
     375                 :            :     case SYMBOL_REF:
     376                 :            :       /* TLS symbols are not constant.  */
     377                 :            :       if (SYMBOL_REF_TLS_MODEL (op))
     378                 :            :         return false;
     379                 :            : 
     380                 :            :       /* Load the external function address via the GOT slot.  */
     381                 :            :       if (ix86_force_load_from_GOT_p (op))
     382                 :            :         return false;
     383                 :            : 
     384                 :            :      /* For certain code models, the symbolic references are known to fit.  */
     385                 :            :       return (ix86_cmodel == CM_SMALL
     386                 :            :               || (ix86_cmodel == CM_MEDIUM
     387                 :            :                   && !SYMBOL_REF_FAR_ADDR_P (op)));
     388                 :            : 
     389                 :            :     case LABEL_REF:
     390                 :            :       /* For certain code models, the code is near as well.  */
     391                 :            :       return ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM;
     392                 :            : 
     393                 :            :     case CONST:
     394                 :            :       /* We also may accept the offsetted memory references in certain
     395                 :            :          special cases.  */
     396                 :            :       if (GET_CODE (XEXP (op, 0)) == PLUS)
     397                 :            :         {
     398                 :            :           rtx op1 = XEXP (XEXP (op, 0), 0);
     399                 :            :           rtx op2 = XEXP (XEXP (op, 0), 1);
     400                 :            : 
     401                 :            :           if (ix86_cmodel == CM_LARGE)
     402                 :            :             return false;
     403                 :            :           if (!CONST_INT_P (op2))
     404                 :            :             return false;
     405                 :            : 
     406                 :            :           HOST_WIDE_INT offset = INTVAL (op2);
     407                 :            :           if (trunc_int_for_mode (offset, SImode) != offset)
     408                 :            :             return false;
     409                 :            : 
     410                 :            :           switch (GET_CODE (op1))
     411                 :            :             {
     412                 :            :             case SYMBOL_REF:
     413                 :            :               /* TLS symbols are not constant.  */
     414                 :            :               if (SYMBOL_REF_TLS_MODEL (op1))
     415                 :            :                 return false;
     416                 :            : 
     417                 :            :               /* Load the external function address via the GOT slot.  */
     418                 :            :               if (ix86_force_load_from_GOT_p (op1))
     419                 :            :                 return false;
     420                 :            : 
     421                 :            :               /* For small code model we may accept pretty large positive
     422                 :            :                  offsets, since one bit is available for free.  Negative
     423                 :            :                  offsets are limited by the size of NULL pointer area
     424                 :            :                  specified by the ABI.  */
     425                 :            :               if ((ix86_cmodel == CM_SMALL
     426                 :            :                    || (ix86_cmodel == CM_MEDIUM
     427                 :            :                        && !SYMBOL_REF_FAR_ADDR_P (op1)))
     428                 :            :                   && offset > -0x10000)
     429                 :            :                 return true;
     430                 :            :               /* ??? For the kernel, we may accept adjustment of
     431                 :            :                  -0x10000000, since we know that it will just convert
     432                 :            :                  negative address space to positive, but perhaps this
     433                 :            :                  is not worthwhile.  */
     434                 :            :               break;
     435                 :            : 
     436                 :            :             case LABEL_REF:
     437                 :            :               /* These conditions are similar to SYMBOL_REF ones, just the
     438                 :            :                  constraints for code models differ.  */
     439                 :            :               if ((ix86_cmodel == CM_SMALL || ix86_cmodel == CM_MEDIUM)
     440                 :            :                   && offset > -0x10000)
     441                 :            :                 return true;
     442                 :            :               break;
     443                 :            : 
     444                 :            :             default:
     445                 :            :               return false;
     446                 :            :             }
     447                 :            :         }
     448                 :            :       break;
     449                 :            : 
     450                 :            :     default:
     451                 :            :       gcc_unreachable ();
     452                 :            :     }
     453                 :            :   return false;
     454                 :            : }
     455                 :            : 
     456                 :            : int
     457                 :            : x86_64_zext_immediate_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     458                 :            : {
     459                 :            :   switch (GET_CODE (op))
     460                 :            :     {
     461                 :            :     case CONST_INT:
     462                 :            :     case SYMBOL_REF:
     463                 :            :     case LABEL_REF:
     464                 :            :     case CONST:
     465                 :            :       break;
     466                 :            :     default:
     467                 :            :       return false;
     468                 :            :     }
     469                 :            :   return (
     470                 :            : (x86_64_zext_immediate_operand_1 (op, mode))) && (
     471                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
     472                 :            : }
     473                 :            : 
     474                 :            : static inline int
     475                 :            : x86_64_hilo_int_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     476                 :            : #line 361 "../../gcc/config/i386/predicates.md"
     477                 :            : {
     478                 :            :   switch (GET_CODE (op))
     479                 :            :     {
     480                 :            :     case CONST_INT:
     481                 :            :       return x86_64_immediate_operand (op, mode);
     482                 :            : 
     483                 :            :     case CONST_WIDE_INT:
     484                 :            :       gcc_assert (CONST_WIDE_INT_NUNITS (op) == 2);
     485                 :            :       return (x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op, 0)),
     486                 :            :                                         DImode)
     487                 :            :               && x86_64_immediate_operand (GEN_INT (CONST_WIDE_INT_ELT (op,
     488                 :            :                                                                         1)),
     489                 :            :                                            DImode));
     490                 :            : 
     491                 :            :     default:
     492                 :            :       gcc_unreachable ();
     493                 :            :     }
     494                 :            : }
     495                 :            : 
     496                 :            : int
     497                 :            : x86_64_hilo_int_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     498                 :            : {
     499                 :            :   switch (GET_CODE (op))
     500                 :            :     {
     501                 :            :     case CONST_INT:
     502                 :            :     case CONST_WIDE_INT:
     503                 :            :       break;
     504                 :            :     default:
     505                 :            :       return false;
     506                 :            :     }
     507                 :            :   return 
     508                 :            : (x86_64_hilo_int_operand_1 (op, mode));
     509                 :            : }
     510                 :            : 
     511                 :            : static inline int
     512                 :            : x86_64_dwzext_immediate_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     513                 :            : #line 384 "../../gcc/config/i386/predicates.md"
     514                 :            : {
     515                 :            :   switch (GET_CODE (op))
     516                 :            :     {
     517                 :            :     case CONST_INT:
     518                 :            :       if (!TARGET_64BIT)
     519                 :            :         return UINTVAL (op) <= HOST_WIDE_INT_UC (0xffffffff);
     520                 :            :       return UINTVAL (op) <= HOST_WIDE_INT_UC (0x7fffffff);
     521                 :            : 
     522                 :            :     case CONST_WIDE_INT:
     523                 :            :       if (!TARGET_64BIT)
     524                 :            :         return false;
     525                 :            :       return (CONST_WIDE_INT_NUNITS (op) == 2
     526                 :            :               && CONST_WIDE_INT_ELT (op, 1) == 0
     527                 :            :               && (trunc_int_for_mode (CONST_WIDE_INT_ELT (op, 0), SImode)
     528                 :            :                   == (HOST_WIDE_INT) CONST_WIDE_INT_ELT (op, 0)));
     529                 :            : 
     530                 :            :     default:
     531                 :            :       gcc_unreachable ();
     532                 :            :     }
     533                 :            : }
     534                 :            : 
     535                 :            : int
     536                 :            : x86_64_dwzext_immediate_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     537                 :            : {
     538                 :            :   switch (GET_CODE (op))
     539                 :            :     {
     540                 :            :     case CONST_INT:
     541                 :            :     case CONST_WIDE_INT:
     542                 :            :       break;
     543                 :            :     default:
     544                 :            :       return false;
     545                 :            :     }
     546                 :            :   return 
     547                 :            : (x86_64_dwzext_immediate_operand_1 (op, mode));
     548                 :            : }
     549                 :            : 
     550                 :            : int
     551                 :            : x86_64_immediate_size_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     552                 :            : {
     553                 :            :   return ((GET_CODE (op) == SYMBOL_REF) && ((!(
     554                 :            : #line 409 "../../gcc/config/i386/predicates.md"
     555                 :            : (TARGET_64BIT))) || ((
     556                 :            : #line 410 "../../gcc/config/i386/predicates.md"
     557                 :            : (ix86_cmodel == CM_SMALL)) || (
     558                 :            : #line 411 "../../gcc/config/i386/predicates.md"
     559                 :            : (ix86_cmodel == CM_KERNEL))))) && (
     560                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     561                 :            : }
     562                 :            : 
     563                 :            : int
     564                 :            : x86_64_general_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     565                 :            : {
     566                 :            :   return (
     567                 :            : #line 415 "../../gcc/config/i386/predicates.md"
     568                 :            : (TARGET_64BIT)) ? ((nonimmediate_operand (op, mode)) || (x86_64_immediate_operand (op, mode))) : (general_operand (op, mode));
     569                 :            : }
     570                 :            : 
     571                 :            : int
     572                 :            : x86_64_hilo_general_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     573                 :            : {
     574                 :            :   return (
     575                 :            : #line 423 "../../gcc/config/i386/predicates.md"
     576                 :            : (TARGET_64BIT)) ? ((nonimmediate_operand (op, mode)) || (x86_64_hilo_int_operand (op, mode))) : (general_operand (op, mode));
     577                 :            : }
     578                 :            : 
     579                 :            : int
     580                 :            : x86_64_sext_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     581                 :            : {
     582                 :            :   return (
     583                 :            : #line 432 "../../gcc/config/i386/predicates.md"
     584                 :            : (GET_MODE (op) != VOIDmode)) && (x86_64_general_operand (op, mode));
     585                 :            : }
     586                 :            : 
     587                 :            : int
     588                 :            : sext_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     589                 :            : {
     590                 :            :   return (
     591                 :            : #line 439 "../../gcc/config/i386/predicates.md"
     592                 :            : (GET_MODE (op) != VOIDmode)) && (general_operand (op, mode));
     593                 :            : }
     594                 :            : 
     595                 :            : int
     596                 :            : x86_64_zext_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     597                 :            : {
     598                 :            :   return (
     599                 :            : #line 446 "../../gcc/config/i386/predicates.md"
     600                 :            : (TARGET_64BIT)) ? ((nonimmediate_operand (op, mode)) || ((x86_64_zext_immediate_operand (op, mode)) && (
     601                 :            : #line 449 "../../gcc/config/i386/predicates.md"
     602                 :            : (GET_MODE (op) != VOIDmode)))) : (nonimmediate_operand (op, mode));
     603                 :            : }
     604                 :            : 
     605                 :            : int
     606                 :            : x86_64_szext_general_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     607                 :            : {
     608                 :            :   return (
     609                 :            : #line 455 "../../gcc/config/i386/predicates.md"
     610                 :            : (TARGET_64BIT)) ? ((nonimmediate_operand (op, mode)) || ((x86_64_immediate_operand (op, mode)) || (x86_64_zext_immediate_operand (op, mode)))) : (general_operand (op, mode));
     611                 :            : }
     612                 :            : 
     613                 :            : int
     614                 :            : x86_64_nonmemory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     615                 :            : {
     616                 :            :   return (
     617                 :            : #line 463 "../../gcc/config/i386/predicates.md"
     618                 :            : (TARGET_64BIT)) ? ((register_operand (op, mode)) || (x86_64_immediate_operand (op, mode))) : (nonmemory_operand (op, mode));
     619                 :            : }
     620                 :            : 
     621                 :            : int
     622                 :            : x86_64_szext_nonmemory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     623                 :            : {
     624                 :            :   return (
     625                 :            : #line 470 "../../gcc/config/i386/predicates.md"
     626                 :            : (TARGET_64BIT)) ? ((register_operand (op, mode)) || ((x86_64_immediate_operand (op, mode)) || (x86_64_zext_immediate_operand (op, mode)))) : (nonmemory_operand (op, mode));
     627                 :            : }
     628                 :            : 
     629                 :            : static inline int
     630                 :            : pic_32bit_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     631                 :            : #line 480 "../../gcc/config/i386/predicates.md"
     632                 :            : {
     633                 :            :   if (!flag_pic)
     634                 :            :     return false;
     635                 :            : 
     636                 :            :   /* Rule out relocations that translate into 64bit constants.  */
     637                 :            :   if (TARGET_64BIT && GET_CODE (op) == CONST)
     638                 :            :     {
     639                 :            :       op = XEXP (op, 0);
     640                 :            :       if (GET_CODE (op) == PLUS && CONST_INT_P (XEXP (op, 1)))
     641                 :            :         op = XEXP (op, 0);
     642                 :            :       if (GET_CODE (op) == UNSPEC
     643                 :            :           && (XINT (op, 1) == UNSPEC_GOTOFF
     644                 :            :               || XINT (op, 1) == UNSPEC_GOT))
     645                 :            :         return false;
     646                 :            :     }
     647                 :            : 
     648                 :            :   return symbolic_operand (op, mode);
     649                 :            : }
     650                 :            : 
     651                 :            : int
     652                 :            : pic_32bit_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     653                 :            : {
     654                 :            :   switch (GET_CODE (op))
     655                 :            :     {
     656                 :            :     case CONST:
     657                 :            :     case SYMBOL_REF:
     658                 :            :     case LABEL_REF:
     659                 :            :       break;
     660                 :            :     default:
     661                 :            :       return false;
     662                 :            :     }
     663                 :            :   return (
     664                 :            : (pic_32bit_operand_1 (op, mode))) && (
     665                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
     666                 :            : }
     667                 :            : 
     668                 :            : int
     669                 :            : x86_64_movabs_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     670                 :            : {
     671                 :            :   return (nonmemory_operand (op, mode)) && (!(pic_32bit_operand (op, mode)));
     672                 :            : }
     673                 :            : 
     674                 :            : static inline int
     675                 :            : symbolic_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     676                 :            : #line 508 "../../gcc/config/i386/predicates.md"
     677                 :            : {
     678                 :            :   switch (GET_CODE (op))
     679                 :            :     {
     680                 :            :     case SYMBOL_REF:
     681                 :            :     case LABEL_REF:
     682                 :            :       return true;
     683                 :            : 
     684                 :            :     case CONST:
     685                 :            :       op = XEXP (op, 0);
     686                 :            :       if (GET_CODE (op) == SYMBOL_REF
     687                 :            :           || GET_CODE (op) == LABEL_REF
     688                 :            :           || (GET_CODE (op) == UNSPEC
     689                 :            :               && (XINT (op, 1) == UNSPEC_GOT
     690                 :            :                   || XINT (op, 1) == UNSPEC_GOTOFF
     691                 :            :                   || XINT (op, 1) == UNSPEC_PCREL
     692                 :            :                   || XINT (op, 1) == UNSPEC_GOTPCREL)))
     693                 :            :         return true;
     694                 :            :       if (GET_CODE (op) != PLUS
     695                 :            :           || !CONST_INT_P (XEXP (op, 1)))
     696                 :            :         return false;
     697                 :            : 
     698                 :            :       op = XEXP (op, 0);
     699                 :            :       if (GET_CODE (op) == SYMBOL_REF
     700                 :            :           || GET_CODE (op) == LABEL_REF)
     701                 :            :         return true;
     702                 :            :       /* Only @GOTOFF gets offsets.  */
     703                 :            :       if (GET_CODE (op) != UNSPEC
     704                 :            :           || XINT (op, 1) != UNSPEC_GOTOFF)
     705                 :            :         return false;
     706                 :            : 
     707                 :            :       op = XVECEXP (op, 0, 0);
     708                 :            :       if (GET_CODE (op) == SYMBOL_REF
     709                 :            :           || GET_CODE (op) == LABEL_REF)
     710                 :            :         return true;
     711                 :            :       return false;
     712                 :            : 
     713                 :            :     default:
     714                 :            :       gcc_unreachable ();
     715                 :            :     }
     716                 :            : }
     717                 :            : 
     718                 :            : int
     719                 :            : symbolic_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     720                 :            : {
     721                 :            :   switch (GET_CODE (op))
     722                 :            :     {
     723                 :            :     case SYMBOL_REF:
     724                 :            :     case LABEL_REF:
     725                 :            :     case CONST:
     726                 :            :       break;
     727                 :            :     default:
     728                 :            :       return false;
     729                 :            :     }
     730                 :            :   return (
     731                 :            : (symbolic_operand_1 (op, mode))) && (
     732                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
     733                 :            : }
     734                 :            : 
     735                 :            : static inline int
     736                 :            : local_symbolic_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     737                 :            : #line 552 "../../gcc/config/i386/predicates.md"
     738                 :            : {
     739                 :            :   if (GET_CODE (op) == CONST
     740                 :            :       && GET_CODE (XEXP (op, 0)) == PLUS
     741                 :            :       && CONST_INT_P (XEXP (XEXP (op, 0), 1)))
     742                 :            :     op = XEXP (XEXP (op, 0), 0);
     743                 :            : 
     744                 :            :   if (GET_CODE (op) == LABEL_REF)
     745                 :            :     return true;
     746                 :            : 
     747                 :            :   if (GET_CODE (op) != SYMBOL_REF)
     748                 :            :     return false;
     749                 :            : 
     750                 :            :   if (SYMBOL_REF_TLS_MODEL (op))
     751                 :            :     return false;
     752                 :            : 
     753                 :            :   /* Dll-imported symbols are always external.  */
     754                 :            :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     755                 :            :     return false;
     756                 :            :   if (SYMBOL_REF_LOCAL_P (op))
     757                 :            :     return true;
     758                 :            : 
     759                 :            :   /* There is, however, a not insubstantial body of code in the rest of
     760                 :            :      the compiler that assumes it can just stick the results of
     761                 :            :      ASM_GENERATE_INTERNAL_LABEL in a symbol_ref and have done.  */
     762                 :            :   /* ??? This is a hack.  Should update the body of the compiler to
     763                 :            :      always create a DECL an invoke targetm.encode_section_info.  */
     764                 :            :   if (strncmp (XSTR (op, 0), internal_label_prefix,
     765                 :            :                internal_label_prefix_len) == 0)
     766                 :            :     return true;
     767                 :            : 
     768                 :            :   return false;
     769                 :            : }
     770                 :            : 
     771                 :            : int
     772                 :            : local_symbolic_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     773                 :            : {
     774                 :            :   switch (GET_CODE (op))
     775                 :            :     {
     776                 :            :     case CONST:
     777                 :            :     case LABEL_REF:
     778                 :            :     case SYMBOL_REF:
     779                 :            :       break;
     780                 :            :     default:
     781                 :            :       return false;
     782                 :            :     }
     783                 :            :   return (
     784                 :            : (local_symbolic_operand_1 (op, mode))) && (
     785                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
     786                 :            : }
     787                 :            : 
     788                 :            : int
     789                 :            : gotoff_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     790                 :            : {
     791                 :            :   return (!(
     792                 :            : #line 594 "../../gcc/config/i386/predicates.md"
     793                 :            : (TARGET_VXWORKS_RTP))) && (local_symbolic_operand (op, mode));
     794                 :            : }
     795                 :            : 
     796                 :            : int
     797                 :            : tls_symbolic_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     798                 :            : {
     799                 :            :   return (GET_CODE (op) == SYMBOL_REF) && (
     800                 :            : #line 600 "../../gcc/config/i386/predicates.md"
     801                 :            : (SYMBOL_REF_TLS_MODEL (op)));
     802                 :            : }
     803                 :            : 
     804                 :            : int
     805                 :            : tls_modbase_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     806                 :            : {
     807                 :            :   return (GET_CODE (op) == SYMBOL_REF) && (
     808                 :            : #line 604 "../../gcc/config/i386/predicates.md"
     809                 :            : (op == ix86_tls_module_base ()));
     810                 :            : }
     811                 :            : 
     812                 :            : int
     813                 :            : tls_address_pattern (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     814                 :            : {
     815                 :            :   switch (GET_CODE (op))
     816                 :            :     {
     817                 :            :     case SET:
     818                 :            :     case PARALLEL:
     819                 :            :     case UNSPEC:
     820                 :            :     case UNSPEC_VOLATILE:
     821                 :            :       break;
     822                 :            :     default:
     823                 :            :       return false;
     824                 :            :     }
     825                 :            :   return (
     826                 :            : #line 608 "../../gcc/config/i386/predicates.md"
     827                 :            : (ix86_tls_address_pattern_p (op))) && (
     828                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     829                 :            : }
     830                 :            : 
     831                 :            : static inline int
     832                 :            : constant_call_address_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     833                 :            : #line 613 "../../gcc/config/i386/predicates.md"
     834                 :            : {
     835                 :            :   if (ix86_cmodel == CM_LARGE || ix86_cmodel == CM_LARGE_PIC
     836                 :            :       || flag_force_indirect_call)
     837                 :            :     return false;
     838                 :            :   if (TARGET_DLLIMPORT_DECL_ATTRIBUTES && SYMBOL_REF_DLLIMPORT_P (op))
     839                 :            :     return false;
     840                 :            :   return true;
     841                 :            : }
     842                 :            : 
     843                 :            : int
     844                 :            : constant_call_address_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     845                 :            : {
     846                 :            :   return ((GET_CODE (op) == SYMBOL_REF) && (
     847                 :            : (constant_call_address_operand_1 (op, mode)))) && (
     848                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
     849                 :            : }
     850                 :            : 
     851                 :            : static inline int
     852                 :            : call_register_no_elim_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     853                 :            : #line 628 "../../gcc/config/i386/predicates.md"
     854                 :            : {
     855                 :            :   if (SUBREG_P (op))
     856                 :            :     op = SUBREG_REG (op);
     857                 :            : 
     858                 :            :   if (!TARGET_64BIT && op == stack_pointer_rtx)
     859                 :            :     return false;
     860                 :            : 
     861                 :            :   return register_no_elim_operand (op, mode);
     862                 :            : }
     863                 :            : 
     864                 :            : int
     865                 :            : call_register_no_elim_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     866                 :            : {
     867                 :            :   return (register_operand (op, mode)) && (
     868                 :            : (call_register_no_elim_operand_1 (op, mode)));
     869                 :            : }
     870                 :            : 
     871                 :            : static inline int
     872                 :            : register_no_elim_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     873                 :            : #line 642 "../../gcc/config/i386/predicates.md"
     874                 :            : {
     875                 :            :   if (SUBREG_P (op))
     876                 :            :     op = SUBREG_REG (op);
     877                 :            :   return !(op == arg_pointer_rtx
     878                 :            :            || op == frame_pointer_rtx
     879                 :            :            || IN_RANGE (REGNO (op),
     880                 :            :                         FIRST_PSEUDO_REGISTER, LAST_VIRTUAL_REGISTER));
     881                 :            : }
     882                 :            : 
     883                 :            : int
     884                 :            : register_no_elim_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     885                 :            : {
     886                 :            :   return (register_operand (op, mode)) && (
     887                 :            : (register_no_elim_operand_1 (op, mode)));
     888                 :            : }
     889                 :            : 
     890                 :            : static inline int
     891                 :            : index_register_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     892                 :            : #line 655 "../../gcc/config/i386/predicates.md"
     893                 :            : {
     894                 :            :   if (SUBREG_P (op))
     895                 :            :     op = SUBREG_REG (op);
     896                 :            :   if (reload_completed)
     897                 :            :     return REG_OK_FOR_INDEX_STRICT_P (op);
     898                 :            :   else
     899                 :            :     return REG_OK_FOR_INDEX_NONSTRICT_P (op);
     900                 :            : }
     901                 :            : 
     902                 :            : int
     903                 :            : index_register_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     904                 :            : {
     905                 :            :   return (register_operand (op, mode)) && (
     906                 :            : (index_register_operand_1 (op, mode)));
     907                 :            : }
     908                 :            : 
     909                 :            : int
     910                 :            : general_no_elim_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     911                 :            : {
     912                 :            :   return (GET_CODE (op) == REG || GET_CODE (op) == SUBREG) ? (register_no_elim_operand (op, mode)) : (general_operand (op, mode));
     913                 :            : }
     914                 :            : 
     915                 :            : int
     916                 :            : nonmemory_no_elim_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     917                 :            : {
     918                 :            :   return (register_no_elim_operand (op, mode)) || (immediate_operand (op, mode));
     919                 :            : }
     920                 :            : 
     921                 :            : int
     922                 :            : indirect_branch_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     923                 :            : {
     924                 :            :   return (register_operand (op, mode)) || ((!(
     925                 :            : #line 679 "../../gcc/config/i386/predicates.md"
     926                 :            : (TARGET_INDIRECT_BRANCH_REGISTER))) && ((!(
     927                 :            : #line 680 "../../gcc/config/i386/predicates.md"
     928                 :            : (TARGET_X32))) && (memory_operand (op, mode))));
     929                 :            : }
     930                 :            : 
     931                 :            : static inline int
     932                 :            : sibcall_memory_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     933                 :            : #line 690 "../../gcc/config/i386/predicates.md"
     934                 :            : {
     935                 :            :   op = XEXP (op, 0);
     936                 :            :   if (CONSTANT_P (op))
     937                 :            :     return true;
     938                 :            :   if (GET_CODE (op) == PLUS && REG_P (XEXP (op, 0)))
     939                 :            :     {
     940                 :            :       int regno = REGNO (XEXP (op, 0));
     941                 :            :       if (!HARD_REGISTER_NUM_P (regno) || call_used_or_fixed_reg_p (regno))
     942                 :            :         {
     943                 :            :           op = XEXP (op, 1);
     944                 :            :           if (GOT32_symbol_operand (op, VOIDmode))
     945                 :            :             return true;
     946                 :            :         }
     947                 :            :     }
     948                 :            :   return false;
     949                 :            : }
     950                 :            : 
     951                 :            : int
     952                 :            : sibcall_memory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     953                 :            : {
     954                 :            :   return (memory_operand (op, mode)) && (
     955                 :            : (sibcall_memory_operand_1 (op, mode)));
     956                 :            : }
     957                 :            : 
     958                 :            : static inline int
     959                 :            : GOT_memory_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
     960                 :            : #line 710 "../../gcc/config/i386/predicates.md"
     961                 :            : {
     962                 :            :   op = XEXP (op, 0);
     963                 :            :   return (GET_CODE (op) == CONST
     964                 :            :           && GET_CODE (XEXP (op, 0)) == UNSPEC
     965                 :            :           && XINT (XEXP (op, 0), 1) == UNSPEC_GOTPCREL);
     966                 :            : }
     967                 :            : 
     968                 :            : int
     969                 :            : GOT_memory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     970                 :            : {
     971                 :            :   return (memory_operand (op, mode)) && (
     972                 :            : (GOT_memory_operand_1 (op, mode)));
     973                 :            : }
     974                 :            : 
     975                 :            : int
     976                 :            : call_insn_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     977                 :            : {
     978                 :            :   return (
     979                 :            : #line 720 "../../gcc/config/i386/predicates.md"
     980                 :            : (constant_call_address_operand
     981                 :            :                      (op, mode == VOIDmode ? mode : Pmode))) || ((call_register_no_elim_operand (op, mode)) || ((!(
     982                 :            : #line 723 "../../gcc/config/i386/predicates.md"
     983                 :            : (TARGET_INDIRECT_BRANCH_REGISTER))) && (((!(
     984                 :            : #line 724 "../../gcc/config/i386/predicates.md"
     985                 :            : (TARGET_X32))) && (memory_operand (op, mode))) || ((
     986                 :            : #line 726 "../../gcc/config/i386/predicates.md"
     987                 :            : (TARGET_X32 && Pmode == DImode)) && (GOT_memory_operand (op, mode))))));
     988                 :            : }
     989                 :            : 
     990                 :            : int
     991                 :            : sibcall_insn_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
     992                 :            : {
     993                 :            :   return (
     994                 :            : #line 731 "../../gcc/config/i386/predicates.md"
     995                 :            : (constant_call_address_operand
     996                 :            :                      (op, mode == VOIDmode ? mode : Pmode))) || ((register_no_elim_operand (op, mode)) || ((!(
     997                 :            : #line 734 "../../gcc/config/i386/predicates.md"
     998                 :            : (TARGET_INDIRECT_BRANCH_REGISTER))) && (((!(
     999                 :            : #line 735 "../../gcc/config/i386/predicates.md"
    1000                 :            : (TARGET_X32))) && (sibcall_memory_operand (op, mode))) || ((
    1001                 :            : #line 737 "../../gcc/config/i386/predicates.md"
    1002                 :            : (TARGET_X32 && Pmode == DImode)) && (GOT_memory_operand (op, mode))))));
    1003                 :            : }
    1004                 :            : 
    1005                 :            : int
    1006                 :            : GOT32_symbol_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1007                 :            : {
    1008                 :            :   return (
    1009                 :            : #line 742 "../../gcc/config/i386/predicates.md"
    1010                 :            : (GET_CODE (op) == CONST
    1011                 :            :                && GET_CODE (XEXP (op, 0)) == UNSPEC
    1012                 :            :                && XINT (XEXP (op, 0), 1) == UNSPEC_GOT)) && (
    1013                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
    1014                 :            : }
    1015                 :            : 
    1016                 :            : static inline int
    1017                 :            : const0_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1018                 :            : #line 749 "../../gcc/config/i386/predicates.md"
    1019                 :            : {
    1020                 :            :   if (mode == VOIDmode)
    1021                 :            :     mode = GET_MODE (op);
    1022                 :            :   return op == CONST0_RTX (mode);
    1023                 :            : }
    1024                 :            : 
    1025                 :            : int
    1026                 :            : const0_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1027                 :            : {
    1028                 :            :   switch (GET_CODE (op))
    1029                 :            :     {
    1030                 :            :     case CONST_INT:
    1031                 :            :     case CONST_DOUBLE:
    1032                 :            :     case CONST_VECTOR:
    1033                 :            :       break;
    1034                 :            :     default:
    1035                 :            :       return false;
    1036                 :            :     }
    1037                 :            :   return (
    1038                 :            : (const0_operand_1 (op, mode))) && (
    1039                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
    1040                 :            : }
    1041                 :            : 
    1042                 :            : static inline int
    1043                 :            : const1_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1044                 :            : #line 758 "../../gcc/config/i386/predicates.md"
    1045                 :            : {
    1046                 :            :   if (mode == VOIDmode)
    1047                 :            :     mode = GET_MODE (op);
    1048                 :            :   return op == CONST1_RTX (mode);
    1049                 :            : }
    1050                 :            : 
    1051                 :            : int
    1052                 :            : const1_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1053                 :            : {
    1054                 :            :   switch (GET_CODE (op))
    1055                 :            :     {
    1056                 :            :     case CONST_INT:
    1057                 :            :     case CONST_DOUBLE:
    1058                 :            :     case CONST_VECTOR:
    1059                 :            :       break;
    1060                 :            :     default:
    1061                 :            :       return false;
    1062                 :            :     }
    1063                 :            :   return (
    1064                 :            : (const1_operand_1 (op, mode))) && (
    1065                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
    1066                 :            : }
    1067                 :            : 
    1068                 :            : int
    1069                 :            : constm1_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1070                 :            : {
    1071                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1072                 :            : #line 767 "../../gcc/config/i386/predicates.md"
    1073                 :            : (op == constm1_rtx));
    1074                 :            : }
    1075                 :            : 
    1076                 :            : int
    1077                 :            : const8_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1078                 :            : {
    1079                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1080                 :            : #line 772 "../../gcc/config/i386/predicates.md"
    1081                 :            : (INTVAL (op) == 8));
    1082                 :            : }
    1083                 :            : 
    1084                 :            : int
    1085                 :            : const128_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1086                 :            : {
    1087                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1088                 :            : #line 777 "../../gcc/config/i386/predicates.md"
    1089                 :            : (INTVAL (op) == 128));
    1090                 :            : }
    1091                 :            : 
    1092                 :            : int
    1093                 :            : const_32bit_mask (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1094                 :            : {
    1095                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1096                 :            : #line 782 "../../gcc/config/i386/predicates.md"
    1097                 :            : (trunc_int_for_mode (INTVAL (op), DImode)
    1098                 :            :                     == (HOST_WIDE_INT) 0xffffffff));
    1099                 :            : }
    1100                 :            : 
    1101                 :            : static inline int
    1102                 :            : const248_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1103                 :            : #line 788 "../../gcc/config/i386/predicates.md"
    1104                 :            : {
    1105                 :            :   HOST_WIDE_INT i = INTVAL (op);
    1106                 :            :   return i == 2 || i == 4 || i == 8;
    1107                 :            : }
    1108                 :            : 
    1109                 :            : int
    1110                 :            : const248_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1111                 :            : {
    1112                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1113                 :            : (const248_operand_1 (op, mode)));
    1114                 :            : }
    1115                 :            : 
    1116                 :            : static inline int
    1117                 :            : const123_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1118                 :            : #line 796 "../../gcc/config/i386/predicates.md"
    1119                 :            : {
    1120                 :            :   HOST_WIDE_INT i = INTVAL (op);
    1121                 :            :   return i == 1 || i == 2 || i == 3;
    1122                 :            : }
    1123                 :            : 
    1124                 :            : int
    1125                 :            : const123_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1126                 :            : {
    1127                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1128                 :            : (const123_operand_1 (op, mode)));
    1129                 :            : }
    1130                 :            : 
    1131                 :            : static inline int
    1132                 :            : const2367_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1133                 :            : #line 804 "../../gcc/config/i386/predicates.md"
    1134                 :            : {
    1135                 :            :   HOST_WIDE_INT i = INTVAL (op);
    1136                 :            :   return i == 2 || i == 3 || i == 6 || i == 7;
    1137                 :            : }
    1138                 :            : 
    1139                 :            : int
    1140                 :            : const2367_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1141                 :            : {
    1142                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1143                 :            : (const2367_operand_1 (op, mode)));
    1144                 :            : }
    1145                 :            : 
    1146                 :            : static inline int
    1147                 :            : const1248_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1148                 :            : #line 812 "../../gcc/config/i386/predicates.md"
    1149                 :            : {
    1150                 :            :   HOST_WIDE_INT i = INTVAL (op);
    1151                 :            :   return i == 1 || i == 2 || i == 4 || i == 8;
    1152                 :            : }
    1153                 :            : 
    1154                 :            : int
    1155                 :            : const1248_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1156                 :            : {
    1157                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1158                 :            : (const1248_operand_1 (op, mode)));
    1159                 :            : }
    1160                 :            : 
    1161                 :            : static inline int
    1162                 :            : const359_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1163                 :            : #line 820 "../../gcc/config/i386/predicates.md"
    1164                 :            : {
    1165                 :            :   HOST_WIDE_INT i = INTVAL (op);
    1166                 :            :   return i == 3 || i == 5 || i == 9;
    1167                 :            : }
    1168                 :            : 
    1169                 :            : int
    1170                 :            : const359_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1171                 :            : {
    1172                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1173                 :            : (const359_operand_1 (op, mode)));
    1174                 :            : }
    1175                 :            : 
    1176                 :            : static inline int
    1177                 :            : const_4_or_8_to_11_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1178                 :            : #line 828 "../../gcc/config/i386/predicates.md"
    1179                 :            : {
    1180                 :            :   HOST_WIDE_INT i = INTVAL (op);
    1181                 :            :   return i == 4 || (i >= 8 && i <= 11);
    1182                 :            : }
    1183                 :            : 
    1184                 :            : int
    1185                 :            : const_4_or_8_to_11_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1186                 :            : {
    1187                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1188                 :            : (const_4_or_8_to_11_operand_1 (op, mode)));
    1189                 :            : }
    1190                 :            : 
    1191                 :            : static inline int
    1192                 :            : const48_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1193                 :            : #line 836 "../../gcc/config/i386/predicates.md"
    1194                 :            : {
    1195                 :            :   HOST_WIDE_INT i = INTVAL (op);
    1196                 :            :   return i == 4 || i == 8;
    1197                 :            : }
    1198                 :            : 
    1199                 :            : int
    1200                 :            : const48_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1201                 :            : {
    1202                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1203                 :            : (const48_operand_1 (op, mode)));
    1204                 :            : }
    1205                 :            : 
    1206                 :            : int
    1207                 :            : const_0_to_1_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1208                 :            : {
    1209                 :            :   return (GET_CODE (op) == CONST_INT) && ((
    1210                 :            : #line 844 "../../gcc/config/i386/predicates.md"
    1211                 :            : (op == const0_rtx)) || (
    1212                 :            : #line 845 "../../gcc/config/i386/predicates.md"
    1213                 :            : (op == const1_rtx)));
    1214                 :            : }
    1215                 :            : 
    1216                 :            : int
    1217                 :            : const_0_to_3_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1218                 :            : {
    1219                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1220                 :            : #line 850 "../../gcc/config/i386/predicates.md"
    1221                 :            : (IN_RANGE (INTVAL (op), 0, 3)));
    1222                 :            : }
    1223                 :            : 
    1224                 :            : int
    1225                 :            : const_0_to_4_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1226                 :            : {
    1227                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1228                 :            : #line 855 "../../gcc/config/i386/predicates.md"
    1229                 :            : (IN_RANGE (INTVAL (op), 0, 4)));
    1230                 :            : }
    1231                 :            : 
    1232                 :            : int
    1233                 :            : const_0_to_5_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1234                 :            : {
    1235                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1236                 :            : #line 860 "../../gcc/config/i386/predicates.md"
    1237                 :            : (IN_RANGE (INTVAL (op), 0, 5)));
    1238                 :            : }
    1239                 :            : 
    1240                 :            : int
    1241                 :            : const_0_to_7_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1242                 :            : {
    1243                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1244                 :            : #line 865 "../../gcc/config/i386/predicates.md"
    1245                 :            : (IN_RANGE (INTVAL (op), 0, 7)));
    1246                 :            : }
    1247                 :            : 
    1248                 :            : int
    1249                 :            : const_0_to_15_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1250                 :            : {
    1251                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1252                 :            : #line 870 "../../gcc/config/i386/predicates.md"
    1253                 :            : (IN_RANGE (INTVAL (op), 0, 15)));
    1254                 :            : }
    1255                 :            : 
    1256                 :            : int
    1257                 :            : const_0_to_31_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1258                 :            : {
    1259                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1260                 :            : #line 875 "../../gcc/config/i386/predicates.md"
    1261                 :            : (IN_RANGE (INTVAL (op), 0, 31)));
    1262                 :            : }
    1263                 :            : 
    1264                 :            : int
    1265                 :            : const_0_to_63_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1266                 :            : {
    1267                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1268                 :            : #line 880 "../../gcc/config/i386/predicates.md"
    1269                 :            : (IN_RANGE (INTVAL (op), 0, 63)));
    1270                 :            : }
    1271                 :            : 
    1272                 :            : int
    1273                 :            : const_0_to_255_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1274                 :            : {
    1275                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1276                 :            : #line 885 "../../gcc/config/i386/predicates.md"
    1277                 :            : (IN_RANGE (INTVAL (op), 0, 255)));
    1278                 :            : }
    1279                 :            : 
    1280                 :            : static inline int
    1281                 :            : const_0_to_255_mul_8_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1282                 :            : #line 890 "../../gcc/config/i386/predicates.md"
    1283                 :            : {
    1284                 :            :   unsigned HOST_WIDE_INT val = INTVAL (op);
    1285                 :            :   return val <= 255*8 && val % 8 == 0;
    1286                 :            : }
    1287                 :            : 
    1288                 :            : int
    1289                 :            : const_0_to_255_mul_8_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1290                 :            : {
    1291                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1292                 :            : (const_0_to_255_mul_8_operand_1 (op, mode)));
    1293                 :            : }
    1294                 :            : 
    1295                 :            : int
    1296                 :            : const_1_to_31_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1297                 :            : {
    1298                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1299                 :            : #line 899 "../../gcc/config/i386/predicates.md"
    1300                 :            : (IN_RANGE (INTVAL (op), 1, 31)));
    1301                 :            : }
    1302                 :            : 
    1303                 :            : int
    1304                 :            : const_1_to_63_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1305                 :            : {
    1306                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1307                 :            : #line 905 "../../gcc/config/i386/predicates.md"
    1308                 :            : (IN_RANGE (INTVAL (op), 1, 63)));
    1309                 :            : }
    1310                 :            : 
    1311                 :            : int
    1312                 :            : const_2_to_3_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1313                 :            : {
    1314                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1315                 :            : #line 910 "../../gcc/config/i386/predicates.md"
    1316                 :            : (IN_RANGE (INTVAL (op), 2, 3)));
    1317                 :            : }
    1318                 :            : 
    1319                 :            : int
    1320                 :            : const_4_to_5_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1321                 :            : {
    1322                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1323                 :            : #line 915 "../../gcc/config/i386/predicates.md"
    1324                 :            : (IN_RANGE (INTVAL (op), 4, 5)));
    1325                 :            : }
    1326                 :            : 
    1327                 :            : int
    1328                 :            : const_4_to_7_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1329                 :            : {
    1330                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1331                 :            : #line 920 "../../gcc/config/i386/predicates.md"
    1332                 :            : (IN_RANGE (INTVAL (op), 4, 7)));
    1333                 :            : }
    1334                 :            : 
    1335                 :            : int
    1336                 :            : const_6_to_7_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1337                 :            : {
    1338                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1339                 :            : #line 925 "../../gcc/config/i386/predicates.md"
    1340                 :            : (IN_RANGE (INTVAL (op), 6, 7)));
    1341                 :            : }
    1342                 :            : 
    1343                 :            : int
    1344                 :            : const_8_to_9_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1345                 :            : {
    1346                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1347                 :            : #line 930 "../../gcc/config/i386/predicates.md"
    1348                 :            : (IN_RANGE (INTVAL (op), 8, 9)));
    1349                 :            : }
    1350                 :            : 
    1351                 :            : int
    1352                 :            : const_8_to_11_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1353                 :            : {
    1354                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1355                 :            : #line 935 "../../gcc/config/i386/predicates.md"
    1356                 :            : (IN_RANGE (INTVAL (op), 8, 11)));
    1357                 :            : }
    1358                 :            : 
    1359                 :            : int
    1360                 :            : const_8_to_15_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1361                 :            : {
    1362                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1363                 :            : #line 940 "../../gcc/config/i386/predicates.md"
    1364                 :            : (IN_RANGE (INTVAL (op), 8, 15)));
    1365                 :            : }
    1366                 :            : 
    1367                 :            : int
    1368                 :            : const_10_to_11_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1369                 :            : {
    1370                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1371                 :            : #line 945 "../../gcc/config/i386/predicates.md"
    1372                 :            : (IN_RANGE (INTVAL (op), 10, 11)));
    1373                 :            : }
    1374                 :            : 
    1375                 :            : int
    1376                 :            : const_12_to_13_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1377                 :            : {
    1378                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1379                 :            : #line 950 "../../gcc/config/i386/predicates.md"
    1380                 :            : (IN_RANGE (INTVAL (op), 12, 13)));
    1381                 :            : }
    1382                 :            : 
    1383                 :            : int
    1384                 :            : const_12_to_15_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1385                 :            : {
    1386                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1387                 :            : #line 955 "../../gcc/config/i386/predicates.md"
    1388                 :            : (IN_RANGE (INTVAL (op), 12, 15)));
    1389                 :            : }
    1390                 :            : 
    1391                 :            : int
    1392                 :            : const_14_to_15_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1393                 :            : {
    1394                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1395                 :            : #line 960 "../../gcc/config/i386/predicates.md"
    1396                 :            : (IN_RANGE (INTVAL (op), 14, 15)));
    1397                 :            : }
    1398                 :            : 
    1399                 :            : int
    1400                 :            : const_16_to_19_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1401                 :            : {
    1402                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1403                 :            : #line 965 "../../gcc/config/i386/predicates.md"
    1404                 :            : (IN_RANGE (INTVAL (op), 16, 19)));
    1405                 :            : }
    1406                 :            : 
    1407                 :            : int
    1408                 :            : const_16_to_31_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1409                 :            : {
    1410                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1411                 :            : #line 970 "../../gcc/config/i386/predicates.md"
    1412                 :            : (IN_RANGE (INTVAL (op), 16, 31)));
    1413                 :            : }
    1414                 :            : 
    1415                 :            : int
    1416                 :            : const_20_to_23_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1417                 :            : {
    1418                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1419                 :            : #line 975 "../../gcc/config/i386/predicates.md"
    1420                 :            : (IN_RANGE (INTVAL (op), 20, 23)));
    1421                 :            : }
    1422                 :            : 
    1423                 :            : int
    1424                 :            : const_24_to_27_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1425                 :            : {
    1426                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1427                 :            : #line 980 "../../gcc/config/i386/predicates.md"
    1428                 :            : (IN_RANGE (INTVAL (op), 24, 27)));
    1429                 :            : }
    1430                 :            : 
    1431                 :            : int
    1432                 :            : const_28_to_31_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1433                 :            : {
    1434                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1435                 :            : #line 985 "../../gcc/config/i386/predicates.md"
    1436                 :            : (IN_RANGE (INTVAL (op), 28, 31)));
    1437                 :            : }
    1438                 :            : 
    1439                 :            : static inline int
    1440                 :            : incdec_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1441                 :            : #line 990 "../../gcc/config/i386/predicates.md"
    1442                 :            : {
    1443                 :            :   /* On Pentium4, the inc and dec operations causes extra dependency on flag
    1444                 :            :      registers, since carry flag is not set.  */
    1445                 :            :   if (!TARGET_USE_INCDEC && !optimize_insn_for_size_p ())
    1446                 :            :     return false;
    1447                 :            :   return op == const1_rtx || op == constm1_rtx;
    1448                 :            : }
    1449                 :            : 
    1450                 :            : int
    1451                 :            : incdec_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1452                 :            : {
    1453                 :            :   return (GET_CODE (op) == CONST_INT) && (
    1454                 :            : (incdec_operand_1 (op, mode)));
    1455                 :            : }
    1456                 :            : 
    1457                 :            : int
    1458                 :            : reg_or_pm1_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1459                 :            : {
    1460                 :            :   return (register_operand (op, mode)) || (((GET_CODE (op) == CONST_INT) && ((
    1461                 :            : #line 1002 "../../gcc/config/i386/predicates.md"
    1462                 :            : (op == const1_rtx)) || (
    1463                 :            : #line 1003 "../../gcc/config/i386/predicates.md"
    1464                 :            : (op == constm1_rtx)))) && (
    1465                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)));
    1466                 :            : }
    1467                 :            : 
    1468                 :            : int
    1469                 :            : shiftdi_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1470                 :            : {
    1471                 :            :   return (
    1472                 :            : #line 1007 "../../gcc/config/i386/predicates.md"
    1473                 :            : (TARGET_64BIT)) ? (nonimmediate_operand (op, mode)) : (register_operand (op, mode));
    1474                 :            : }
    1475                 :            : 
    1476                 :            : int
    1477                 :            : ashldi_input_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1478                 :            : {
    1479                 :            :   return (
    1480                 :            : #line 1012 "../../gcc/config/i386/predicates.md"
    1481                 :            : (TARGET_64BIT)) ? (nonimmediate_operand (op, mode)) : (reg_or_pm1_operand (op, mode));
    1482                 :            : }
    1483                 :            : 
    1484                 :            : static inline int
    1485                 :            : zero_extended_scalar_load_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1486                 :            : #line 1020 "../../gcc/config/i386/predicates.md"
    1487                 :            : {
    1488                 :            :   unsigned n_elts;
    1489                 :            :   op = avoid_constant_pool_reference (op);
    1490                 :            : 
    1491                 :            :   if (GET_CODE (op) != CONST_VECTOR)
    1492                 :            :     return false;
    1493                 :            : 
    1494                 :            :   n_elts = CONST_VECTOR_NUNITS (op);
    1495                 :            : 
    1496                 :            :   for (n_elts--; n_elts > 0; n_elts--)
    1497                 :            :     {
    1498                 :            :       rtx elt = CONST_VECTOR_ELT (op, n_elts);
    1499                 :            :       if (elt != CONST0_RTX (GET_MODE_INNER (GET_MODE (op))))
    1500                 :            :         return false;
    1501                 :            :     }
    1502                 :            :   return true;
    1503                 :            : }
    1504                 :            : 
    1505                 :            : int
    1506                 :            : zero_extended_scalar_load_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1507                 :            : {
    1508                 :            :   return ((GET_CODE (op) == MEM) && (
    1509                 :            : (zero_extended_scalar_load_operand_1 (op, mode)))) && (
    1510                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    1511                 :            : }
    1512                 :            : 
    1513                 :            : int
    1514                 :            : vector_all_ones_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1515                 :            : {
    1516                 :            :   return ((GET_CODE (op) == CONST_VECTOR) && ((
    1517                 :            : #line 1041 "../../gcc/config/i386/predicates.md"
    1518                 :            : (INTEGRAL_MODE_P (GET_MODE (op)))) && (
    1519                 :            : #line 1042 "../../gcc/config/i386/predicates.md"
    1520                 :            : (op == CONSTM1_RTX (GET_MODE (op)))))) && (
    1521                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    1522                 :            : }
    1523                 :            : 
    1524                 :            : int
    1525                 :            : vector_memory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1526                 :            : {
    1527                 :            :   return (memory_operand (op, mode)) && ((
    1528                 :            : #line 1048 "../../gcc/config/i386/predicates.md"
    1529                 :            : (TARGET_AVX)) || (
    1530                 :            : #line 1049 "../../gcc/config/i386/predicates.md"
    1531                 :            : (MEM_ALIGN (op) >= GET_MODE_ALIGNMENT (mode))));
    1532                 :            : }
    1533                 :            : 
    1534                 :            : int
    1535                 :            : vector_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1536                 :            : {
    1537                 :            :   return (register_operand (op, mode)) || (vector_memory_operand (op, mode));
    1538                 :            : }
    1539                 :            : 
    1540                 :            : int
    1541                 :            : nonimmediate_or_const_vector_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1542                 :            : {
    1543                 :            :   return (nonimmediate_operand (op, mode)) || ((GET_CODE (op) == CONST_VECTOR) && (
    1544                 :            : (mode == VOIDmode || GET_MODE (op) == mode)));
    1545                 :            : }
    1546                 :            : 
    1547                 :            : int
    1548                 :            : nonimmediate_or_sse_const_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1549                 :            : {
    1550                 :            :   return (nonimmediate_operand (op, mode)) || ((
    1551                 :            : #line 1065 "../../gcc/config/i386/predicates.md"
    1552                 :            : (standard_sse_constant_p (op, mode))) && (
    1553                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)));
    1554                 :            : }
    1555                 :            : 
    1556                 :            : int
    1557                 :            : reg_or_0_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1558                 :            : {
    1559                 :            :   return (register_operand (op, mode)) || (const0_operand (op, mode));
    1560                 :            : }
    1561                 :            : 
    1562                 :            : int
    1563                 :            : nonimm_or_0_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1564                 :            : {
    1565                 :            :   return (nonimmediate_operand (op, mode)) || (const0_operand (op, mode));
    1566                 :            : }
    1567                 :            : 
    1568                 :            : int
    1569                 :            : norex_memory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1570                 :            : {
    1571                 :            :   return (memory_operand (op, mode)) && (!(
    1572                 :            : #line 1079 "../../gcc/config/i386/predicates.md"
    1573                 :            : (x86_extended_reg_mentioned_p (op))));
    1574                 :            : }
    1575                 :            : 
    1576                 :            : int
    1577                 :            : SImode_address_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1578                 :            : {
    1579                 :            :   switch (GET_CODE (op))
    1580                 :            :     {
    1581                 :            :     case SUBREG:
    1582                 :            :     case ZERO_EXTEND:
    1583                 :            :     case AND:
    1584                 :            :       break;
    1585                 :            :     default:
    1586                 :            :       return false;
    1587                 :            :     }
    1588                 :            :   return 
    1589                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    1590                 :            : }
    1591                 :            : 
    1592                 :            : static inline int
    1593                 :            : address_no_seg_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1594                 :            : #line 1090 "../../gcc/config/i386/predicates.md"
    1595                 :            : {
    1596                 :            :   struct ix86_address parts;
    1597                 :            :   int ok;
    1598                 :            : 
    1599                 :            :   if (!CONST_INT_P (op)
    1600                 :            :       && mode != VOIDmode
    1601                 :            :       && GET_MODE (op) != mode)
    1602                 :            :     return false;
    1603                 :            : 
    1604                 :            :   ok = ix86_decompose_address (op, &parts);
    1605                 :            :   gcc_assert (ok);
    1606                 :            :   return parts.seg == ADDR_SPACE_GENERIC;
    1607                 :            : }
    1608                 :            : 
    1609                 :            : int
    1610                 :            : address_no_seg_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1611                 :            : {
    1612                 :            :   return (
    1613                 :            : #line 1089 "../../gcc/config/i386/predicates.md"
    1614                 :            : (address_operand (op, VOIDmode))) && (
    1615                 :            : (address_no_seg_operand_1 (op, mode)));
    1616                 :            : }
    1617                 :            : 
    1618                 :            : static inline int
    1619                 :            : vsib_address_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1620                 :            : #line 1108 "../../gcc/config/i386/predicates.md"
    1621                 :            : {
    1622                 :            :   struct ix86_address parts;
    1623                 :            :   int ok;
    1624                 :            :   rtx disp;
    1625                 :            : 
    1626                 :            :   ok = ix86_decompose_address (op, &parts);
    1627                 :            :   gcc_assert (ok);
    1628                 :            :   if (parts.index || parts.seg != ADDR_SPACE_GENERIC)
    1629                 :            :     return false;
    1630                 :            : 
    1631                 :            :   /* VSIB addressing doesn't support (%rip).  */
    1632                 :            :   if (parts.disp)
    1633                 :            :     {
    1634                 :            :       disp = parts.disp;
    1635                 :            :       if (GET_CODE (disp) == CONST)
    1636                 :            :         {
    1637                 :            :           disp = XEXP (disp, 0);
    1638                 :            :           if (GET_CODE (disp) == PLUS)
    1639                 :            :             disp = XEXP (disp, 0);
    1640                 :            :           if (GET_CODE (disp) == UNSPEC)
    1641                 :            :             switch (XINT (disp, 1))
    1642                 :            :               {
    1643                 :            :               case UNSPEC_GOTPCREL:
    1644                 :            :               case UNSPEC_PCREL:
    1645                 :            :               case UNSPEC_GOTNTPOFF:
    1646                 :            :                 return false;
    1647                 :            :               }
    1648                 :            :         }
    1649                 :            :       if (TARGET_64BIT
    1650                 :            :           && flag_pic
    1651                 :            :           && (GET_CODE (disp) == SYMBOL_REF
    1652                 :            :               || GET_CODE (disp) == LABEL_REF))
    1653                 :            :         return false;
    1654                 :            :     }
    1655                 :            : 
    1656                 :            :   return true;
    1657                 :            : }
    1658                 :            : 
    1659                 :            : int
    1660                 :            : vsib_address_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1661                 :            : {
    1662                 :            :   return ((
    1663                 :            : #line 1107 "../../gcc/config/i386/predicates.md"
    1664                 :            : (address_operand (op, VOIDmode))) && (
    1665                 :            : (vsib_address_operand_1 (op, mode)))) && (
    1666                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode));
    1667                 :            : }
    1668                 :            : 
    1669                 :            : int
    1670                 :            : vsib_mem_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1671                 :            : {
    1672                 :            :   return (GET_CODE (op) == MEM) && (
    1673                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    1674                 :            : }
    1675                 :            : 
    1676                 :            : static inline int
    1677                 :            : aligned_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1678                 :            : #line 1152 "../../gcc/config/i386/predicates.md"
    1679                 :            : {
    1680                 :            :   struct ix86_address parts;
    1681                 :            :   int ok;
    1682                 :            : 
    1683                 :            :   /* Registers and immediate operands are always "aligned".  */
    1684                 :            :   if (!MEM_P (op))
    1685                 :            :     return true;
    1686                 :            : 
    1687                 :            :   /* All patterns using aligned_operand on memory operands ends up
    1688                 :            :      in promoting memory operand to 64bit and thus causing memory mismatch.  */
    1689                 :            :   if (TARGET_MEMORY_MISMATCH_STALL && !optimize_insn_for_size_p ())
    1690                 :            :     return false;
    1691                 :            : 
    1692                 :            :   /* Don't even try to do any aligned optimizations with volatiles.  */
    1693                 :            :   if (MEM_VOLATILE_P (op))
    1694                 :            :     return false;
    1695                 :            : 
    1696                 :            :   if (MEM_ALIGN (op) >= 32)
    1697                 :            :     return true;
    1698                 :            : 
    1699                 :            :   op = XEXP (op, 0);
    1700                 :            : 
    1701                 :            :   /* Pushes and pops are only valid on the stack pointer.  */
    1702                 :            :   if (GET_CODE (op) == PRE_DEC
    1703                 :            :       || GET_CODE (op) == POST_INC)
    1704                 :            :     return true;
    1705                 :            : 
    1706                 :            :   /* Decode the address.  */
    1707                 :            :   ok = ix86_decompose_address (op, &parts);
    1708                 :            :   gcc_assert (ok);
    1709                 :            : 
    1710                 :            :   if (parts.base && SUBREG_P (parts.base))
    1711                 :            :     parts.base = SUBREG_REG (parts.base);
    1712                 :            :   if (parts.index && SUBREG_P (parts.index))
    1713                 :            :     parts.index = SUBREG_REG (parts.index);
    1714                 :            : 
    1715                 :            :   /* Look for some component that isn't known to be aligned.  */
    1716                 :            :   if (parts.index)
    1717                 :            :     {
    1718                 :            :       if (REGNO_POINTER_ALIGN (REGNO (parts.index)) * parts.scale < 32)
    1719                 :            :         return false;
    1720                 :            :     }
    1721                 :            :   if (parts.base)
    1722                 :            :     {
    1723                 :            :       if (REGNO_POINTER_ALIGN (REGNO (parts.base)) < 32)
    1724                 :            :         return false;
    1725                 :            :     }
    1726                 :            :   if (parts.disp)
    1727                 :            :     {
    1728                 :            :       if (!CONST_INT_P (parts.disp)
    1729                 :            :           || (INTVAL (parts.disp) & 3))
    1730                 :            :         return false;
    1731                 :            :     }
    1732                 :            : 
    1733                 :            :   /* Didn't find one -- this must be an aligned address.  */
    1734                 :            :   return true;
    1735                 :            : }
    1736                 :            : 
    1737                 :            : int
    1738                 :            : aligned_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1739                 :            : {
    1740                 :            :   return (general_operand (op, mode)) && (
    1741                 :            : (aligned_operand_1 (op, mode)));
    1742                 :            : }
    1743                 :            : 
    1744                 :            : static inline int
    1745                 :            : memory_displacement_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1746                 :            : #line 1213 "../../gcc/config/i386/predicates.md"
    1747                 :            : {
    1748                 :            :   struct ix86_address parts;
    1749                 :            :   int ok;
    1750                 :            : 
    1751                 :            :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1752                 :            :   gcc_assert (ok);
    1753                 :            :   return parts.disp != NULL_RTX;
    1754                 :            : }
    1755                 :            : 
    1756                 :            : int
    1757                 :            : memory_displacement_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1758                 :            : {
    1759                 :            :   return (memory_operand (op, mode)) && (
    1760                 :            : (memory_displacement_operand_1 (op, mode)));
    1761                 :            : }
    1762                 :            : 
    1763                 :            : static inline int
    1764                 :            : memory_displacement_only_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1765                 :            : #line 1225 "../../gcc/config/i386/predicates.md"
    1766                 :            : {
    1767                 :            :   struct ix86_address parts;
    1768                 :            :   int ok;
    1769                 :            : 
    1770                 :            :   if (TARGET_64BIT)
    1771                 :            :     return false;
    1772                 :            : 
    1773                 :            :   ok = ix86_decompose_address (XEXP (op, 0), &parts);
    1774                 :            :   gcc_assert (ok);
    1775                 :            : 
    1776                 :            :   if (parts.base || parts.index)
    1777                 :            :     return false;
    1778                 :            : 
    1779                 :            :   return parts.disp != NULL_RTX;
    1780                 :            : }
    1781                 :            : 
    1782                 :            : int
    1783                 :            : memory_displacement_only_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1784                 :            : {
    1785                 :            :   return (memory_operand (op, mode)) && (
    1786                 :            : (memory_displacement_only_operand_1 (op, mode)));
    1787                 :            : }
    1788                 :            : 
    1789                 :            : int
    1790                 :            : long_memory_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1791                 :            : {
    1792                 :            :   return (memory_operand (op, mode)) && (
    1793                 :            : #line 1245 "../../gcc/config/i386/predicates.md"
    1794                 :            : (memory_address_length (op, false)));
    1795                 :            : }
    1796                 :            : 
    1797                 :            : static inline int
    1798                 :            : fcmov_comparison_operator_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1799                 :            : #line 1250 "../../gcc/config/i386/predicates.md"
    1800                 :            : {
    1801                 :            :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1802                 :            :   enum rtx_code code = GET_CODE (op);
    1803                 :            : 
    1804                 :            :   if (inmode == CCFPmode)
    1805                 :            :     {
    1806                 :            :       if (!ix86_trivial_fp_comparison_operator (op, mode))
    1807                 :            :         return false;
    1808                 :            :       code = ix86_fp_compare_code_to_integer (code);
    1809                 :            :     }
    1810                 :            :   /* i387 supports just limited amount of conditional codes.  */
    1811                 :            :   switch (code)
    1812                 :            :     {
    1813                 :            :     case LTU: case GTU: case LEU: case GEU:
    1814                 :            :       if (inmode == CCmode || inmode == CCFPmode || inmode == CCCmode)
    1815                 :            :         return true;
    1816                 :            :       return false;
    1817                 :            :     case ORDERED: case UNORDERED:
    1818                 :            :     case EQ: case NE:
    1819                 :            :       return true;
    1820                 :            :     default:
    1821                 :            :       return false;
    1822                 :            :     }
    1823                 :            : }
    1824                 :            : 
    1825                 :            : int
    1826                 :            : fcmov_comparison_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1827                 :            : {
    1828                 :            :   return (comparison_operator (op, mode)) && (
    1829                 :            : (fcmov_comparison_operator_1 (op, mode)));
    1830                 :            : }
    1831                 :            : 
    1832                 :            : int
    1833                 :            : sse_comparison_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1834                 :            : {
    1835                 :            :   return ((GET_CODE (op) == EQ || GET_CODE (op) == NE || GET_CODE (op) == LT || GET_CODE (op) == LE || GET_CODE (op) == UNORDERED || GET_CODE (op) == UNGE || GET_CODE (op) == UNGT || GET_CODE (op) == ORDERED) || ((
    1836                 :            : #line 1281 "../../gcc/config/i386/predicates.md"
    1837                 :            : (TARGET_AVX)) && (GET_CODE (op) == GE || GET_CODE (op) == GT || GET_CODE (op) == UNEQ || GET_CODE (op) == UNLE || GET_CODE (op) == UNLT || GET_CODE (op) == LTGT))) && (
    1838                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    1839                 :            : }
    1840                 :            : 
    1841                 :            : int
    1842                 :            : ix86_comparison_int_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1843                 :            : {
    1844                 :            :   switch (GET_CODE (op))
    1845                 :            :     {
    1846                 :            :     case NE:
    1847                 :            :     case EQ:
    1848                 :            :     case GE:
    1849                 :            :     case GT:
    1850                 :            :     case LE:
    1851                 :            :     case LT:
    1852                 :            :       break;
    1853                 :            :     default:
    1854                 :            :       return false;
    1855                 :            :     }
    1856                 :            :   return 
    1857                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    1858                 :            : }
    1859                 :            : 
    1860                 :            : int
    1861                 :            : ix86_comparison_uns_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1862                 :            : {
    1863                 :            :   switch (GET_CODE (op))
    1864                 :            :     {
    1865                 :            :     case NE:
    1866                 :            :     case EQ:
    1867                 :            :     case GEU:
    1868                 :            :     case GTU:
    1869                 :            :     case LEU:
    1870                 :            :     case LTU:
    1871                 :            :       break;
    1872                 :            :     default:
    1873                 :            :       return false;
    1874                 :            :     }
    1875                 :            :   return 
    1876                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    1877                 :            : }
    1878                 :            : 
    1879                 :            : int
    1880                 :            : bt_comparison_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1881                 :            : {
    1882                 :            :   switch (GET_CODE (op))
    1883                 :            :     {
    1884                 :            :     case NE:
    1885                 :            :     case EQ:
    1886                 :            :       break;
    1887                 :            :     default:
    1888                 :            :       return false;
    1889                 :            :     }
    1890                 :            :   return 
    1891                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    1892                 :            : }
    1893                 :            : 
    1894                 :            : static inline int
    1895                 :            : ix86_comparison_operator_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1896                 :            : #line 1296 "../../gcc/config/i386/predicates.md"
    1897                 :            : {
    1898                 :            :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1899                 :            :   enum rtx_code code = GET_CODE (op);
    1900                 :            : 
    1901                 :            :   if (inmode == CCFPmode)
    1902                 :            :     return ix86_trivial_fp_comparison_operator (op, mode);
    1903                 :            : 
    1904                 :            :   switch (code)
    1905                 :            :     {
    1906                 :            :     case EQ: case NE:
    1907                 :            :       if (inmode == CCGZmode)
    1908                 :            :         return false;
    1909                 :            :       return true;
    1910                 :            :     case GE: case LT:
    1911                 :            :       if (inmode == CCmode || inmode == CCGCmode
    1912                 :            :           || inmode == CCGOCmode || inmode == CCNOmode || inmode == CCGZmode)
    1913                 :            :         return true;
    1914                 :            :       return false;
    1915                 :            :     case GEU: case LTU:
    1916                 :            :       if (inmode == CCGZmode)
    1917                 :            :         return true;
    1918                 :            :       /* FALLTHRU */
    1919                 :            :     case GTU: case LEU:
    1920                 :            :       if (inmode == CCmode || inmode == CCCmode || inmode == CCGZmode)
    1921                 :            :         return true;
    1922                 :            :       return false;
    1923                 :            :     case ORDERED: case UNORDERED:
    1924                 :            :       if (inmode == CCmode)
    1925                 :            :         return true;
    1926                 :            :       return false;
    1927                 :            :     case GT: case LE:
    1928                 :            :       if (inmode == CCmode || inmode == CCGCmode || inmode == CCNOmode)
    1929                 :            :         return true;
    1930                 :            :       return false;
    1931                 :            :     default:
    1932                 :            :       return false;
    1933                 :            :     }
    1934                 :            : }
    1935                 :            : 
    1936                 :            : int
    1937                 :            : ix86_comparison_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1938                 :            : {
    1939                 :            :   return (comparison_operator (op, mode)) && (
    1940                 :            : (ix86_comparison_operator_1 (op, mode)));
    1941                 :            : }
    1942                 :            : 
    1943                 :            : static inline int
    1944                 :            : ix86_carry_flag_operator_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    1945                 :            : #line 1339 "../../gcc/config/i386/predicates.md"
    1946                 :            : {
    1947                 :            :   machine_mode inmode = GET_MODE (XEXP (op, 0));
    1948                 :            :   enum rtx_code code = GET_CODE (op);
    1949                 :            : 
    1950                 :            :   if (inmode == CCFPmode)
    1951                 :            :     {
    1952                 :            :       if (!ix86_trivial_fp_comparison_operator (op, mode))
    1953                 :            :         return false;
    1954                 :            :       code = ix86_fp_compare_code_to_integer (code);
    1955                 :            :     }
    1956                 :            :   else if (inmode == CCCmode)
    1957                 :            :    return code == LTU || code == GTU;
    1958                 :            :   else if (inmode != CCmode)
    1959                 :            :     return false;
    1960                 :            : 
    1961                 :            :   return code == LTU;
    1962                 :            : }
    1963                 :            : 
    1964                 :            : int
    1965                 :            : ix86_carry_flag_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1966                 :            : {
    1967                 :            :   switch (GET_CODE (op))
    1968                 :            :     {
    1969                 :            :     case LTU:
    1970                 :            :     case LT:
    1971                 :            :     case UNLT:
    1972                 :            :     case GTU:
    1973                 :            :     case GT:
    1974                 :            :     case UNGT:
    1975                 :            :     case LE:
    1976                 :            :     case UNLE:
    1977                 :            :     case GE:
    1978                 :            :     case UNGE:
    1979                 :            :     case LTGT:
    1980                 :            :     case UNEQ:
    1981                 :            :       break;
    1982                 :            :     default:
    1983                 :            :       return false;
    1984                 :            :     }
    1985                 :            :   return (
    1986                 :            : (ix86_carry_flag_operator_1 (op, mode))) && (
    1987                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    1988                 :            : }
    1989                 :            : 
    1990                 :            : int
    1991                 :            : ix86_trivial_fp_comparison_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    1992                 :            : {
    1993                 :            :   switch (GET_CODE (op))
    1994                 :            :     {
    1995                 :            :     case GT:
    1996                 :            :     case GE:
    1997                 :            :     case UNLT:
    1998                 :            :     case UNLE:
    1999                 :            :     case UNEQ:
    2000                 :            :     case LTGT:
    2001                 :            :     case ORDERED:
    2002                 :            :     case UNORDERED:
    2003                 :            :       break;
    2004                 :            :     default:
    2005                 :            :       return false;
    2006                 :            :     }
    2007                 :            :   return 
    2008                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    2009                 :            : }
    2010                 :            : 
    2011                 :            : int
    2012                 :            : ix86_fp_comparison_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2013                 :            : {
    2014                 :            :   return (
    2015                 :            : #line 1365 "../../gcc/config/i386/predicates.md"
    2016                 :            : (ix86_fp_comparison_strategy (GET_CODE (op))
    2017                 :            :                              == IX86_FPCMP_ARITH)) ? (comparison_operator (op, mode)) : (ix86_trivial_fp_comparison_operator (op, mode));
    2018                 :            : }
    2019                 :            : 
    2020                 :            : int
    2021                 :            : cmp_fp_expander_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2022                 :            : {
    2023                 :            :   return ((GET_CODE (op) == CONST_DOUBLE) && (
    2024                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode))) || (general_operand (op, mode));
    2025                 :            : }
    2026                 :            : 
    2027                 :            : int
    2028                 :            : binary_fp_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2029                 :            : {
    2030                 :            :   switch (GET_CODE (op))
    2031                 :            :     {
    2032                 :            :     case PLUS:
    2033                 :            :     case MINUS:
    2034                 :            :     case MULT:
    2035                 :            :     case DIV:
    2036                 :            :       break;
    2037                 :            :     default:
    2038                 :            :       return false;
    2039                 :            :     }
    2040                 :            :   return 
    2041                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    2042                 :            : }
    2043                 :            : 
    2044                 :            : int
    2045                 :            : mult_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2046                 :            : {
    2047                 :            :   return (GET_CODE (op) == MULT) && (
    2048                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2049                 :            : }
    2050                 :            : 
    2051                 :            : int
    2052                 :            : div_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2053                 :            : {
    2054                 :            :   return (GET_CODE (op) == DIV) && (
    2055                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2056                 :            : }
    2057                 :            : 
    2058                 :            : int
    2059                 :            : plusminuslogic_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2060                 :            : {
    2061                 :            :   switch (GET_CODE (op))
    2062                 :            :     {
    2063                 :            :     case PLUS:
    2064                 :            :     case MINUS:
    2065                 :            :     case AND:
    2066                 :            :     case IOR:
    2067                 :            :     case XOR:
    2068                 :            :       break;
    2069                 :            :     default:
    2070                 :            :       return false;
    2071                 :            :     }
    2072                 :            :   return 
    2073                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    2074                 :            : }
    2075                 :            : 
    2076                 :            : int
    2077                 :            : arith_or_logical_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2078                 :            : {
    2079                 :            :   switch (GET_CODE (op))
    2080                 :            :     {
    2081                 :            :     case PLUS:
    2082                 :            :     case MULT:
    2083                 :            :     case AND:
    2084                 :            :     case IOR:
    2085                 :            :     case XOR:
    2086                 :            :     case SMIN:
    2087                 :            :     case SMAX:
    2088                 :            :     case UMIN:
    2089                 :            :     case UMAX:
    2090                 :            :     case COMPARE:
    2091                 :            :     case MINUS:
    2092                 :            :     case DIV:
    2093                 :            :     case MOD:
    2094                 :            :     case UDIV:
    2095                 :            :     case UMOD:
    2096                 :            :     case ASHIFT:
    2097                 :            :     case ROTATE:
    2098                 :            :     case ASHIFTRT:
    2099                 :            :     case LSHIFTRT:
    2100                 :            :     case ROTATERT:
    2101                 :            :       break;
    2102                 :            :     default:
    2103                 :            :       return false;
    2104                 :            :     }
    2105                 :            :   return 
    2106                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    2107                 :            : }
    2108                 :            : 
    2109                 :            : int
    2110                 :            : commutative_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2111                 :            : {
    2112                 :            :   switch (GET_CODE (op))
    2113                 :            :     {
    2114                 :            :     case PLUS:
    2115                 :            :     case MULT:
    2116                 :            :     case AND:
    2117                 :            :     case IOR:
    2118                 :            :     case XOR:
    2119                 :            :     case SMIN:
    2120                 :            :     case SMAX:
    2121                 :            :     case UMIN:
    2122                 :            :     case UMAX:
    2123                 :            :       break;
    2124                 :            :     default:
    2125                 :            :       return false;
    2126                 :            :     }
    2127                 :            :   return 
    2128                 :            : (mode == VOIDmode || GET_MODE (op) == mode);
    2129                 :            : }
    2130                 :            : 
    2131                 :            : int
    2132                 :            : promotable_binary_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2133                 :            : {
    2134                 :            :   return ((GET_CODE (op) == PLUS || GET_CODE (op) == MINUS || GET_CODE (op) == AND || GET_CODE (op) == IOR || GET_CODE (op) == XOR || GET_CODE (op) == ASHIFT) || ((GET_CODE (op) == MULT) && (
    2135                 :            : #line 1406 "../../gcc/config/i386/predicates.md"
    2136                 :            : (TARGET_TUNE_PROMOTE_HIMODE_IMUL)))) && (
    2137                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2138                 :            : }
    2139                 :            : 
    2140                 :            : int
    2141                 :            : compare_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2142                 :            : {
    2143                 :            :   return (GET_CODE (op) == COMPARE) && (
    2144                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2145                 :            : }
    2146                 :            : 
    2147                 :            : int
    2148                 :            : misaligned_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2149                 :            : {
    2150                 :            :   return ((GET_CODE (op) == MEM) && (
    2151                 :            : #line 1415 "../../gcc/config/i386/predicates.md"
    2152                 :            : (MEM_ALIGN (op) < GET_MODE_BITSIZE (mode)))) && (
    2153                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2154                 :            : }
    2155                 :            : 
    2156                 :            : static inline int
    2157                 :            : vzeroall_operation_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2158                 :            : #line 1420 "../../gcc/config/i386/predicates.md"
    2159                 :            : {
    2160                 :            :   unsigned i, nregs = TARGET_64BIT ? 16 : 8;
    2161                 :            : 
    2162                 :            :   if ((unsigned) XVECLEN (op, 0) != 1 + nregs)
    2163                 :            :     return false;
    2164                 :            : 
    2165                 :            :   for (i = 0; i < nregs; i++)
    2166                 :            :     {
    2167                 :            :       rtx elt = XVECEXP (op, 0, i+1);
    2168                 :            : 
    2169                 :            :       if (GET_CODE (elt) != SET
    2170                 :            :           || GET_CODE (SET_DEST (elt)) != REG
    2171                 :            :           || GET_MODE (SET_DEST (elt)) != V8SImode
    2172                 :            :           || REGNO (SET_DEST (elt)) != GET_SSE_REGNO (i)
    2173                 :            :           || SET_SRC (elt) != CONST0_RTX (V8SImode))
    2174                 :            :         return false;
    2175                 :            :     }
    2176                 :            :   return true;
    2177                 :            : }
    2178                 :            : 
    2179                 :            : int
    2180                 :            : vzeroall_operation (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2181                 :            : {
    2182                 :            :   return ((GET_CODE (op) == PARALLEL) && (
    2183                 :            : (vzeroall_operation_1 (op, mode)))) && (
    2184                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2185                 :            : }
    2186                 :            : 
    2187                 :            : int
    2188                 :            : vzeroall_pattern (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2189                 :            : {
    2190                 :            :   return ((GET_CODE (op) == PARALLEL) && ((GET_CODE (XVECEXP (op, 0, 0)) == UNSPEC_VOLATILE) && (
    2191                 :            : #line 1444 "../../gcc/config/i386/predicates.md"
    2192                 :            : (XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROALL)))) && (
    2193                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2194                 :            : }
    2195                 :            : 
    2196                 :            : int
    2197                 :            : vzeroupper_pattern (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2198                 :            : {
    2199                 :            :   return ((GET_CODE (op) == PARALLEL) && ((GET_CODE (XVECEXP (op, 0, 0)) == UNSPEC_VOLATILE) && (
    2200                 :            : #line 1450 "../../gcc/config/i386/predicates.md"
    2201                 :            : (XINT (XVECEXP (op, 0, 0), 1) == UNSPECV_VZEROUPPER)))) && (
    2202                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2203                 :            : }
    2204                 :            : 
    2205                 :            : static inline int
    2206                 :            : addsub_vm_operator_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2207                 :            : #line 1455 "../../gcc/config/i386/predicates.md"
    2208                 :            : {
    2209                 :            :   rtx op0, op1;
    2210                 :            :   int swapped;
    2211                 :            :   HOST_WIDE_INT mask;
    2212                 :            :   int nunits, elt;
    2213                 :            : 
    2214                 :            :   op0 = XEXP (op, 0);
    2215                 :            :   op1 = XEXP (op, 1);
    2216                 :            : 
    2217                 :            :   /* Sanity check.  */
    2218                 :            :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    2219                 :            :     swapped = 0;
    2220                 :            :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    2221                 :            :     swapped = 1;
    2222                 :            :   else
    2223                 :            :     gcc_unreachable ();
    2224                 :            : 
    2225                 :            :   mask = INTVAL (XEXP (op, 2));
    2226                 :            :   nunits = GET_MODE_NUNITS (mode);
    2227                 :            : 
    2228                 :            :   for (elt = 0; elt < nunits; elt++)
    2229                 :            :     {
    2230                 :            :       /* bit clear: take from op0, set: take from op1  */
    2231                 :            :       int bit = !(mask & (HOST_WIDE_INT_1U << elt));
    2232                 :            : 
    2233                 :            :       if (bit != ((elt & 1) ^ swapped))
    2234                 :            :         return false;
    2235                 :            :     }
    2236                 :            : 
    2237                 :            :   return true;
    2238                 :            : }
    2239                 :            : 
    2240                 :            : int
    2241                 :            : addsub_vm_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2242                 :            : {
    2243                 :            :   return ((GET_CODE (op) == VEC_MERGE) && (
    2244                 :            : (addsub_vm_operator_1 (op, mode)))) && (
    2245                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2246                 :            : }
    2247                 :            : 
    2248                 :            : static inline int
    2249                 :            : addsub_vs_operator_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2250                 :            : #line 1491 "../../gcc/config/i386/predicates.md"
    2251                 :            : {
    2252                 :            :   rtx op0, op1;
    2253                 :            :   bool swapped;
    2254                 :            :   int nunits, elt;
    2255                 :            : 
    2256                 :            :   op0 = XEXP (XEXP (op, 0), 0);
    2257                 :            :   op1 = XEXP (XEXP (op, 0), 1);
    2258                 :            : 
    2259                 :            :   /* Sanity check.  */
    2260                 :            :   if (GET_CODE (op0) == MINUS && GET_CODE (op1) == PLUS)
    2261                 :            :     swapped = false;
    2262                 :            :   else if (GET_CODE (op0) == PLUS && GET_CODE (op1) == MINUS)
    2263                 :            :     swapped = true;
    2264                 :            :   else
    2265                 :            :     gcc_unreachable ();
    2266                 :            : 
    2267                 :            :   nunits = GET_MODE_NUNITS (mode);
    2268                 :            :   if (XVECLEN (XEXP (op, 1), 0) != nunits)
    2269                 :            :     return false;
    2270                 :            : 
    2271                 :            :   /* We already checked that permutation is suitable for addsub,
    2272                 :            :      so only look at the first element of the parallel.  */
    2273                 :            :   elt = INTVAL (XVECEXP (XEXP (op, 1), 0, 0));
    2274                 :            : 
    2275                 :            :   return elt == (swapped ? nunits : 0);
    2276                 :            : }
    2277                 :            : 
    2278                 :            : int
    2279                 :            : addsub_vs_operator (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2280                 :            : {
    2281                 :            :   return (((GET_CODE (op) == VEC_SELECT) && (GET_CODE (XEXP (op, 0)) == VEC_CONCAT)) && (
    2282                 :            : (addsub_vs_operator_1 (op, mode)))) && (
    2283                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2284                 :            : }
    2285                 :            : 
    2286                 :            : static inline int
    2287                 :            : addsub_vs_parallel_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2288                 :            : #line 1522 "../../gcc/config/i386/predicates.md"
    2289                 :            : {
    2290                 :            :   int nelt = XVECLEN (op, 0);
    2291                 :            :   int elt, i;
    2292                 :            :   
    2293                 :            :   if (nelt < 2)
    2294                 :            :     return false;
    2295                 :            : 
    2296                 :            :   /* Check that the permutation is suitable for addsub.
    2297                 :            :      For example, { 0 9 2 11 4 13 6 15 } or { 8 1 10 3 12 5 14 7 }.  */
    2298                 :            :   elt = INTVAL (XVECEXP (op, 0, 0));
    2299                 :            :   if (elt == 0)
    2300                 :            :     {
    2301                 :            :       for (i = 1; i < nelt; ++i)
    2302                 :            :         if (INTVAL (XVECEXP (op, 0, i)) != (i + (i & 1) * nelt))
    2303                 :            :           return false;
    2304                 :            :     }
    2305                 :            :   else if (elt == nelt)
    2306                 :            :     {
    2307                 :            :       for (i = 1; i < nelt; ++i)
    2308                 :            :         if (INTVAL (XVECEXP (op, 0, i)) != (elt + i - (i & 1) * nelt))
    2309                 :            :           return false;
    2310                 :            :     }
    2311                 :            :   else
    2312                 :            :     return false;
    2313                 :            : 
    2314                 :            :   return true;
    2315                 :            : }
    2316                 :            : 
    2317                 :            : int
    2318                 :            : addsub_vs_parallel (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2319                 :            : {
    2320                 :            :   return (((GET_CODE (op) == PARALLEL) && (GET_CODE (XVECEXP (op, 0, 0)) == CONST_INT)) && (
    2321                 :            : (addsub_vs_parallel_1 (op, mode)))) && (
    2322                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2323                 :            : }
    2324                 :            : 
    2325                 :            : static inline int
    2326                 :            : avx_vbroadcast_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2327                 :            : #line 1554 "../../gcc/config/i386/predicates.md"
    2328                 :            : {
    2329                 :            :   rtx elt = XVECEXP (op, 0, 0);
    2330                 :            :   int i, nelt = XVECLEN (op, 0);
    2331                 :            : 
    2332                 :            :   /* Don't bother checking there are the right number of operands,
    2333                 :            :      merely that they're all identical.  */
    2334                 :            :   for (i = 1; i < nelt; ++i)
    2335                 :            :     if (XVECEXP (op, 0, i) != elt)
    2336                 :            :       return false;
    2337                 :            :   return true;
    2338                 :            : }
    2339                 :            : 
    2340                 :            : int
    2341                 :            : avx_vbroadcast_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2342                 :            : {
    2343                 :            :   return (((GET_CODE (op) == PARALLEL) && (GET_CODE (XVECEXP (op, 0, 0)) == CONST_INT)) && (
    2344                 :            : (avx_vbroadcast_operand_1 (op, mode)))) && (
    2345                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2346                 :            : }
    2347                 :            : 
    2348                 :            : static inline int
    2349                 :            : palignr_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2350                 :            : #line 1570 "../../gcc/config/i386/predicates.md"
    2351                 :            : {
    2352                 :            :   int elt = INTVAL (XVECEXP (op, 0, 0));
    2353                 :            :   int i, nelt = XVECLEN (op, 0);
    2354                 :            : 
    2355                 :            :   /* Check that an order in the permutation is suitable for palignr.
    2356                 :            :      For example, {5 6 7 0 1 2 3 4} is "palignr 5, xmm, xmm".  */
    2357                 :            :   for (i = 1; i < nelt; ++i)
    2358                 :            :     if (INTVAL (XVECEXP (op, 0, i)) != ((elt + i) % nelt))
    2359                 :            :       return false;
    2360                 :            :   return true;
    2361                 :            : }
    2362                 :            : 
    2363                 :            : int
    2364                 :            : palignr_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2365                 :            : {
    2366                 :            :   return (((GET_CODE (op) == PARALLEL) && (GET_CODE (XVECEXP (op, 0, 0)) == CONST_INT)) && (
    2367                 :            : (palignr_operand_1 (op, mode)))) && (
    2368                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2369                 :            : }
    2370                 :            : 
    2371                 :            : static inline int
    2372                 :            : avx2_pblendw_operand_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2373                 :            : #line 1585 "../../gcc/config/i386/predicates.md"
    2374                 :            : {
    2375                 :            :   HOST_WIDE_INT val = INTVAL (op);
    2376                 :            :   HOST_WIDE_INT low = val & 0xff;
    2377                 :            :   return val == ((low << 8) | low);
    2378                 :            : }
    2379                 :            : 
    2380                 :            : int
    2381                 :            : avx2_pblendw_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2382                 :            : {
    2383                 :            :   return (GET_CODE (op) == CONST_INT) && (
    2384                 :            : (avx2_pblendw_operand_1 (op, mode)));
    2385                 :            : }
    2386                 :            : 
    2387                 :            : int
    2388                 :            : general_vector_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2389                 :            : {
    2390                 :            :   return (vector_operand (op, mode)) || ((GET_CODE (op) == CONST_VECTOR) && (
    2391                 :            : (mode == VOIDmode || GET_MODE (op) == mode)));
    2392                 :            : }
    2393                 :            : 
    2394                 :            : int
    2395                 :            : register_or_constm1_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2396                 :            : {
    2397                 :            :   return (register_operand (op, mode)) || (((GET_CODE (op) == CONST_INT) && (
    2398                 :            : #line 1600 "../../gcc/config/i386/predicates.md"
    2399                 :            : (op == constm1_rtx))) && (
    2400                 :            : (mode == VOIDmode || GET_MODE (op) == mode || GET_MODE (op) == VOIDmode)));
    2401                 :            : }
    2402                 :            : 
    2403                 :            : static inline int
    2404                 :            : save_multiple_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2405                 :            : #line 1606 "../../gcc/config/i386/predicates.md"
    2406                 :            : {
    2407                 :            :   const unsigned len = XVECLEN (op, 0);
    2408                 :            :   unsigned i;
    2409                 :            : 
    2410                 :            :   /* Starting from end of vector, count register saves.  */
    2411                 :            :   for (i = 0; i < len; ++i)
    2412                 :            :     {
    2413                 :            :       rtx src, dest, addr;
    2414                 :            :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2415                 :            : 
    2416                 :            :       if (GET_CODE (e) != SET)
    2417                 :            :         break;
    2418                 :            : 
    2419                 :            :       src  = SET_SRC (e);
    2420                 :            :       dest = SET_DEST (e);
    2421                 :            : 
    2422                 :            :       if (!REG_P (src) || !MEM_P (dest))
    2423                 :            :         break;
    2424                 :            : 
    2425                 :            :       addr = XEXP (dest, 0);
    2426                 :            : 
    2427                 :            :       /* Good if dest address is in RAX.  */
    2428                 :            :       if (REG_P (addr) && REGNO (addr) == AX_REG)
    2429                 :            :         continue;
    2430                 :            : 
    2431                 :            :       /* Good if dest address is offset of RAX.  */
    2432                 :            :       if (GET_CODE (addr) == PLUS
    2433                 :            :           && REG_P (XEXP (addr, 0))
    2434                 :            :           && REGNO (XEXP (addr, 0)) == AX_REG)
    2435                 :            :         continue;
    2436                 :            : 
    2437                 :            :       break;
    2438                 :            :     }
    2439                 :            :   return (i >= 12 && i <= 18);
    2440                 :            : }
    2441                 :            : 
    2442                 :            : int
    2443                 :            : save_multiple (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2444                 :            : {
    2445                 :            :   return ((GET_CODE (op) == PARALLEL) && (
    2446                 :            : (save_multiple_1 (op, mode)))) && (
    2447                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2448                 :            : }
    2449                 :            : 
    2450                 :            : static inline int
    2451                 :            : restore_multiple_1 (rtx op ATTRIBUTE_UNUSED, machine_mode mode ATTRIBUTE_UNUSED)
    2452                 :            : #line 1647 "../../gcc/config/i386/predicates.md"
    2453                 :            : {
    2454                 :            :   const unsigned len = XVECLEN (op, 0);
    2455                 :            :   unsigned i;
    2456                 :            : 
    2457                 :            :   /* Starting from end of vector, count register restores.  */
    2458                 :            :   for (i = 0; i < len; ++i)
    2459                 :            :     {
    2460                 :            :       rtx src, dest, addr;
    2461                 :            :       rtx e = XVECEXP (op, 0, len - 1 - i);
    2462                 :            : 
    2463                 :            :       if (GET_CODE (e) != SET)
    2464                 :            :         break;
    2465                 :            : 
    2466                 :            :       src  = SET_SRC (e);
    2467                 :            :       dest = SET_DEST (e);
    2468                 :            : 
    2469                 :            :       if (!MEM_P (src) || !REG_P (dest))
    2470                 :            :         break;
    2471                 :            : 
    2472                 :            :       addr = XEXP (src, 0);
    2473                 :            : 
    2474                 :            :       /* Good if src address is in RSI.  */
    2475                 :            :       if (REG_P (addr) && REGNO (addr) == SI_REG)
    2476                 :            :         continue;
    2477                 :            : 
    2478                 :            :       /* Good if src address is offset of RSI.  */
    2479                 :            :       if (GET_CODE (addr) == PLUS
    2480                 :            :           && REG_P (XEXP (addr, 0))
    2481                 :            :           && REGNO (XEXP (addr, 0)) == SI_REG)
    2482                 :            :         continue;
    2483                 :            : 
    2484                 :            :       break;
    2485                 :            :     }
    2486                 :            :   return (i >= 12 && i <= 18);
    2487                 :            : }
    2488                 :            : 
    2489                 :            : int
    2490                 :            : restore_multiple (rtx op, machine_mode mode ATTRIBUTE_UNUSED)
    2491                 :            : {
    2492                 :            :   return ((GET_CODE (op) == PARALLEL) && (
    2493                 :            : (restore_multiple_1 (op, mode)))) && (
    2494                 :            : (mode == VOIDmode || GET_MODE (op) == mode));
    2495                 :            : }
    2496                 :            : 
    2497                 :            : enum constraint_num
    2498                 :            : lookup_constraint_1 (const char *str)
    2499                 :            : {
    2500                 :            :   switch (str[0])
    2501                 :            :     {
    2502                 :            :     case '<':
    2503                 :            :       return CONSTRAINT__l;
    2504                 :            :     case '>':
    2505                 :            :       return CONSTRAINT__g;
    2506                 :            :     case 'A':
    2507                 :            :       return CONSTRAINT_A;
    2508                 :            :     case 'B':
    2509                 :            :       if (!strncmp (str + 1, "g", 1))
    2510                 :            :         return CONSTRAINT_Bg;
    2511                 :            :       if (!strncmp (str + 1, "m", 1))
    2512                 :            :         return CONSTRAINT_Bm;
    2513                 :            :       if (!strncmp (str + 1, "c", 1))
    2514                 :            :         return CONSTRAINT_Bc;
    2515                 :            :       if (!strncmp (str + 1, "n", 1))
    2516                 :            :         return CONSTRAINT_Bn;
    2517                 :            :       if (!strncmp (str + 1, "s", 1))
    2518                 :            :         return CONSTRAINT_Bs;
    2519                 :            :       if (!strncmp (str + 1, "w", 1))
    2520                 :            :         return CONSTRAINT_Bw;
    2521                 :            :       if (!strncmp (str + 1, "z", 1))
    2522                 :            :         return CONSTRAINT_Bz;
    2523                 :            :       if (!strncmp (str + 1, "C", 1))
    2524                 :            :         return CONSTRAINT_BC;
    2525                 :            :       if (!strncmp (str + 1, "f", 1))
    2526                 :            :         return CONSTRAINT_Bf;
    2527                 :            :       break;
    2528                 :            :     case 'C':
    2529                 :            :       return CONSTRAINT_C;
    2530                 :            :     case 'D':
    2531                 :            :       return CONSTRAINT_D;
    2532                 :            :     case 'E':
    2533                 :            :       return CONSTRAINT_E;
    2534                 :            :     case 'F':
    2535                 :            :       return CONSTRAINT_F;
    2536                 :            :     case 'G':
    2537                 :            :       return CONSTRAINT_G;
    2538                 :            :     case 'I':
    2539                 :            :       return CONSTRAINT_I;
    2540                 :            :     case 'J':
    2541                 :            :       return CONSTRAINT_J;
    2542                 :            :     case 'K':
    2543                 :            :       return CONSTRAINT_K;
    2544                 :            :     case 'L':
    2545                 :            :       return CONSTRAINT_L;
    2546                 :            :     case 'M':
    2547                 :            :       return CONSTRAINT_M;
    2548                 :            :     case 'N':
    2549                 :            :       return CONSTRAINT_N;
    2550                 :            :     case 'O':
    2551                 :            :       return CONSTRAINT_O;
    2552                 :            :     case 'Q':
    2553                 :            :       return CONSTRAINT_Q;
    2554                 :            :     case 'R':
    2555                 :            :       return CONSTRAINT_R;
    2556                 :            :     case 'S':
    2557                 :            :       return CONSTRAINT_S;
    2558                 :            :     case 'T':
    2559                 :            :       if (!strncmp (str + 1, "s", 1))
    2560                 :            :         return CONSTRAINT_Ts;
    2561                 :            :       if (!strncmp (str + 1, "v", 1))
    2562                 :            :         return CONSTRAINT_Tv;
    2563                 :            :       break;
    2564                 :            :     case 'U':
    2565                 :            :       return CONSTRAINT_U;
    2566                 :            :     case 'V':
    2567                 :            :       return CONSTRAINT_V;
    2568                 :            :     case 'W':
    2569                 :            :       if (!strncmp (str + 1, "z", 1))
    2570                 :            :         return CONSTRAINT_Wz;
    2571                 :            :       if (!strncmp (str + 1, "d", 1))
    2572                 :            :         return CONSTRAINT_Wd;
    2573                 :            :       if (!strncmp (str + 1, "f", 1))
    2574                 :            :         return CONSTRAINT_Wf;
    2575                 :            :       if (!strncmp (str + 1, "e", 1))
    2576                 :            :         return CONSTRAINT_We;
    2577                 :            :       break;
    2578                 :            :     case 'X':
    2579                 :            :       return CONSTRAINT_X;
    2580                 :            :     case 'Y':
    2581                 :            :       if (!strncmp (str + 1, "z", 1))
    2582                 :            :         return CONSTRAINT_Yz;
    2583                 :            :       if (!strncmp (str + 1, "d", 1))
    2584                 :            :         return CONSTRAINT_Yd;
    2585                 :            :       if (!strncmp (str + 1, "p", 1))
    2586                 :            :         return CONSTRAINT_Yp;
    2587                 :            :       if (!strncmp (str + 1, "a", 1))
    2588                 :            :         return CONSTRAINT_Ya;
    2589                 :            :       if (!strncmp (str + 1, "b", 1))
    2590                 :            :         return CONSTRAINT_Yb;
    2591                 :            :       if (!strncmp (str + 1, "f", 1))
    2592                 :            :         return CONSTRAINT_Yf;
    2593                 :            :       if (!strncmp (str + 1, "r", 1))
    2594                 :            :         return CONSTRAINT_Yr;
    2595                 :            :       if (!strncmp (str + 1, "v", 1))
    2596                 :            :         return CONSTRAINT_Yv;
    2597                 :            :       if (!strncmp (str + 1, "w", 1))
    2598                 :            :         return CONSTRAINT_Yw;
    2599                 :            :       if (!strncmp (str + 1, "k", 1))
    2600                 :            :         return CONSTRAINT_Yk;
    2601                 :            :       break;
    2602                 :            :     case 'Z':
    2603                 :            :       return CONSTRAINT_Z;
    2604                 :            :     case 'a':
    2605                 :            :       return CONSTRAINT_a;
    2606                 :            :     case 'b':
    2607                 :            :       return CONSTRAINT_b;
    2608                 :            :     case 'c':
    2609                 :            :       return CONSTRAINT_c;
    2610                 :            :     case 'd':
    2611                 :            :       return CONSTRAINT_d;
    2612                 :            :     case 'e':
    2613                 :            :       return CONSTRAINT_e;
    2614                 :            :     case 'f':
    2615                 :            :       return CONSTRAINT_f;
    2616                 :            :     case 'i':
    2617                 :            :       return CONSTRAINT_i;
    2618                 :            :     case 'k':
    2619                 :            :       return CONSTRAINT_k;
    2620                 :            :     case 'l':
    2621                 :            :       return CONSTRAINT_l;
    2622                 :            :     case 'm':
    2623                 :            :       return CONSTRAINT_m;
    2624                 :            :     case 'n':
    2625                 :            :       return CONSTRAINT_n;
    2626                 :            :     case 'o':
    2627                 :            :       return CONSTRAINT_o;
    2628                 :            :     case 'p':
    2629                 :            :       return CONSTRAINT_p;
    2630                 :            :     case 'q':
    2631                 :            :       return CONSTRAINT_q;
    2632                 :            :     case 'r':
    2633                 :            :       return CONSTRAINT_r;
    2634                 :            :     case 's':
    2635                 :            :       return CONSTRAINT_s;
    2636                 :            :     case 't':
    2637                 :            :       return CONSTRAINT_t;
    2638                 :            :     case 'u':
    2639                 :            :       return CONSTRAINT_u;
    2640                 :            :     case 'v':
    2641                 :            :       return CONSTRAINT_v;
    2642                 :            :     case 'x':
    2643                 :            :       return CONSTRAINT_x;
    2644                 :            :     case 'y':
    2645                 :            :       return CONSTRAINT_y;
    2646                 :            :     default: break;
    2647                 :            :     }
    2648                 :            :   return CONSTRAINT__UNKNOWN;
    2649                 :            : }
    2650                 :            : 
    2651                 :            : const unsigned char lookup_constraint_array[] = {
    2652                 :            :   CONSTRAINT__UNKNOWN,
    2653                 :            :   CONSTRAINT__UNKNOWN,
    2654                 :            :   CONSTRAINT__UNKNOWN,
    2655                 :            :   CONSTRAINT__UNKNOWN,
    2656                 :            :   CONSTRAINT__UNKNOWN,
    2657                 :            :   CONSTRAINT__UNKNOWN,
    2658                 :            :   CONSTRAINT__UNKNOWN,
    2659                 :            :   CONSTRAINT__UNKNOWN,
    2660                 :            :   CONSTRAINT__UNKNOWN,
    2661                 :            :   CONSTRAINT__UNKNOWN,
    2662                 :            :   CONSTRAINT__UNKNOWN,
    2663                 :            :   CONSTRAINT__UNKNOWN,
    2664                 :            :   CONSTRAINT__UNKNOWN,
    2665                 :            :   CONSTRAINT__UNKNOWN,
    2666                 :            :   CONSTRAINT__UNKNOWN,
    2667                 :            :   CONSTRAINT__UNKNOWN,
    2668                 :            :   CONSTRAINT__UNKNOWN,
    2669                 :            :   CONSTRAINT__UNKNOWN,
    2670                 :            :   CONSTRAINT__UNKNOWN,
    2671                 :            :   CONSTRAINT__UNKNOWN,
    2672                 :            :   CONSTRAINT__UNKNOWN,
    2673                 :            :   CONSTRAINT__UNKNOWN,
    2674                 :            :   CONSTRAINT__UNKNOWN,
    2675                 :            :   CONSTRAINT__UNKNOWN,
    2676                 :            :   CONSTRAINT__UNKNOWN,
    2677                 :            :   CONSTRAINT__UNKNOWN,
    2678                 :            :   CONSTRAINT__UNKNOWN,
    2679                 :            :   CONSTRAINT__UNKNOWN,
    2680                 :            :   CONSTRAINT__UNKNOWN,
    2681                 :            :   CONSTRAINT__UNKNOWN,
    2682                 :            :   CONSTRAINT__UNKNOWN,
    2683                 :            :   CONSTRAINT__UNKNOWN,
    2684                 :            :   CONSTRAINT__UNKNOWN,
    2685                 :            :   CONSTRAINT__UNKNOWN,
    2686                 :            :   CONSTRAINT__UNKNOWN,
    2687                 :            :   CONSTRAINT__UNKNOWN,
    2688                 :            :   CONSTRAINT__UNKNOWN,
    2689                 :            :   CONSTRAINT__UNKNOWN,
    2690                 :            :   CONSTRAINT__UNKNOWN,
    2691                 :            :   CONSTRAINT__UNKNOWN,
    2692                 :            :   CONSTRAINT__UNKNOWN,
    2693                 :            :   CONSTRAINT__UNKNOWN,
    2694                 :            :   CONSTRAINT__UNKNOWN,
    2695                 :            :   CONSTRAINT__UNKNOWN,
    2696                 :            :   CONSTRAINT__UNKNOWN,
    2697                 :            :   CONSTRAINT__UNKNOWN,
    2698                 :            :   CONSTRAINT__UNKNOWN,
    2699                 :            :   CONSTRAINT__UNKNOWN,
    2700                 :            :   CONSTRAINT__UNKNOWN,
    2701                 :            :   CONSTRAINT__UNKNOWN,
    2702                 :            :   CONSTRAINT__UNKNOWN,
    2703                 :            :   CONSTRAINT__UNKNOWN,
    2704                 :            :   CONSTRAINT__UNKNOWN,
    2705                 :            :   CONSTRAINT__UNKNOWN,
    2706                 :            :   CONSTRAINT__UNKNOWN,
    2707                 :            :   CONSTRAINT__UNKNOWN,
    2708                 :            :   CONSTRAINT__UNKNOWN,
    2709                 :            :   CONSTRAINT__UNKNOWN,
    2710                 :            :   CONSTRAINT__UNKNOWN,
    2711                 :            :   CONSTRAINT__UNKNOWN,
    2712                 :            :   MIN ((int) CONSTRAINT__l, (int) UCHAR_MAX),
    2713                 :            :   CONSTRAINT__UNKNOWN,
    2714                 :            :   MIN ((int) CONSTRAINT__g, (int) UCHAR_MAX),
    2715                 :            :   CONSTRAINT__UNKNOWN,
    2716                 :            :   CONSTRAINT__UNKNOWN,
    2717                 :            :   MIN ((int) CONSTRAINT_A, (int) UCHAR_MAX),
    2718                 :            :   UCHAR_MAX,
    2719                 :            :   MIN ((int) CONSTRAINT_C, (int) UCHAR_MAX),
    2720                 :            :   MIN ((int) CONSTRAINT_D, (int) UCHAR_MAX),
    2721                 :            :   MIN ((int) CONSTRAINT_E, (int) UCHAR_MAX),
    2722                 :            :   MIN ((int) CONSTRAINT_F, (int) UCHAR_MAX),
    2723                 :            :   MIN ((int) CONSTRAINT_G, (int) UCHAR_MAX),
    2724                 :            :   CONSTRAINT__UNKNOWN,
    2725                 :            :   MIN ((int) CONSTRAINT_I, (int) UCHAR_MAX),
    2726                 :            :   MIN ((int) CONSTRAINT_J, (int) UCHAR_MAX),
    2727                 :            :   MIN ((int) CONSTRAINT_K, (int) UCHAR_MAX),
    2728                 :            :   MIN ((int) CONSTRAINT_L, (int) UCHAR_MAX),
    2729                 :            :   MIN ((int) CONSTRAINT_M, (int) UCHAR_MAX),
    2730                 :            :   MIN ((int) CONSTRAINT_N, (int) UCHAR_MAX),
    2731                 :            :   MIN ((int) CONSTRAINT_O, (int) UCHAR_MAX),
    2732                 :            :   CONSTRAINT__UNKNOWN,
    2733                 :            :   MIN ((int) CONSTRAINT_Q, (int) UCHAR_MAX),
    2734                 :            :   MIN ((int) CONSTRAINT_R, (int) UCHAR_MAX),
    2735                 :            :   MIN ((int) CONSTRAINT_S, (int) UCHAR_MAX),
    2736                 :            :   UCHAR_MAX,
    2737                 :            :   MIN ((int) CONSTRAINT_U, (int) UCHAR_MAX),
    2738                 :            :   MIN ((int) CONSTRAINT_V, (int) UCHAR_MAX),
    2739                 :            :   UCHAR_MAX,
    2740                 :            :   MIN ((int) CONSTRAINT_X, (int) UCHAR_MAX),
    2741                 :            :   UCHAR_MAX,
    2742                 :            :   MIN ((int) CONSTRAINT_Z, (int) UCHAR_MAX),
    2743                 :            :   CONSTRAINT__UNKNOWN,
    2744                 :            :   CONSTRAINT__UNKNOWN,
    2745                 :            :   CONSTRAINT__UNKNOWN,
    2746                 :            :   CONSTRAINT__UNKNOWN,
    2747                 :            :   CONSTRAINT__UNKNOWN,
    2748                 :            :   CONSTRAINT__UNKNOWN,
    2749                 :            :   MIN ((int) CONSTRAINT_a, (int) UCHAR_MAX),
    2750                 :            :   MIN ((int) CONSTRAINT_b, (int) UCHAR_MAX),
    2751                 :            :   MIN ((int) CONSTRAINT_c, (int) UCHAR_MAX),
    2752                 :            :   MIN ((int) CONSTRAINT_d, (int) UCHAR_MAX),
    2753                 :            :   MIN ((int) CONSTRAINT_e, (int) UCHAR_MAX),
    2754                 :            :   MIN ((int) CONSTRAINT_f, (int) UCHAR_MAX),
    2755                 :            :   CONSTRAINT__UNKNOWN,
    2756                 :            :   CONSTRAINT__UNKNOWN,
    2757                 :            :   MIN ((int) CONSTRAINT_i, (int) UCHAR_MAX),
    2758                 :            :   CONSTRAINT__UNKNOWN,
    2759                 :            :   MIN ((int) CONSTRAINT_k, (int) UCHAR_MAX),
    2760                 :            :   MIN ((int) CONSTRAINT_l, (int) UCHAR_MAX),
    2761                 :            :   MIN ((int) CONSTRAINT_m, (int) UCHAR_MAX),
    2762                 :            :   MIN ((int) CONSTRAINT_n, (int) UCHAR_MAX),
    2763                 :            :   MIN ((int) CONSTRAINT_o, (int) UCHAR_MAX),
    2764                 :            :   MIN ((int) CONSTRAINT_p, (int) UCHAR_MAX),
    2765                 :            :   MIN ((int) CONSTRAINT_q, (int) UCHAR_MAX),
    2766                 :            :   MIN ((int) CONSTRAINT_r, (int) UCHAR_MAX),
    2767                 :            :   MIN ((int) CONSTRAINT_s, (int) UCHAR_MAX),
    2768                 :            :   MIN ((int) CONSTRAINT_t, (int) UCHAR_MAX),
    2769                 :            :   MIN ((int) CONSTRAINT_u, (int) UCHAR_MAX),
    2770                 :            :   MIN ((int) CONSTRAINT_v, (int) UCHAR_MAX),
    2771                 :            :   CONSTRAINT__UNKNOWN,
    2772                 :            :   MIN ((int) CONSTRAINT_x, (int) UCHAR_MAX),
    2773                 :            :   MIN ((int) CONSTRAINT_y, (int) UCHAR_MAX),
    2774                 :            :   CONSTRAINT__UNKNOWN,
    2775                 :            :   CONSTRAINT__UNKNOWN,
    2776                 :            :   CONSTRAINT__UNKNOWN,
    2777                 :            :   CONSTRAINT__UNKNOWN,
    2778                 :            :   CONSTRAINT__UNKNOWN,
    2779                 :            :   CONSTRAINT__UNKNOWN,
    2780                 :            :   CONSTRAINT__UNKNOWN,
    2781                 :            :   CONSTRAINT__UNKNOWN,
    2782                 :            :   CONSTRAINT__UNKNOWN,
    2783                 :            :   CONSTRAINT__UNKNOWN,
    2784                 :            :   CONSTRAINT__UNKNOWN,
    2785                 :            :   CONSTRAINT__UNKNOWN,
    2786                 :            :   CONSTRAINT__UNKNOWN,
    2787                 :            :   CONSTRAINT__UNKNOWN,
    2788                 :            :   CONSTRAINT__UNKNOWN,
    2789                 :            :   CONSTRAINT__UNKNOWN,
    2790                 :            :   CONSTRAINT__UNKNOWN,
    2791                 :            :   CONSTRAINT__UNKNOWN,
    2792                 :            :   CONSTRAINT__UNKNOWN,
    2793                 :            :   CONSTRAINT__UNKNOWN,
    2794                 :            :   CONSTRAINT__UNKNOWN,
    2795                 :            :   CONSTRAINT__UNKNOWN,
    2796                 :            :   CONSTRAINT__UNKNOWN,
    2797                 :            :   CONSTRAINT__UNKNOWN,
    2798                 :            :   CONSTRAINT__UNKNOWN,
    2799                 :            :   CONSTRAINT__UNKNOWN,
    2800                 :            :   CONSTRAINT__UNKNOWN,
    2801                 :            :   CONSTRAINT__UNKNOWN,
    2802                 :            :   CONSTRAINT__UNKNOWN,
    2803                 :            :   CONSTRAINT__UNKNOWN,
    2804                 :            :   CONSTRAINT__UNKNOWN,
    2805                 :            :   CONSTRAINT__UNKNOWN,
    2806                 :            :   CONSTRAINT__UNKNOWN,
    2807                 :            :   CONSTRAINT__UNKNOWN,
    2808                 :            :   CONSTRAINT__UNKNOWN,
    2809                 :            :   CONSTRAINT__UNKNOWN,
    2810                 :            :   CONSTRAINT__UNKNOWN,
    2811                 :            :   CONSTRAINT__UNKNOWN,
    2812                 :            :   CONSTRAINT__UNKNOWN,
    2813                 :            :   CONSTRAINT__UNKNOWN,
    2814                 :            :   CONSTRAINT__UNKNOWN,
    2815                 :            :   CONSTRAINT__UNKNOWN,
    2816                 :            :   CONSTRAINT__UNKNOWN,
    2817                 :            :   CONSTRAINT__UNKNOWN,
    2818                 :            :   CONSTRAINT__UNKNOWN,
    2819                 :            :   CONSTRAINT__UNKNOWN,
    2820                 :            :   CONSTRAINT__UNKNOWN,
    2821                 :            :   CONSTRAINT__UNKNOWN,
    2822                 :            :   CONSTRAINT__UNKNOWN,
    2823                 :            :   CONSTRAINT__UNKNOWN,
    2824                 :            :   CONSTRAINT__UNKNOWN,
    2825                 :            :   CONSTRAINT__UNKNOWN,
    2826                 :            :   CONSTRAINT__UNKNOWN,
    2827                 :            :   CONSTRAINT__UNKNOWN,
    2828                 :            :   CONSTRAINT__UNKNOWN,
    2829                 :            :   CONSTRAINT__UNKNOWN,
    2830                 :            :   CONSTRAINT__UNKNOWN,
    2831                 :            :   CONSTRAINT__UNKNOWN,
    2832                 :            :   CONSTRAINT__UNKNOWN,
    2833                 :            :   CONSTRAINT__UNKNOWN,
    2834                 :            :   CONSTRAINT__UNKNOWN,
    2835                 :            :   CONSTRAINT__UNKNOWN,
    2836                 :            :   CONSTRAINT__UNKNOWN,
    2837                 :            :   CONSTRAINT__UNKNOWN,
    2838                 :            :   CONSTRAINT__UNKNOWN,
    2839                 :            :   CONSTRAINT__UNKNOWN,
    2840                 :            :   CONSTRAINT__UNKNOWN,
    2841                 :            :   CONSTRAINT__UNKNOWN,
    2842                 :            :   CONSTRAINT__UNKNOWN,
    2843                 :            :   CONSTRAINT__UNKNOWN,
    2844                 :            :   CONSTRAINT__UNKNOWN,
    2845                 :            :   CONSTRAINT__UNKNOWN,
    2846                 :            :   CONSTRAINT__UNKNOWN,
    2847                 :            :   CONSTRAINT__UNKNOWN,
    2848                 :            :   CONSTRAINT__UNKNOWN,
    2849                 :            :   CONSTRAINT__UNKNOWN,
    2850                 :            :   CONSTRAINT__UNKNOWN,
    2851                 :            :   CONSTRAINT__UNKNOWN,
    2852                 :            :   CONSTRAINT__UNKNOWN,
    2853                 :            :   CONSTRAINT__UNKNOWN,
    2854                 :            :   CONSTRAINT__UNKNOWN,
    2855                 :            :   CONSTRAINT__UNKNOWN,
    2856                 :            :   CONSTRAINT__UNKNOWN,
    2857                 :            :   CONSTRAINT__UNKNOWN,
    2858                 :            :   CONSTRAINT__UNKNOWN,
    2859                 :            :   CONSTRAINT__UNKNOWN,
    2860                 :            :   CONSTRAINT__UNKNOWN,
    2861                 :            :   CONSTRAINT__UNKNOWN,
    2862                 :            :   CONSTRAINT__UNKNOWN,
    2863                 :            :   CONSTRAINT__UNKNOWN,
    2864                 :            :   CONSTRAINT__UNKNOWN,
    2865                 :            :   CONSTRAINT__UNKNOWN,
    2866                 :            :   CONSTRAINT__UNKNOWN,
    2867                 :            :   CONSTRAINT__UNKNOWN,
    2868                 :            :   CONSTRAINT__UNKNOWN,
    2869                 :            :   CONSTRAINT__UNKNOWN,
    2870                 :            :   CONSTRAINT__UNKNOWN,
    2871                 :            :   CONSTRAINT__UNKNOWN,
    2872                 :            :   CONSTRAINT__UNKNOWN,
    2873                 :            :   CONSTRAINT__UNKNOWN,
    2874                 :            :   CONSTRAINT__UNKNOWN,
    2875                 :            :   CONSTRAINT__UNKNOWN,
    2876                 :            :   CONSTRAINT__UNKNOWN,
    2877                 :            :   CONSTRAINT__UNKNOWN,
    2878                 :            :   CONSTRAINT__UNKNOWN,
    2879                 :            :   CONSTRAINT__UNKNOWN,
    2880                 :            :   CONSTRAINT__UNKNOWN,
    2881                 :            :   CONSTRAINT__UNKNOWN,
    2882                 :            :   CONSTRAINT__UNKNOWN,
    2883                 :            :   CONSTRAINT__UNKNOWN,
    2884                 :            :   CONSTRAINT__UNKNOWN,
    2885                 :            :   CONSTRAINT__UNKNOWN,
    2886                 :            :   CONSTRAINT__UNKNOWN,
    2887                 :            :   CONSTRAINT__UNKNOWN,
    2888                 :            :   CONSTRAINT__UNKNOWN,
    2889                 :            :   CONSTRAINT__UNKNOWN,
    2890                 :            :   CONSTRAINT__UNKNOWN,
    2891                 :            :   CONSTRAINT__UNKNOWN,
    2892                 :            :   CONSTRAINT__UNKNOWN,
    2893                 :            :   CONSTRAINT__UNKNOWN,
    2894                 :            :   CONSTRAINT__UNKNOWN,
    2895                 :            :   CONSTRAINT__UNKNOWN,
    2896                 :            :   CONSTRAINT__UNKNOWN,
    2897                 :            :   CONSTRAINT__UNKNOWN,
    2898                 :            :   CONSTRAINT__UNKNOWN,
    2899                 :            :   CONSTRAINT__UNKNOWN,
    2900                 :            :   CONSTRAINT__UNKNOWN,
    2901                 :            :   CONSTRAINT__UNKNOWN,
    2902                 :            :   CONSTRAINT__UNKNOWN,
    2903                 :            :   CONSTRAINT__UNKNOWN,
    2904                 :            :   CONSTRAINT__UNKNOWN,
    2905                 :            :   CONSTRAINT__UNKNOWN,
    2906                 :            :   CONSTRAINT__UNKNOWN,
    2907                 :            :   CONSTRAINT__UNKNOWN
    2908                 :            : };
    2909                 :            : 
    2910                 :            : enum reg_class
    2911                 :            : reg_class_for_constraint_1 (enum constraint_num c)
    2912                 :            : {
    2913                 :            :   switch (c)
    2914                 :            :     {
    2915                 :            :     case CONSTRAINT_r: return GENERAL_REGS;
    2916                 :            :     case CONSTRAINT_R: return LEGACY_REGS;
    2917                 :            :     case CONSTRAINT_q: return TARGET_64BIT ? GENERAL_REGS : Q_REGS;
    2918                 :            :     case CONSTRAINT_Q: return Q_REGS;
    2919                 :            :     case CONSTRAINT_l: return INDEX_REGS;
    2920                 :            :     case CONSTRAINT_a: return AREG;
    2921                 :            :     case CONSTRAINT_b: return BREG;
    2922                 :            :     case CONSTRAINT_c: return CREG;
    2923                 :            :     case CONSTRAINT_d: return DREG;
    2924                 :            :     case CONSTRAINT_S: return SIREG;
    2925                 :            :     case CONSTRAINT_D: return DIREG;
    2926                 :            :     case CONSTRAINT_A: return AD_REGS;
    2927                 :            :     case CONSTRAINT_U: return CLOBBERED_REGS;
    2928                 :            :     case CONSTRAINT_f: return TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ? FLOAT_REGS : NO_REGS;
    2929                 :            :     case CONSTRAINT_t: return TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ? FP_TOP_REG : NO_REGS;
    2930                 :            :     case CONSTRAINT_u: return TARGET_80387 || TARGET_FLOAT_RETURNS_IN_80387 ? FP_SECOND_REG : NO_REGS;
    2931                 :            :     case CONSTRAINT_Yk: return TARGET_AVX512F ? MASK_REGS : NO_REGS;
    2932                 :            :     case CONSTRAINT_k: return TARGET_AVX512F ? ALL_MASK_REGS : NO_REGS;
    2933                 :            :     case CONSTRAINT_y: return TARGET_MMX ? MMX_REGS : NO_REGS;
    2934                 :            :     case CONSTRAINT_x: return TARGET_SSE ? SSE_REGS : NO_REGS;
    2935                 :            :     case CONSTRAINT_v: return TARGET_SSE ? ALL_SSE_REGS : NO_REGS;
    2936                 :            :     case CONSTRAINT_Yz: return TARGET_SSE ? SSE_FIRST_REG : NO_REGS;
    2937                 :            :     case CONSTRAINT_Yd: return TARGET_AVX512DQ ? ALL_SSE_REGS : TARGET_SSE4_1 ? SSE_REGS : NO_REGS;
    2938                 :            :     case CONSTRAINT_Yp: return TARGET_PARTIAL_REG_STALL ? NO_REGS : GENERAL_REGS;
    2939                 :            :     case CONSTRAINT_Ya: return TARGET_ZERO_EXTEND_WITH_AND && optimize_function_for_speed_p (cfun)
    2940                 :            :   ? NO_REGS : GENERAL_REGS;
    2941                 :            :     case CONSTRAINT_Yb: return (!flag_plt && HAVE_AS_IX86_TLS_GET_ADDR_GOT) ? TLS_GOTBASE_REGS : BREG;
    2942                 :            :     case CONSTRAINT_Yf: return (ix86_fpmath & FPMATH_387) ? FLOAT_REGS : NO_REGS;
    2943                 :            :     case CONSTRAINT_Yr: return TARGET_SSE ? (TARGET_AVOID_4BYTE_PREFIXES ? NO_REX_SSE_REGS : ALL_SSE_REGS) : NO_REGS;
    2944                 :            :     case CONSTRAINT_Yv: return TARGET_AVX512VL ? ALL_SSE_REGS : TARGET_SSE ? SSE_REGS : NO_REGS;
    2945                 :            :     case CONSTRAINT_Yw: return TARGET_AVX512BW && TARGET_AVX512VL ? ALL_SSE_REGS : NO_REGS;
    2946                 :            :     default: break;
    2947                 :            :     }
    2948                 :            :   return NO_REGS;
    2949                 :            : }
    2950                 :            : 
    2951                 :            : bool (*constraint_satisfied_p_array[]) (rtx) = {
    2952                 :            :   satisfies_constraint_I,
    2953                 :            :   satisfies_constraint_J,
    2954                 :            :   satisfies_constraint_K,
    2955                 :            :   satisfies_constraint_L,
    2956                 :            :   satisfies_constraint_M,
    2957                 :            :   satisfies_constraint_N,
    2958                 :            :   satisfies_constraint_O,
    2959                 :            :   satisfies_constraint_m,
    2960                 :            :   satisfies_constraint_o,
    2961                 :            :   satisfies_constraint_Bm,
    2962                 :            :   satisfies_constraint_Bc,
    2963                 :            :   satisfies_constraint_Bn,
    2964                 :            :   satisfies_constraint_p,
    2965                 :            :   satisfies_constraint_Tv,
    2966                 :            :   satisfies_constraint_Ts,
    2967                 :            :   satisfies_constraint_Bz,
    2968                 :            :   satisfies_constraint_G,
    2969                 :            :   satisfies_constraint_e,
    2970                 :            :   satisfies_constraint_We,
    2971                 :            :   satisfies_constraint_Wz,
    2972                 :            :   satisfies_constraint_Wd,
    2973                 :            :   satisfies_constraint_Wf,
    2974                 :            :   satisfies_constraint_Z,
    2975                 :            :   satisfies_constraint_Bf,
    2976                 :            :   satisfies_constraint_V,
    2977                 :            :   satisfies_constraint__l,
    2978                 :            :   satisfies_constraint__g,
    2979                 :            :   satisfies_constraint_i,
    2980                 :            :   satisfies_constraint_s,
    2981                 :            :   satisfies_constraint_n,
    2982                 :            :   satisfies_constraint_E,
    2983                 :            :   satisfies_constraint_F,
    2984                 :            :   satisfies_constraint_X,
    2985                 :            :   satisfies_constraint_Bg,
    2986                 :            :   satisfies_constraint_Bs,
    2987                 :            :   satisfies_constraint_Bw,
    2988                 :            :   satisfies_constraint_BC,
    2989                 :            :   satisfies_constraint_C
    2990                 :            : };
    2991                 :            : 
    2992                 :            : bool
    2993                 :            : insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, enum constraint_num c)
    2994                 :            : {
    2995                 :            :   switch (c)
    2996                 :            :     {
    2997                 :            :     case CONSTRAINT_I:
    2998                 :            :       return 
    2999                 :            : #line 216 "../../gcc/config/i386/constraints.md"
    3000                 :            : (IN_RANGE (ival, 0, 31));
    3001                 :            : 
    3002                 :            :     case CONSTRAINT_J:
    3003                 :            :       return 
    3004                 :            : #line 221 "../../gcc/config/i386/constraints.md"
    3005                 :            : (IN_RANGE (ival, 0, 63));
    3006                 :            : 
    3007                 :            :     case CONSTRAINT_K:
    3008                 :            :       return 
    3009                 :            : #line 226 "../../gcc/config/i386/constraints.md"
    3010                 :            : (IN_RANGE (ival, -128, 127));
    3011                 :            : 
    3012                 :            :     case CONSTRAINT_L:
    3013                 :            :       return 
    3014                 :            : #line 232 "../../gcc/config/i386/constraints.md"
    3015                 :            : (ival == 0xff || ival == 0xffff
    3016                 :            :                     || ival == (HOST_WIDE_INT) 0xffffffff);
    3017                 :            : 
    3018                 :            :     case CONSTRAINT_M:
    3019                 :            :       return 
    3020                 :            : #line 238 "../../gcc/config/i386/constraints.md"
    3021                 :            : (IN_RANGE (ival, 0, 3));
    3022                 :            : 
    3023                 :            :     case CONSTRAINT_N:
    3024                 :            :       return 
    3025                 :            : #line 244 "../../gcc/config/i386/constraints.md"
    3026                 :            : (IN_RANGE (ival, 0, 255));
    3027                 :            : 
    3028                 :            :     case CONSTRAINT_O:
    3029                 :            :       return 
    3030                 :            : #line 249 "../../gcc/config/i386/constraints.md"
    3031                 :            : (IN_RANGE (ival, 0, 127));
    3032                 :            : 
    3033                 :            :     default: break;
    3034                 :            :     }
    3035                 :            :   return false;
    3036                 :            : }
    3037                 :            : 

Generated by: LCOV version 1.0

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