LCOV - code coverage report
Current view: top level - objdir/gcc - insn-opinit.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 128 132 97.0 %
Date: 2020-03-28 11:57:23 Functions: 31 32 96.9 %
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 `genopinit'
       2                 :            :    from the machine description file `md'.  */
       3                 :            : 
       4                 :            : #ifndef GCC_INSN_OPINIT_H
       5                 :            : #define GCC_INSN_OPINIT_H 1
       6                 :            : enum optab_tag {
       7                 :            :   unknown_optab,
       8                 :            :   sext_optab,
       9                 :            :   trunc_optab,
      10                 :            :   zext_optab,
      11                 :            :   sfix_optab,
      12                 :            :   ufix_optab,
      13                 :            :   sfloat_optab,
      14                 :            :   ufloat_optab,
      15                 :            :   lrint_optab,
      16                 :            :   lround_optab,
      17                 :            :   lfloor_optab,
      18                 :            :   lceil_optab,
      19                 :            :   fract_optab,
      20                 :            :   fractuns_optab,
      21                 :            :   satfract_optab,
      22                 :            :   satfractuns_optab,
      23                 :            :   sfixtrunc_optab,
      24                 :            :   ufixtrunc_optab,
      25                 :            :   smul_widen_optab,
      26                 :            :   umul_widen_optab,
      27                 :            :   usmul_widen_optab,
      28                 :            :   smadd_widen_optab,
      29                 :            :   umadd_widen_optab,
      30                 :            :   ssmadd_widen_optab,
      31                 :            :   usmadd_widen_optab,
      32                 :            :   smsub_widen_optab,
      33                 :            :   umsub_widen_optab,
      34                 :            :   ssmsub_widen_optab,
      35                 :            :   usmsub_widen_optab,
      36                 :            :   vec_load_lanes_optab,
      37                 :            :   vec_store_lanes_optab,
      38                 :            :   vec_mask_load_lanes_optab,
      39                 :            :   vec_mask_store_lanes_optab,
      40                 :            :   vcond_optab,
      41                 :            :   vcondu_optab,
      42                 :            :   vcondeq_optab,
      43                 :            :   vcond_mask_optab,
      44                 :            :   vec_cmp_optab,
      45                 :            :   vec_cmpu_optab,
      46                 :            :   vec_cmpeq_optab,
      47                 :            :   maskload_optab,
      48                 :            :   maskstore_optab,
      49                 :            :   gather_load_optab,
      50                 :            :   mask_gather_load_optab,
      51                 :            :   scatter_store_optab,
      52                 :            :   mask_scatter_store_optab,
      53                 :            :   vec_extract_optab,
      54                 :            :   vec_init_optab,
      55                 :            :   while_ult_optab,
      56                 :            :   add_optab,
      57                 :            :   addv_optab,
      58                 :            :   ssadd_optab,
      59                 :            :   usadd_optab,
      60                 :            :   sub_optab,
      61                 :            :   subv_optab,
      62                 :            :   sssub_optab,
      63                 :            :   ussub_optab,
      64                 :            :   smul_optab,
      65                 :            :   smulv_optab,
      66                 :            :   ssmul_optab,
      67                 :            :   usmul_optab,
      68                 :            :   sdiv_optab,
      69                 :            :   sdivv_optab,
      70                 :            :   ssdiv_optab,
      71                 :            :   udiv_optab,
      72                 :            :   usdiv_optab,
      73                 :            :   sdivmod_optab,
      74                 :            :   udivmod_optab,
      75                 :            :   smod_optab,
      76                 :            :   umod_optab,
      77                 :            :   ftrunc_optab,
      78                 :            :   and_optab,
      79                 :            :   ior_optab,
      80                 :            :   xor_optab,
      81                 :            :   ashl_optab,
      82                 :            :   ssashl_optab,
      83                 :            :   usashl_optab,
      84                 :            :   ashr_optab,
      85                 :            :   lshr_optab,
      86                 :            :   rotl_optab,
      87                 :            :   rotr_optab,
      88                 :            :   vashl_optab,
      89                 :            :   vashr_optab,
      90                 :            :   vlshr_optab,
      91                 :            :   vrotl_optab,
      92                 :            :   vrotr_optab,
      93                 :            :   smin_optab,
      94                 :            :   smax_optab,
      95                 :            :   umin_optab,
      96                 :            :   umax_optab,
      97                 :            :   neg_optab,
      98                 :            :   negv_optab,
      99                 :            :   ssneg_optab,
     100                 :            :   usneg_optab,
     101                 :            :   abs_optab,
     102                 :            :   absv_optab,
     103                 :            :   one_cmpl_optab,
     104                 :            :   bswap_optab,
     105                 :            :   ffs_optab,
     106                 :            :   clz_optab,
     107                 :            :   ctz_optab,
     108                 :            :   clrsb_optab,
     109                 :            :   popcount_optab,
     110                 :            :   parity_optab,
     111                 :            :   cmp_optab,
     112                 :            :   ucmp_optab,
     113                 :            :   eq_optab,
     114                 :            :   ne_optab,
     115                 :            :   gt_optab,
     116                 :            :   ge_optab,
     117                 :            :   lt_optab,
     118                 :            :   le_optab,
     119                 :            :   unord_optab,
     120                 :            :   powi_optab,
     121                 :            :   sqrt_optab,
     122                 :            :   sync_old_add_optab,
     123                 :            :   sync_old_sub_optab,
     124                 :            :   sync_old_ior_optab,
     125                 :            :   sync_old_and_optab,
     126                 :            :   sync_old_xor_optab,
     127                 :            :   sync_old_nand_optab,
     128                 :            :   sync_new_add_optab,
     129                 :            :   sync_new_sub_optab,
     130                 :            :   sync_new_ior_optab,
     131                 :            :   sync_new_and_optab,
     132                 :            :   sync_new_xor_optab,
     133                 :            :   sync_new_nand_optab,
     134                 :            :   sync_compare_and_swap_optab,
     135                 :            :   sync_lock_test_and_set_optab,
     136                 :            :   mov_optab,
     137                 :            :   movstrict_optab,
     138                 :            :   movmisalign_optab,
     139                 :            :   storent_optab,
     140                 :            :   insv_optab,
     141                 :            :   extv_optab,
     142                 :            :   extzv_optab,
     143                 :            :   insvmisalign_optab,
     144                 :            :   extvmisalign_optab,
     145                 :            :   extzvmisalign_optab,
     146                 :            :   push_optab,
     147                 :            :   reload_in_optab,
     148                 :            :   reload_out_optab,
     149                 :            :   cbranch_optab,
     150                 :            :   addcc_optab,
     151                 :            :   negcc_optab,
     152                 :            :   notcc_optab,
     153                 :            :   movcc_optab,
     154                 :            :   cond_add_optab,
     155                 :            :   cond_sub_optab,
     156                 :            :   cond_smul_optab,
     157                 :            :   cond_sdiv_optab,
     158                 :            :   cond_smod_optab,
     159                 :            :   cond_udiv_optab,
     160                 :            :   cond_umod_optab,
     161                 :            :   cond_and_optab,
     162                 :            :   cond_ior_optab,
     163                 :            :   cond_xor_optab,
     164                 :            :   cond_ashl_optab,
     165                 :            :   cond_ashr_optab,
     166                 :            :   cond_lshr_optab,
     167                 :            :   cond_smin_optab,
     168                 :            :   cond_smax_optab,
     169                 :            :   cond_umin_optab,
     170                 :            :   cond_umax_optab,
     171                 :            :   cond_fma_optab,
     172                 :            :   cond_fms_optab,
     173                 :            :   cond_fnma_optab,
     174                 :            :   cond_fnms_optab,
     175                 :            :   cmov_optab,
     176                 :            :   cstore_optab,
     177                 :            :   ctrap_optab,
     178                 :            :   addv4_optab,
     179                 :            :   subv4_optab,
     180                 :            :   mulv4_optab,
     181                 :            :   uaddv4_optab,
     182                 :            :   usubv4_optab,
     183                 :            :   umulv4_optab,
     184                 :            :   negv3_optab,
     185                 :            :   addptr3_optab,
     186                 :            :   smul_highpart_optab,
     187                 :            :   umul_highpart_optab,
     188                 :            :   cmpmem_optab,
     189                 :            :   cmpstr_optab,
     190                 :            :   cmpstrn_optab,
     191                 :            :   cpymem_optab,
     192                 :            :   movmem_optab,
     193                 :            :   setmem_optab,
     194                 :            :   strlen_optab,
     195                 :            :   fma_optab,
     196                 :            :   fms_optab,
     197                 :            :   fnma_optab,
     198                 :            :   fnms_optab,
     199                 :            :   rint_optab,
     200                 :            :   round_optab,
     201                 :            :   roundeven_optab,
     202                 :            :   floor_optab,
     203                 :            :   ceil_optab,
     204                 :            :   btrunc_optab,
     205                 :            :   nearbyint_optab,
     206                 :            :   acos_optab,
     207                 :            :   acosh_optab,
     208                 :            :   asin_optab,
     209                 :            :   asinh_optab,
     210                 :            :   atan2_optab,
     211                 :            :   atan_optab,
     212                 :            :   atanh_optab,
     213                 :            :   copysign_optab,
     214                 :            :   xorsign_optab,
     215                 :            :   cos_optab,
     216                 :            :   cosh_optab,
     217                 :            :   exp10_optab,
     218                 :            :   exp2_optab,
     219                 :            :   exp_optab,
     220                 :            :   expm1_optab,
     221                 :            :   fmod_optab,
     222                 :            :   hypot_optab,
     223                 :            :   ilogb_optab,
     224                 :            :   isinf_optab,
     225                 :            :   ldexp_optab,
     226                 :            :   log10_optab,
     227                 :            :   log1p_optab,
     228                 :            :   log2_optab,
     229                 :            :   log_optab,
     230                 :            :   logb_optab,
     231                 :            :   pow_optab,
     232                 :            :   remainder_optab,
     233                 :            :   rsqrt_optab,
     234                 :            :   scalb_optab,
     235                 :            :   signbit_optab,
     236                 :            :   significand_optab,
     237                 :            :   sin_optab,
     238                 :            :   sincos_optab,
     239                 :            :   sinh_optab,
     240                 :            :   tan_optab,
     241                 :            :   tanh_optab,
     242                 :            :   fmax_optab,
     243                 :            :   fmin_optab,
     244                 :            :   reduc_smax_scal_optab,
     245                 :            :   reduc_smin_scal_optab,
     246                 :            :   reduc_plus_scal_optab,
     247                 :            :   reduc_umax_scal_optab,
     248                 :            :   reduc_umin_scal_optab,
     249                 :            :   reduc_and_scal_optab,
     250                 :            :   reduc_ior_scal_optab,
     251                 :            :   reduc_xor_scal_optab,
     252                 :            :   fold_left_plus_optab,
     253                 :            :   mask_fold_left_plus_optab,
     254                 :            :   extract_last_optab,
     255                 :            :   fold_extract_last_optab,
     256                 :            :   savg_floor_optab,
     257                 :            :   uavg_floor_optab,
     258                 :            :   savg_ceil_optab,
     259                 :            :   uavg_ceil_optab,
     260                 :            :   sdot_prod_optab,
     261                 :            :   ssum_widen_optab,
     262                 :            :   udot_prod_optab,
     263                 :            :   usum_widen_optab,
     264                 :            :   usad_optab,
     265                 :            :   ssad_optab,
     266                 :            :   smulhs_optab,
     267                 :            :   smulhrs_optab,
     268                 :            :   umulhs_optab,
     269                 :            :   umulhrs_optab,
     270                 :            :   sdiv_pow2_optab,
     271                 :            :   vec_pack_sfix_trunc_optab,
     272                 :            :   vec_pack_ssat_optab,
     273                 :            :   vec_pack_trunc_optab,
     274                 :            :   vec_pack_ufix_trunc_optab,
     275                 :            :   vec_pack_sbool_trunc_optab,
     276                 :            :   vec_pack_usat_optab,
     277                 :            :   vec_packs_float_optab,
     278                 :            :   vec_packu_float_optab,
     279                 :            :   vec_perm_optab,
     280                 :            :   vec_realign_load_optab,
     281                 :            :   vec_set_optab,
     282                 :            :   vec_shl_optab,
     283                 :            :   vec_shr_optab,
     284                 :            :   vec_unpack_sfix_trunc_hi_optab,
     285                 :            :   vec_unpack_sfix_trunc_lo_optab,
     286                 :            :   vec_unpack_ufix_trunc_hi_optab,
     287                 :            :   vec_unpack_ufix_trunc_lo_optab,
     288                 :            :   vec_unpacks_float_hi_optab,
     289                 :            :   vec_unpacks_float_lo_optab,
     290                 :            :   vec_unpacks_hi_optab,
     291                 :            :   vec_unpacks_lo_optab,
     292                 :            :   vec_unpacks_sbool_hi_optab,
     293                 :            :   vec_unpacks_sbool_lo_optab,
     294                 :            :   vec_unpacku_float_hi_optab,
     295                 :            :   vec_unpacku_float_lo_optab,
     296                 :            :   vec_unpacku_hi_optab,
     297                 :            :   vec_unpacku_lo_optab,
     298                 :            :   vec_widen_smult_even_optab,
     299                 :            :   vec_widen_smult_hi_optab,
     300                 :            :   vec_widen_smult_lo_optab,
     301                 :            :   vec_widen_smult_odd_optab,
     302                 :            :   vec_widen_sshiftl_hi_optab,
     303                 :            :   vec_widen_sshiftl_lo_optab,
     304                 :            :   vec_widen_umult_even_optab,
     305                 :            :   vec_widen_umult_hi_optab,
     306                 :            :   vec_widen_umult_lo_optab,
     307                 :            :   vec_widen_umult_odd_optab,
     308                 :            :   vec_widen_ushiftl_hi_optab,
     309                 :            :   vec_widen_ushiftl_lo_optab,
     310                 :            :   sync_add_optab,
     311                 :            :   sync_and_optab,
     312                 :            :   sync_ior_optab,
     313                 :            :   sync_lock_release_optab,
     314                 :            :   sync_nand_optab,
     315                 :            :   sync_sub_optab,
     316                 :            :   sync_xor_optab,
     317                 :            :   atomic_add_fetch_optab,
     318                 :            :   atomic_add_optab,
     319                 :            :   atomic_and_fetch_optab,
     320                 :            :   atomic_and_optab,
     321                 :            :   atomic_bit_test_and_set_optab,
     322                 :            :   atomic_bit_test_and_complement_optab,
     323                 :            :   atomic_bit_test_and_reset_optab,
     324                 :            :   atomic_compare_and_swap_optab,
     325                 :            :   atomic_exchange_optab,
     326                 :            :   atomic_fetch_add_optab,
     327                 :            :   atomic_fetch_and_optab,
     328                 :            :   atomic_fetch_nand_optab,
     329                 :            :   atomic_fetch_or_optab,
     330                 :            :   atomic_fetch_sub_optab,
     331                 :            :   atomic_fetch_xor_optab,
     332                 :            :   atomic_load_optab,
     333                 :            :   atomic_nand_fetch_optab,
     334                 :            :   atomic_nand_optab,
     335                 :            :   atomic_or_fetch_optab,
     336                 :            :   atomic_or_optab,
     337                 :            :   atomic_store_optab,
     338                 :            :   atomic_sub_fetch_optab,
     339                 :            :   atomic_sub_optab,
     340                 :            :   atomic_xor_fetch_optab,
     341                 :            :   atomic_xor_optab,
     342                 :            :   get_thread_pointer_optab,
     343                 :            :   set_thread_pointer_optab,
     344                 :            :   check_raw_ptrs_optab,
     345                 :            :   check_war_ptrs_optab,
     346                 :            :   vec_duplicate_optab,
     347                 :            :   vec_series_optab,
     348                 :            :   vec_shl_insert_optab,
     349                 :            :   FIRST_CONV_OPTAB = sext_optab,
     350                 :            :   LAST_CONVLIB_OPTAB = satfractuns_optab,
     351                 :            :   LAST_CONV_OPTAB = while_ult_optab,
     352                 :            :   FIRST_NORM_OPTAB = add_optab,
     353                 :            :   LAST_NORMLIB_OPTAB = sync_lock_test_and_set_optab,
     354                 :            :   LAST_NORM_OPTAB = vec_shl_insert_optab
     355                 :            : };
     356                 :            : 
     357                 :            : #define NUM_OPTABS          342
     358                 :            : #define NUM_CONVLIB_OPTABS  15
     359                 :            : #define NUM_NORMLIB_OPTABS  80
     360                 :            : #define NUM_OPTAB_PATTERNS  1668
     361                 :            : typedef enum optab_tag optab;
     362                 :            : typedef enum optab_tag convert_optab;
     363                 :            : typedef enum optab_tag direct_optab;
     364                 :            : 
     365                 :            : struct optab_libcall_d
     366                 :            : {
     367                 :            :   char libcall_suffix;
     368                 :            :   const char *libcall_basename;
     369                 :            :   void (*libcall_gen) (optab, const char *name,
     370                 :            :                        char suffix, machine_mode);
     371                 :            : };
     372                 :            : 
     373                 :            : struct convert_optab_libcall_d
     374                 :            : {
     375                 :            :   const char *libcall_basename;
     376                 :            :   void (*libcall_gen) (convert_optab, const char *name,
     377                 :            :                        machine_mode, machine_mode);
     378                 :            : };
     379                 :            : 
     380                 :            : /* Given an enum insn_code, access the function to construct
     381                 :            :    the body of that kind of insn.  */
     382                 :            : #define GEN_FCN(CODE) (insn_data[CODE].genfun)
     383                 :            : 
     384                 :            : #ifdef NUM_RTX_CODE
     385                 :            : /* Contains the optab used for each rtx code, and vice-versa.  */
     386                 :            : extern const optab code_to_optab_[NUM_RTX_CODE];
     387                 :            : extern const enum rtx_code optab_to_code_[NUM_OPTABS];
     388                 :            : 
     389                 :            : static inline optab
     390                 :   84663066 : code_to_optab (enum rtx_code code)
     391                 :            : {
     392                 :   57387966 :   return code_to_optab_[code];
     393                 :            : }
     394                 :            : 
     395                 :            : static inline enum rtx_code
     396                 :   28144500 : optab_to_code (optab op)
     397                 :            : {
     398                 :   28144500 :   return optab_to_code_[op];
     399                 :            : }
     400                 :            : 
     401                 :            : extern insn_code maybe_code_for_cmp_1 (machine_mode);
     402                 :            : inline insn_code
     403                 :            : code_for_cmp_1 (machine_mode arg0)
     404                 :            : {
     405                 :            :   insn_code code = maybe_code_for_cmp_1 (arg0);
     406                 :            :   gcc_assert (code != CODE_FOR_nothing);
     407                 :            :   return code;
     408                 :            : }
     409                 :            : 
     410                 :            : extern rtx maybe_gen_cmp_1 (machine_mode, rtx, rtx);
     411                 :            : inline rtx
     412                 :      11947 : gen_cmp_1 (machine_mode arg0, rtx x0, rtx x1)
     413                 :            : {
     414                 :      11947 :   rtx res = maybe_gen_cmp_1 (arg0, x0, x1);
     415                 :      11947 :   gcc_assert (res);
     416                 :      11947 :   return res;
     417                 :            : }
     418                 :            : 
     419                 :            : extern insn_code maybe_code_for_add3_carry (machine_mode);
     420                 :            : inline insn_code
     421                 :            : code_for_add3_carry (machine_mode arg0)
     422                 :            : {
     423                 :            :   insn_code code = maybe_code_for_add3_carry (arg0);
     424                 :            :   gcc_assert (code != CODE_FOR_nothing);
     425                 :            :   return code;
     426                 :            : }
     427                 :            : 
     428                 :            : extern rtx maybe_gen_add3_carry (machine_mode, rtx, rtx, rtx, rtx, rtx);
     429                 :            : inline rtx
     430                 :        295 : gen_add3_carry (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4)
     431                 :            : {
     432                 :        295 :   rtx res = maybe_gen_add3_carry (arg0, x0, x1, x2, x3, x4);
     433                 :        295 :   gcc_assert (res);
     434                 :        295 :   return res;
     435                 :            : }
     436                 :            : 
     437                 :            : extern insn_code maybe_code_for_sub3_carry (machine_mode);
     438                 :            : inline insn_code
     439                 :            : code_for_sub3_carry (machine_mode arg0)
     440                 :            : {
     441                 :            :   insn_code code = maybe_code_for_sub3_carry (arg0);
     442                 :            :   gcc_assert (code != CODE_FOR_nothing);
     443                 :            :   return code;
     444                 :            : }
     445                 :            : 
     446                 :            : extern rtx maybe_gen_sub3_carry (machine_mode, rtx, rtx, rtx, rtx, rtx);
     447                 :            : inline rtx
     448                 :       1099 : gen_sub3_carry (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4)
     449                 :            : {
     450                 :       1099 :   rtx res = maybe_gen_sub3_carry (arg0, x0, x1, x2, x3, x4);
     451                 :       1099 :   gcc_assert (res);
     452                 :       1099 :   return res;
     453                 :            : }
     454                 :            : 
     455                 :            : extern insn_code maybe_code_for_sub3_carry_ccc (machine_mode);
     456                 :            : inline insn_code
     457                 :            : code_for_sub3_carry_ccc (machine_mode arg0)
     458                 :            : {
     459                 :            :   insn_code code = maybe_code_for_sub3_carry_ccc (arg0);
     460                 :            :   gcc_assert (code != CODE_FOR_nothing);
     461                 :            :   return code;
     462                 :            : }
     463                 :            : 
     464                 :            : extern rtx maybe_gen_sub3_carry_ccc (machine_mode, rtx, rtx, rtx);
     465                 :            : inline rtx
     466                 :       7979 : gen_sub3_carry_ccc (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     467                 :            : {
     468                 :       7979 :   rtx res = maybe_gen_sub3_carry_ccc (arg0, x0, x1, x2);
     469                 :       7979 :   gcc_assert (res);
     470                 :       7979 :   return res;
     471                 :            : }
     472                 :            : 
     473                 :            : extern insn_code maybe_code_for_sub3_carry_ccgz (machine_mode);
     474                 :            : inline insn_code
     475                 :            : code_for_sub3_carry_ccgz (machine_mode arg0)
     476                 :            : {
     477                 :            :   insn_code code = maybe_code_for_sub3_carry_ccgz (arg0);
     478                 :            :   gcc_assert (code != CODE_FOR_nothing);
     479                 :            :   return code;
     480                 :            : }
     481                 :            : 
     482                 :            : extern rtx maybe_gen_sub3_carry_ccgz (machine_mode, rtx, rtx, rtx);
     483                 :            : inline rtx
     484                 :       3773 : gen_sub3_carry_ccgz (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     485                 :            : {
     486                 :       3773 :   rtx res = maybe_gen_sub3_carry_ccgz (arg0, x0, x1, x2);
     487                 :       3773 :   gcc_assert (res);
     488                 :       3773 :   return res;
     489                 :            : }
     490                 :            : 
     491                 :            : extern insn_code maybe_code_for_test_ccno_1 (machine_mode);
     492                 :            : inline insn_code
     493                 :            : code_for_test_ccno_1 (machine_mode arg0)
     494                 :            : {
     495                 :            :   insn_code code = maybe_code_for_test_ccno_1 (arg0);
     496                 :            :   gcc_assert (code != CODE_FOR_nothing);
     497                 :            :   return code;
     498                 :            : }
     499                 :            : 
     500                 :            : extern rtx maybe_gen_test_ccno_1 (machine_mode, rtx, rtx);
     501                 :            : inline rtx
     502                 :         25 : gen_test_ccno_1 (machine_mode arg0, rtx x0, rtx x1)
     503                 :            : {
     504                 :         25 :   rtx res = maybe_gen_test_ccno_1 (arg0, x0, x1);
     505                 :         25 :   gcc_assert (res);
     506                 :         25 :   return res;
     507                 :            : }
     508                 :            : 
     509                 :            : extern insn_code maybe_code_for_copysign3_const (machine_mode);
     510                 :            : inline insn_code
     511                 :            : code_for_copysign3_const (machine_mode arg0)
     512                 :            : {
     513                 :            :   insn_code code = maybe_code_for_copysign3_const (arg0);
     514                 :            :   gcc_assert (code != CODE_FOR_nothing);
     515                 :            :   return code;
     516                 :            : }
     517                 :            : 
     518                 :            : extern rtx maybe_gen_copysign3_const (machine_mode, rtx, rtx, rtx, rtx);
     519                 :            : inline rtx
     520                 :      23276 : gen_copysign3_const (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
     521                 :            : {
     522                 :      23276 :   rtx res = maybe_gen_copysign3_const (arg0, x0, x1, x2, x3);
     523                 :      23276 :   gcc_assert (res);
     524                 :      23276 :   return res;
     525                 :            : }
     526                 :            : 
     527                 :            : extern insn_code maybe_code_for_copysign3_var (machine_mode);
     528                 :            : inline insn_code
     529                 :            : code_for_copysign3_var (machine_mode arg0)
     530                 :            : {
     531                 :            :   insn_code code = maybe_code_for_copysign3_var (arg0);
     532                 :            :   gcc_assert (code != CODE_FOR_nothing);
     533                 :            :   return code;
     534                 :            : }
     535                 :            : 
     536                 :            : extern rtx maybe_gen_copysign3_var (machine_mode, rtx, rtx, rtx, rtx, rtx, rtx);
     537                 :            : inline rtx
     538                 :        404 : gen_copysign3_var (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4, rtx x5)
     539                 :            : {
     540                 :        404 :   rtx res = maybe_gen_copysign3_var (arg0, x0, x1, x2, x3, x4, x5);
     541                 :        404 :   gcc_assert (res);
     542                 :        404 :   return res;
     543                 :            : }
     544                 :            : 
     545                 :            : extern insn_code maybe_code_for_xorsign3_1 (machine_mode);
     546                 :            : inline insn_code
     547                 :            : code_for_xorsign3_1 (machine_mode arg0)
     548                 :            : {
     549                 :            :   insn_code code = maybe_code_for_xorsign3_1 (arg0);
     550                 :            :   gcc_assert (code != CODE_FOR_nothing);
     551                 :            :   return code;
     552                 :            : }
     553                 :            : 
     554                 :            : extern rtx maybe_gen_xorsign3_1 (machine_mode, rtx, rtx, rtx, rtx);
     555                 :            : inline rtx
     556                 :          2 : gen_xorsign3_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
     557                 :            : {
     558                 :          2 :   rtx res = maybe_gen_xorsign3_1 (arg0, x0, x1, x2, x3);
     559                 :          2 :   gcc_assert (res);
     560                 :          2 :   return res;
     561                 :            : }
     562                 :            : 
     563                 :            : extern insn_code maybe_code_for_x86_shift_adj_1 (machine_mode);
     564                 :            : inline insn_code
     565                 :            : code_for_x86_shift_adj_1 (machine_mode arg0)
     566                 :            : {
     567                 :            :   insn_code code = maybe_code_for_x86_shift_adj_1 (arg0);
     568                 :            :   gcc_assert (code != CODE_FOR_nothing);
     569                 :            :   return code;
     570                 :            : }
     571                 :            : 
     572                 :            : extern rtx maybe_gen_x86_shift_adj_1 (machine_mode, rtx, rtx, rtx, rtx);
     573                 :            : inline rtx
     574                 :       1311 : gen_x86_shift_adj_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
     575                 :            : {
     576                 :       1311 :   rtx res = maybe_gen_x86_shift_adj_1 (arg0, x0, x1, x2, x3);
     577                 :       1311 :   gcc_assert (res);
     578                 :       1311 :   return res;
     579                 :            : }
     580                 :            : 
     581                 :            : extern insn_code maybe_code_for_x86_shift_adj_2 (machine_mode);
     582                 :            : inline insn_code
     583                 :            : code_for_x86_shift_adj_2 (machine_mode arg0)
     584                 :            : {
     585                 :            :   insn_code code = maybe_code_for_x86_shift_adj_2 (arg0);
     586                 :            :   gcc_assert (code != CODE_FOR_nothing);
     587                 :            :   return code;
     588                 :            : }
     589                 :            : 
     590                 :            : extern rtx maybe_gen_x86_shift_adj_2 (machine_mode, rtx, rtx, rtx);
     591                 :            : inline rtx
     592                 :        427 : gen_x86_shift_adj_2 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     593                 :            : {
     594                 :        427 :   rtx res = maybe_gen_x86_shift_adj_2 (arg0, x0, x1, x2);
     595                 :        427 :   gcc_assert (res);
     596                 :        427 :   return res;
     597                 :            : }
     598                 :            : 
     599                 :            : extern insn_code maybe_code_for_x86_shift_adj_3 (machine_mode);
     600                 :            : inline insn_code
     601                 :            : code_for_x86_shift_adj_3 (machine_mode arg0)
     602                 :            : {
     603                 :            :   insn_code code = maybe_code_for_x86_shift_adj_3 (arg0);
     604                 :            :   gcc_assert (code != CODE_FOR_nothing);
     605                 :            :   return code;
     606                 :            : }
     607                 :            : 
     608                 :            : extern rtx maybe_gen_x86_shift_adj_3 (machine_mode, rtx, rtx, rtx);
     609                 :            : inline rtx
     610                 :         26 : gen_x86_shift_adj_3 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     611                 :            : {
     612                 :         26 :   rtx res = maybe_gen_x86_shift_adj_3 (arg0, x0, x1, x2);
     613                 :         26 :   gcc_assert (res);
     614                 :         26 :   return res;
     615                 :            : }
     616                 :            : 
     617                 :            : extern insn_code maybe_code_for_leave (machine_mode);
     618                 :            : inline insn_code
     619                 :            : code_for_leave (machine_mode arg0)
     620                 :            : {
     621                 :            :   insn_code code = maybe_code_for_leave (arg0);
     622                 :            :   gcc_assert (code != CODE_FOR_nothing);
     623                 :            :   return code;
     624                 :            : }
     625                 :            : 
     626                 :            : extern rtx maybe_gen_leave (machine_mode);
     627                 :            : inline rtx
     628                 :     149332 : gen_leave (machine_mode arg0)
     629                 :            : {
     630                 :     149332 :   rtx res = maybe_gen_leave (arg0);
     631                 :     149332 :   gcc_assert (res);
     632                 :     149332 :   return res;
     633                 :            : }
     634                 :            : 
     635                 :            : extern insn_code maybe_code_for_tls_global_dynamic_64 (machine_mode);
     636                 :            : inline insn_code
     637                 :            : code_for_tls_global_dynamic_64 (machine_mode arg0)
     638                 :            : {
     639                 :            :   insn_code code = maybe_code_for_tls_global_dynamic_64 (arg0);
     640                 :            :   gcc_assert (code != CODE_FOR_nothing);
     641                 :            :   return code;
     642                 :            : }
     643                 :            : 
     644                 :            : extern rtx maybe_gen_tls_global_dynamic_64 (machine_mode, rtx, rtx, rtx);
     645                 :            : inline rtx
     646                 :       3949 : gen_tls_global_dynamic_64 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     647                 :            : {
     648                 :       3949 :   rtx res = maybe_gen_tls_global_dynamic_64 (arg0, x0, x1, x2);
     649                 :       3949 :   gcc_assert (res);
     650                 :       3949 :   return res;
     651                 :            : }
     652                 :            : 
     653                 :            : extern insn_code maybe_code_for_tls_local_dynamic_base_64 (machine_mode);
     654                 :            : inline insn_code
     655                 :            : code_for_tls_local_dynamic_base_64 (machine_mode arg0)
     656                 :            : {
     657                 :            :   insn_code code = maybe_code_for_tls_local_dynamic_base_64 (arg0);
     658                 :            :   gcc_assert (code != CODE_FOR_nothing);
     659                 :            :   return code;
     660                 :            : }
     661                 :            : 
     662                 :            : extern rtx maybe_gen_tls_local_dynamic_base_64 (machine_mode, rtx, rtx);
     663                 :            : inline rtx
     664                 :        289 : gen_tls_local_dynamic_base_64 (machine_mode arg0, rtx x0, rtx x1)
     665                 :            : {
     666                 :        289 :   rtx res = maybe_gen_tls_local_dynamic_base_64 (arg0, x0, x1);
     667                 :        289 :   gcc_assert (res);
     668                 :        289 :   return res;
     669                 :            : }
     670                 :            : 
     671                 :            : extern insn_code maybe_code_for_tls_dynamic_gnu2_64 (machine_mode);
     672                 :            : inline insn_code
     673                 :            : code_for_tls_dynamic_gnu2_64 (machine_mode arg0)
     674                 :            : {
     675                 :            :   insn_code code = maybe_code_for_tls_dynamic_gnu2_64 (arg0);
     676                 :            :   gcc_assert (code != CODE_FOR_nothing);
     677                 :            :   return code;
     678                 :            : }
     679                 :            : 
     680                 :            : extern rtx maybe_gen_tls_dynamic_gnu2_64 (machine_mode, rtx, rtx);
     681                 :            : inline rtx
     682                 :         17 : gen_tls_dynamic_gnu2_64 (machine_mode arg0, rtx x0, rtx x1)
     683                 :            : {
     684                 :         17 :   rtx res = maybe_gen_tls_dynamic_gnu2_64 (arg0, x0, x1);
     685                 :         17 :   gcc_assert (res);
     686                 :         17 :   return res;
     687                 :            : }
     688                 :            : 
     689                 :            : extern insn_code maybe_code_for_pro_epilogue_adjust_stack_add (machine_mode);
     690                 :            : inline insn_code
     691                 :            : code_for_pro_epilogue_adjust_stack_add (machine_mode arg0)
     692                 :            : {
     693                 :            :   insn_code code = maybe_code_for_pro_epilogue_adjust_stack_add (arg0);
     694                 :            :   gcc_assert (code != CODE_FOR_nothing);
     695                 :            :   return code;
     696                 :            : }
     697                 :            : 
     698                 :            : extern rtx maybe_gen_pro_epilogue_adjust_stack_add (machine_mode, rtx, rtx, rtx);
     699                 :            : inline rtx
     700                 :     918591 : gen_pro_epilogue_adjust_stack_add (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     701                 :            : {
     702                 :     918591 :   rtx res = maybe_gen_pro_epilogue_adjust_stack_add (arg0, x0, x1, x2);
     703                 :     918591 :   gcc_assert (res);
     704                 :     918591 :   return res;
     705                 :            : }
     706                 :            : 
     707                 :            : extern insn_code maybe_code_for_pro_epilogue_adjust_stack_sub (machine_mode);
     708                 :            : inline insn_code
     709                 :            : code_for_pro_epilogue_adjust_stack_sub (machine_mode arg0)
     710                 :            : {
     711                 :            :   insn_code code = maybe_code_for_pro_epilogue_adjust_stack_sub (arg0);
     712                 :            :   gcc_assert (code != CODE_FOR_nothing);
     713                 :            :   return code;
     714                 :            : }
     715                 :            : 
     716                 :            : extern rtx maybe_gen_pro_epilogue_adjust_stack_sub (machine_mode, rtx, rtx, rtx);
     717                 :            : inline rtx
     718                 :          2 : gen_pro_epilogue_adjust_stack_sub (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     719                 :            : {
     720                 :          2 :   rtx res = maybe_gen_pro_epilogue_adjust_stack_sub (arg0, x0, x1, x2);
     721                 :          2 :   gcc_assert (res);
     722                 :          2 :   return res;
     723                 :            : }
     724                 :            : 
     725                 :            : extern insn_code maybe_code_for_allocate_stack_worker_probe (machine_mode);
     726                 :            : inline insn_code
     727                 :            : code_for_allocate_stack_worker_probe (machine_mode arg0)
     728                 :            : {
     729                 :            :   insn_code code = maybe_code_for_allocate_stack_worker_probe (arg0);
     730                 :            :   gcc_assert (code != CODE_FOR_nothing);
     731                 :            :   return code;
     732                 :            : }
     733                 :            : 
     734                 :            : extern rtx maybe_gen_allocate_stack_worker_probe (machine_mode, rtx, rtx);
     735                 :            : inline rtx
     736                 :          2 : gen_allocate_stack_worker_probe (machine_mode arg0, rtx x0, rtx x1)
     737                 :            : {
     738                 :          2 :   rtx res = maybe_gen_allocate_stack_worker_probe (arg0, x0, x1);
     739                 :          2 :   gcc_assert (res);
     740                 :          2 :   return res;
     741                 :            : }
     742                 :            : 
     743                 :            : extern insn_code maybe_code_for_probe_stack_1 (machine_mode);
     744                 :            : inline insn_code
     745                 :            : code_for_probe_stack_1 (machine_mode arg0)
     746                 :            : {
     747                 :            :   insn_code code = maybe_code_for_probe_stack_1 (arg0);
     748                 :            :   gcc_assert (code != CODE_FOR_nothing);
     749                 :            :   return code;
     750                 :            : }
     751                 :            : 
     752                 :            : extern rtx maybe_gen_probe_stack_1 (machine_mode, rtx, rtx);
     753                 :            : inline rtx
     754                 :         76 : gen_probe_stack_1 (machine_mode arg0, rtx x0, rtx x1)
     755                 :            : {
     756                 :         76 :   rtx res = maybe_gen_probe_stack_1 (arg0, x0, x1);
     757                 :         76 :   gcc_assert (res);
     758                 :         76 :   return res;
     759                 :            : }
     760                 :            : 
     761                 :            : extern insn_code maybe_code_for_adjust_stack_and_probe (machine_mode);
     762                 :            : inline insn_code
     763                 :            : code_for_adjust_stack_and_probe (machine_mode arg0)
     764                 :            : {
     765                 :            :   insn_code code = maybe_code_for_adjust_stack_and_probe (arg0);
     766                 :            :   gcc_assert (code != CODE_FOR_nothing);
     767                 :            :   return code;
     768                 :            : }
     769                 :            : 
     770                 :            : extern rtx maybe_gen_adjust_stack_and_probe (machine_mode, rtx, rtx, rtx);
     771                 :            : inline rtx
     772                 :         18 : gen_adjust_stack_and_probe (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     773                 :            : {
     774                 :         18 :   rtx res = maybe_gen_adjust_stack_and_probe (arg0, x0, x1, x2);
     775                 :         18 :   gcc_assert (res);
     776                 :         18 :   return res;
     777                 :            : }
     778                 :            : 
     779                 :            : extern insn_code maybe_code_for_probe_stack_range (machine_mode);
     780                 :            : inline insn_code
     781                 :            : code_for_probe_stack_range (machine_mode arg0)
     782                 :            : {
     783                 :            :   insn_code code = maybe_code_for_probe_stack_range (arg0);
     784                 :            :   gcc_assert (code != CODE_FOR_nothing);
     785                 :            :   return code;
     786                 :            : }
     787                 :            : 
     788                 :            : extern rtx maybe_gen_probe_stack_range (machine_mode, rtx, rtx, rtx);
     789                 :            : inline rtx
     790                 :          0 : gen_probe_stack_range (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     791                 :            : {
     792                 :          0 :   rtx res = maybe_gen_probe_stack_range (arg0, x0, x1, x2);
     793                 :          0 :   gcc_assert (res);
     794                 :          0 :   return res;
     795                 :            : }
     796                 :            : 
     797                 :            : extern insn_code maybe_code_for_stack_protect_set_1 (machine_mode);
     798                 :            : inline insn_code
     799                 :            : code_for_stack_protect_set_1 (machine_mode arg0)
     800                 :            : {
     801                 :            :   insn_code code = maybe_code_for_stack_protect_set_1 (arg0);
     802                 :            :   gcc_assert (code != CODE_FOR_nothing);
     803                 :            :   return code;
     804                 :            : }
     805                 :            : 
     806                 :            : extern rtx maybe_gen_stack_protect_set_1 (machine_mode, rtx, rtx);
     807                 :            : inline rtx
     808                 :        163 : gen_stack_protect_set_1 (machine_mode arg0, rtx x0, rtx x1)
     809                 :            : {
     810                 :        163 :   rtx res = maybe_gen_stack_protect_set_1 (arg0, x0, x1);
     811                 :        163 :   gcc_assert (res);
     812                 :        163 :   return res;
     813                 :            : }
     814                 :            : 
     815                 :            : extern insn_code maybe_code_for_stack_protect_test_1 (machine_mode);
     816                 :            : inline insn_code
     817                 :        120 : code_for_stack_protect_test_1 (machine_mode arg0)
     818                 :            : {
     819                 :        120 :   insn_code code = maybe_code_for_stack_protect_test_1 (arg0);
     820                 :        120 :   gcc_assert (code != CODE_FOR_nothing);
     821                 :        120 :   return code;
     822                 :            : }
     823                 :            : 
     824                 :            : extern rtx maybe_gen_stack_protect_test_1 (machine_mode, rtx, rtx, rtx);
     825                 :            : inline rtx
     826                 :        163 : gen_stack_protect_test_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     827                 :            : {
     828                 :        163 :   rtx res = maybe_gen_stack_protect_test_1 (arg0, x0, x1, x2);
     829                 :        163 :   gcc_assert (res);
     830                 :        163 :   return res;
     831                 :            : }
     832                 :            : 
     833                 :            : extern insn_code maybe_code_for_lwp_slwpcb_1 (machine_mode);
     834                 :            : inline insn_code
     835                 :            : code_for_lwp_slwpcb_1 (machine_mode arg0)
     836                 :            : {
     837                 :            :   insn_code code = maybe_code_for_lwp_slwpcb_1 (arg0);
     838                 :            :   gcc_assert (code != CODE_FOR_nothing);
     839                 :            :   return code;
     840                 :            : }
     841                 :            : 
     842                 :            : extern rtx maybe_gen_lwp_slwpcb_1 (machine_mode, rtx);
     843                 :            : inline rtx
     844                 :          8 : gen_lwp_slwpcb_1 (machine_mode arg0, rtx x0)
     845                 :            : {
     846                 :          8 :   rtx res = maybe_gen_lwp_slwpcb_1 (arg0, x0);
     847                 :          8 :   gcc_assert (res);
     848                 :          8 :   return res;
     849                 :            : }
     850                 :            : 
     851                 :            : extern insn_code maybe_code_for_monitorx (machine_mode);
     852                 :            : inline insn_code
     853                 :            : code_for_monitorx (machine_mode arg0)
     854                 :            : {
     855                 :            :   insn_code code = maybe_code_for_monitorx (arg0);
     856                 :            :   gcc_assert (code != CODE_FOR_nothing);
     857                 :            :   return code;
     858                 :            : }
     859                 :            : 
     860                 :            : extern rtx maybe_gen_monitorx (machine_mode, rtx, rtx, rtx);
     861                 :            : inline rtx
     862                 :         11 : gen_monitorx (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     863                 :            : {
     864                 :         11 :   rtx res = maybe_gen_monitorx (arg0, x0, x1, x2);
     865                 :         11 :   gcc_assert (res);
     866                 :         11 :   return res;
     867                 :            : }
     868                 :            : 
     869                 :            : extern insn_code maybe_code_for_clzero (machine_mode);
     870                 :            : inline insn_code
     871                 :            : code_for_clzero (machine_mode arg0)
     872                 :            : {
     873                 :            :   insn_code code = maybe_code_for_clzero (arg0);
     874                 :            :   gcc_assert (code != CODE_FOR_nothing);
     875                 :            :   return code;
     876                 :            : }
     877                 :            : 
     878                 :            : extern rtx maybe_gen_clzero (machine_mode, rtx);
     879                 :            : inline rtx
     880                 :          9 : gen_clzero (machine_mode arg0, rtx x0)
     881                 :            : {
     882                 :          9 :   rtx res = maybe_gen_clzero (arg0, x0);
     883                 :          9 :   gcc_assert (res);
     884                 :          9 :   return res;
     885                 :            : }
     886                 :            : 
     887                 :            : extern insn_code maybe_code_for_movdir64b (machine_mode);
     888                 :            : inline insn_code
     889                 :            : code_for_movdir64b (machine_mode arg0)
     890                 :            : {
     891                 :            :   insn_code code = maybe_code_for_movdir64b (arg0);
     892                 :            :   gcc_assert (code != CODE_FOR_nothing);
     893                 :            :   return code;
     894                 :            : }
     895                 :            : 
     896                 :            : extern rtx maybe_gen_movdir64b (machine_mode, rtx, rtx);
     897                 :            : inline rtx
     898                 :         13 : gen_movdir64b (machine_mode arg0, rtx x0, rtx x1)
     899                 :            : {
     900                 :         13 :   rtx res = maybe_gen_movdir64b (arg0, x0, x1);
     901                 :         13 :   gcc_assert (res);
     902                 :         13 :   return res;
     903                 :            : }
     904                 :            : 
     905                 :            : extern insn_code maybe_code_for_enqcmd (int, machine_mode);
     906                 :            : inline insn_code
     907                 :            : code_for_enqcmd (int arg0, machine_mode arg1)
     908                 :            : {
     909                 :            :   insn_code code = maybe_code_for_enqcmd (arg0, arg1);
     910                 :            :   gcc_assert (code != CODE_FOR_nothing);
     911                 :            :   return code;
     912                 :            : }
     913                 :            : 
     914                 :            : extern rtx maybe_gen_enqcmd (int, machine_mode, rtx, rtx);
     915                 :            : inline rtx
     916                 :         22 : gen_enqcmd (int arg0, machine_mode arg1, rtx x0, rtx x1)
     917                 :            : {
     918                 :         22 :   rtx res = maybe_gen_enqcmd (arg0, arg1, x0, x1);
     919                 :         22 :   gcc_assert (res);
     920                 :         22 :   return res;
     921                 :            : }
     922                 :            : 
     923                 :            : extern insn_code maybe_code_for_umonitor (machine_mode);
     924                 :            : inline insn_code
     925                 :            : code_for_umonitor (machine_mode arg0)
     926                 :            : {
     927                 :            :   insn_code code = maybe_code_for_umonitor (arg0);
     928                 :            :   gcc_assert (code != CODE_FOR_nothing);
     929                 :            :   return code;
     930                 :            : }
     931                 :            : 
     932                 :            : extern rtx maybe_gen_umonitor (machine_mode, rtx);
     933                 :            : inline rtx
     934                 :         13 : gen_umonitor (machine_mode arg0, rtx x0)
     935                 :            : {
     936                 :         13 :   rtx res = maybe_gen_umonitor (arg0, x0);
     937                 :         13 :   gcc_assert (res);
     938                 :         13 :   return res;
     939                 :            : }
     940                 :            : 
     941                 :            : extern insn_code maybe_code_for_sse3_monitor (machine_mode);
     942                 :            : inline insn_code
     943                 :            : code_for_sse3_monitor (machine_mode arg0)
     944                 :            : {
     945                 :            :   insn_code code = maybe_code_for_sse3_monitor (arg0);
     946                 :            :   gcc_assert (code != CODE_FOR_nothing);
     947                 :            :   return code;
     948                 :            : }
     949                 :            : 
     950                 :            : extern rtx maybe_gen_sse3_monitor (machine_mode, rtx, rtx, rtx);
     951                 :            : inline rtx
     952                 :         15 : gen_sse3_monitor (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     953                 :            : {
     954                 :         15 :   rtx res = maybe_gen_sse3_monitor (arg0, x0, x1, x2);
     955                 :         15 :   gcc_assert (res);
     956                 :         15 :   return res;
     957                 :            : }
     958                 :            : #endif
     959                 :            : 
     960                 :            : extern const struct convert_optab_libcall_d convlib_def[NUM_CONVLIB_OPTABS];
     961                 :            : extern const struct optab_libcall_d normlib_def[NUM_NORMLIB_OPTABS];
     962                 :            : 
     963                 :            : /* Returns the active icode for the given (encoded) optab.  */
     964                 :            : extern enum insn_code raw_optab_handler (unsigned);
     965                 :            : extern bool swap_optab_enable (optab, machine_mode, bool);
     966                 :            : 
     967                 :            : /* Target-dependent globals.  */
     968                 :            : struct target_optabs {
     969                 :            :   /* Patterns that are used by optabs that are enabled for this target.  */
     970                 :            :   bool pat_enable[NUM_OPTAB_PATTERNS];
     971                 :            : 
     972                 :            :   /* Cache if the target supports vec_gather_load for at least one vector
     973                 :            :      mode.  */
     974                 :            :   bool supports_vec_gather_load;
     975                 :            :   bool supports_vec_gather_load_cached;
     976                 :            :   bool supports_vec_scatter_store;
     977                 :            :   bool supports_vec_scatter_store_cached;
     978                 :            : };
     979                 :            : extern void init_all_optabs (struct target_optabs *);
     980                 :            : 
     981                 :            : extern struct target_optabs default_target_optabs;
     982                 :            : extern struct target_optabs *this_fn_optabs;
     983                 :            : #if SWITCHABLE_TARGET
     984                 :            : extern struct target_optabs *this_target_optabs;
     985                 :            : #else
     986                 :            : #define this_target_optabs (&default_target_optabs)
     987                 :            : #endif
     988                 :            : #endif

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.