LCOV - code coverage report
Current view: top level - /mnt/build/buildbot/bld/build-lcov/gcc - insn-opinit.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 96.1 % 204 196
Test Date: 2026-11-14 16:39:50 Functions: 96.1 % 51 49
Legend: Lines:     hit not hit

            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              :   ustrunc_optab,
      24              :   sstrunc_optab,
      25              :   sfixtrunc_optab,
      26              :   ufixtrunc_optab,
      27              :   smul_widen_optab,
      28              :   umul_widen_optab,
      29              :   usmul_widen_optab,
      30              :   smadd_widen_optab,
      31              :   umadd_widen_optab,
      32              :   ssmadd_widen_optab,
      33              :   usmadd_widen_optab,
      34              :   smsub_widen_optab,
      35              :   umsub_widen_optab,
      36              :   ssmsub_widen_optab,
      37              :   usmsub_widen_optab,
      38              :   reduc_widen_ssum_optab,
      39              :   reduc_widen_usum_optab,
      40              :   crc_optab,
      41              :   crc_rev_optab,
      42              :   vec_load_lanes_optab,
      43              :   vec_store_lanes_optab,
      44              :   vec_mask_load_lanes_optab,
      45              :   vec_mask_store_lanes_optab,
      46              :   vec_mask_len_load_lanes_optab,
      47              :   vec_mask_len_store_lanes_optab,
      48              :   vcond_mask_optab,
      49              :   vec_cmp_optab,
      50              :   vec_cmpu_optab,
      51              :   vec_cmpeq_optab,
      52              :   maskload_optab,
      53              :   maskstore_optab,
      54              :   mask_len_load_optab,
      55              :   mask_len_store_optab,
      56              :   gather_load_optab,
      57              :   mask_gather_load_optab,
      58              :   mask_len_gather_load_optab,
      59              :   scatter_store_optab,
      60              :   mask_scatter_store_optab,
      61              :   mask_len_scatter_store_optab,
      62              :   vec_extract_optab,
      63              :   vec_init_optab,
      64              :   sdot_prod_optab,
      65              :   udot_prod_optab,
      66              :   usdot_prod_optab,
      67              :   usad_optab,
      68              :   ssad_optab,
      69              :   while_ult_optab,
      70              :   select_vl_optab,
      71              :   add_optab,
      72              :   addv_optab,
      73              :   ssadd_optab,
      74              :   usadd_optab,
      75              :   sub_optab,
      76              :   subv_optab,
      77              :   sssub_optab,
      78              :   ussub_optab,
      79              :   smul_optab,
      80              :   smulv_optab,
      81              :   ssmul_optab,
      82              :   usmul_optab,
      83              :   sdiv_optab,
      84              :   sdivv_optab,
      85              :   ssdiv_optab,
      86              :   udiv_optab,
      87              :   usdiv_optab,
      88              :   sdivmod_optab,
      89              :   udivmod_optab,
      90              :   smod_optab,
      91              :   umod_optab,
      92              :   ftrunc_optab,
      93              :   and_optab,
      94              :   ior_optab,
      95              :   xor_optab,
      96              :   ashl_optab,
      97              :   ssashl_optab,
      98              :   usashl_optab,
      99              :   ashr_optab,
     100              :   lshr_optab,
     101              :   rotl_optab,
     102              :   rotr_optab,
     103              :   vashl_optab,
     104              :   vashr_optab,
     105              :   vlshr_optab,
     106              :   vrotl_optab,
     107              :   vrotr_optab,
     108              :   smin_optab,
     109              :   smax_optab,
     110              :   umin_optab,
     111              :   umax_optab,
     112              :   neg_optab,
     113              :   negv_optab,
     114              :   ssneg_optab,
     115              :   usneg_optab,
     116              :   abs_optab,
     117              :   absv_optab,
     118              :   one_cmpl_optab,
     119              :   bswap_optab,
     120              :   bitreverse_optab,
     121              :   ffs_optab,
     122              :   clz_optab,
     123              :   ctz_optab,
     124              :   clrsb_optab,
     125              :   popcount_optab,
     126              :   parity_optab,
     127              :   cmp_optab,
     128              :   ucmp_optab,
     129              :   eq_optab,
     130              :   ne_optab,
     131              :   gt_optab,
     132              :   ge_optab,
     133              :   lt_optab,
     134              :   le_optab,
     135              :   unord_optab,
     136              :   powi_optab,
     137              :   bitinttofp_optab,
     138              :   bitintfromfp_optab,
     139              :   sqrt_optab,
     140              :   sync_old_add_optab,
     141              :   sync_old_sub_optab,
     142              :   sync_old_ior_optab,
     143              :   sync_old_and_optab,
     144              :   sync_old_xor_optab,
     145              :   sync_old_nand_optab,
     146              :   sync_new_add_optab,
     147              :   sync_new_sub_optab,
     148              :   sync_new_ior_optab,
     149              :   sync_new_and_optab,
     150              :   sync_new_xor_optab,
     151              :   sync_new_nand_optab,
     152              :   sync_compare_and_swap_optab,
     153              :   sync_lock_test_and_set_optab,
     154              :   mov_optab,
     155              :   movstrict_optab,
     156              :   movmisalign_optab,
     157              :   storent_optab,
     158              :   insv_optab,
     159              :   extv_optab,
     160              :   extzv_optab,
     161              :   insvmisalign_optab,
     162              :   extvmisalign_optab,
     163              :   extzvmisalign_optab,
     164              :   push_optab,
     165              :   reload_in_optab,
     166              :   reload_out_optab,
     167              :   cbranch_optab,
     168              :   tbranch_eq_optab,
     169              :   tbranch_ne_optab,
     170              :   addcc_optab,
     171              :   negcc_optab,
     172              :   notcc_optab,
     173              :   movcc_optab,
     174              :   cond_sqrt_optab,
     175              :   cond_add_optab,
     176              :   cond_sub_optab,
     177              :   cond_smul_optab,
     178              :   cond_sdiv_optab,
     179              :   cond_smod_optab,
     180              :   cond_udiv_optab,
     181              :   cond_umod_optab,
     182              :   cond_and_optab,
     183              :   cond_ior_optab,
     184              :   cond_xor_optab,
     185              :   cond_ashl_optab,
     186              :   cond_ashr_optab,
     187              :   cond_lshr_optab,
     188              :   cond_smin_optab,
     189              :   cond_smax_optab,
     190              :   cond_umin_optab,
     191              :   cond_umax_optab,
     192              :   cond_copysign_optab,
     193              :   cond_fmin_optab,
     194              :   cond_fmax_optab,
     195              :   cond_fma_optab,
     196              :   cond_fms_optab,
     197              :   cond_fnma_optab,
     198              :   cond_fnms_optab,
     199              :   cond_neg_optab,
     200              :   cond_vec_cbranch_any_optab,
     201              :   cond_vec_cbranch_all_optab,
     202              :   cond_one_cmpl_optab,
     203              :   cond_len_sqrt_optab,
     204              :   cond_len_add_optab,
     205              :   cond_len_sub_optab,
     206              :   cond_len_smul_optab,
     207              :   cond_len_sdiv_optab,
     208              :   cond_len_smod_optab,
     209              :   cond_len_udiv_optab,
     210              :   cond_len_umod_optab,
     211              :   cond_len_and_optab,
     212              :   cond_len_ior_optab,
     213              :   cond_len_xor_optab,
     214              :   cond_len_ashl_optab,
     215              :   cond_len_ashr_optab,
     216              :   cond_len_lshr_optab,
     217              :   cond_len_smin_optab,
     218              :   cond_len_smax_optab,
     219              :   cond_len_umin_optab,
     220              :   cond_len_umax_optab,
     221              :   cond_len_copysign_optab,
     222              :   cond_len_fmin_optab,
     223              :   cond_len_fmax_optab,
     224              :   cond_len_fma_optab,
     225              :   cond_len_fms_optab,
     226              :   cond_len_fnma_optab,
     227              :   cond_len_fnms_optab,
     228              :   cond_len_neg_optab,
     229              :   cond_len_one_cmpl_optab,
     230              :   cond_len_vec_cbranch_any_optab,
     231              :   cond_len_vec_cbranch_all_optab,
     232              :   vcond_mask_len_optab,
     233              :   cstore_optab,
     234              :   ctrap_optab,
     235              :   addv4_optab,
     236              :   subv4_optab,
     237              :   mulv4_optab,
     238              :   uaddv4_optab,
     239              :   usubv4_optab,
     240              :   umulv4_optab,
     241              :   negv3_optab,
     242              :   uaddc5_optab,
     243              :   usubc5_optab,
     244              :   addptr3_optab,
     245              :   spaceship_optab,
     246              :   smul_highpart_optab,
     247              :   umul_highpart_optab,
     248              :   cmpmem_optab,
     249              :   cmpstr_optab,
     250              :   cmpstrn_optab,
     251              :   cpymem_optab,
     252              :   movmem_optab,
     253              :   setmem_optab,
     254              :   strlen_optab,
     255              :   rawmemchr_optab,
     256              :   fma_optab,
     257              :   fms_optab,
     258              :   fnma_optab,
     259              :   fnms_optab,
     260              :   rint_optab,
     261              :   round_optab,
     262              :   roundeven_optab,
     263              :   floor_optab,
     264              :   ceil_optab,
     265              :   btrunc_optab,
     266              :   nearbyint_optab,
     267              :   cond_rint_optab,
     268              :   cond_round_optab,
     269              :   cond_floor_optab,
     270              :   cond_ceil_optab,
     271              :   cond_len_rint_optab,
     272              :   cond_len_round_optab,
     273              :   cond_len_floor_optab,
     274              :   cond_len_ceil_optab,
     275              :   acos_optab,
     276              :   acosh_optab,
     277              :   asin_optab,
     278              :   asinh_optab,
     279              :   atan2_optab,
     280              :   atan_optab,
     281              :   atanh_optab,
     282              :   copysign_optab,
     283              :   xorsign_optab,
     284              :   cadd90_optab,
     285              :   cadd270_optab,
     286              :   cmul_optab,
     287              :   cmul_conj_optab,
     288              :   cmla_optab,
     289              :   cmla_conj_optab,
     290              :   cmls_optab,
     291              :   cmls_conj_optab,
     292              :   cos_optab,
     293              :   cosh_optab,
     294              :   exp10_optab,
     295              :   exp2_optab,
     296              :   exp_optab,
     297              :   expm1_optab,
     298              :   fmod_optab,
     299              :   hypot_optab,
     300              :   ilogb_optab,
     301              :   isinf_optab,
     302              :   isfinite_optab,
     303              :   isnormal_optab,
     304              :   issignaling_optab,
     305              :   isnan_optab,
     306              :   ldexp_optab,
     307              :   log10_optab,
     308              :   log1p_optab,
     309              :   log2_optab,
     310              :   log_optab,
     311              :   logb_optab,
     312              :   pow_optab,
     313              :   remainder_optab,
     314              :   rsqrt_optab,
     315              :   scalb_optab,
     316              :   signbit_optab,
     317              :   significand_optab,
     318              :   sin_optab,
     319              :   sincos_optab,
     320              :   sinh_optab,
     321              :   tan_optab,
     322              :   tanh_optab,
     323              :   fegetround_optab,
     324              :   feclearexcept_optab,
     325              :   feraiseexcept_optab,
     326              :   fmax_optab,
     327              :   fmin_optab,
     328              :   reduc_fmax_scal_optab,
     329              :   reduc_fmin_scal_optab,
     330              :   reduc_smax_scal_optab,
     331              :   reduc_smin_scal_optab,
     332              :   reduc_plus_scal_optab,
     333              :   reduc_umax_scal_optab,
     334              :   reduc_umin_scal_optab,
     335              :   reduc_and_scal_optab,
     336              :   reduc_ior_scal_optab,
     337              :   reduc_xor_scal_optab,
     338              :   reduc_sbool_and_scal_optab,
     339              :   reduc_sbool_ior_scal_optab,
     340              :   reduc_sbool_xor_scal_optab,
     341              :   fold_left_plus_optab,
     342              :   mask_fold_left_plus_optab,
     343              :   mask_len_fold_left_plus_optab,
     344              :   extract_last_active_optab,
     345              :   fold_extract_last_optab,
     346              :   len_fold_extract_last_optab,
     347              :   uabd_optab,
     348              :   sabd_optab,
     349              :   savg_floor_optab,
     350              :   uavg_floor_optab,
     351              :   savg_ceil_optab,
     352              :   uavg_ceil_optab,
     353              :   smulhs_optab,
     354              :   smulhrs_optab,
     355              :   umulhs_optab,
     356              :   umulhrs_optab,
     357              :   sdiv_pow2_optab,
     358              :   vec_cbranch_any_optab,
     359              :   vec_cbranch_all_optab,
     360              :   vec_pack_sfix_trunc_optab,
     361              :   vec_pack_ssat_optab,
     362              :   vec_pack_trunc_optab,
     363              :   vec_pack_ufix_trunc_optab,
     364              :   vec_pack_sbool_trunc_optab,
     365              :   vec_pack_usat_optab,
     366              :   vec_packs_float_optab,
     367              :   vec_packu_float_optab,
     368              :   vec_perm_optab,
     369              :   vec_realign_load_optab,
     370              :   vec_set_optab,
     371              :   vec_shl_optab,
     372              :   vec_shr_optab,
     373              :   vec_unpack_sfix_trunc_hi_optab,
     374              :   vec_unpack_sfix_trunc_lo_optab,
     375              :   vec_unpack_ufix_trunc_hi_optab,
     376              :   vec_unpack_ufix_trunc_lo_optab,
     377              :   vec_unpacks_float_hi_optab,
     378              :   vec_unpacks_float_lo_optab,
     379              :   vec_unpacks_hi_optab,
     380              :   vec_unpacks_lo_optab,
     381              :   vec_unpacks_sbool_hi_optab,
     382              :   vec_unpacks_sbool_lo_optab,
     383              :   vec_unpacku_float_hi_optab,
     384              :   vec_unpacku_float_lo_optab,
     385              :   vec_unpacku_hi_optab,
     386              :   vec_unpacku_lo_optab,
     387              :   vec_widen_smult_even_optab,
     388              :   vec_widen_smult_hi_optab,
     389              :   vec_widen_smult_lo_optab,
     390              :   vec_widen_smult_odd_optab,
     391              :   vec_widen_ssub_optab,
     392              :   vec_widen_ssub_hi_optab,
     393              :   vec_widen_ssub_lo_optab,
     394              :   vec_widen_ssub_odd_optab,
     395              :   vec_widen_ssub_even_optab,
     396              :   vec_widen_sadd_optab,
     397              :   vec_widen_sadd_hi_optab,
     398              :   vec_widen_sadd_lo_optab,
     399              :   vec_widen_sadd_odd_optab,
     400              :   vec_widen_sadd_even_optab,
     401              :   vec_widen_sabd_optab,
     402              :   vec_widen_sabd_hi_optab,
     403              :   vec_widen_sabd_lo_optab,
     404              :   vec_widen_sabd_odd_optab,
     405              :   vec_widen_sabd_even_optab,
     406              :   vec_widen_sshiftl_hi_optab,
     407              :   vec_widen_sshiftl_lo_optab,
     408              :   vec_widen_umult_even_optab,
     409              :   vec_widen_umult_hi_optab,
     410              :   vec_widen_umult_lo_optab,
     411              :   vec_widen_umult_odd_optab,
     412              :   vec_widen_ushiftl_hi_optab,
     413              :   vec_widen_ushiftl_lo_optab,
     414              :   vec_widen_usub_optab,
     415              :   vec_widen_usub_hi_optab,
     416              :   vec_widen_usub_lo_optab,
     417              :   vec_widen_usub_odd_optab,
     418              :   vec_widen_usub_even_optab,
     419              :   vec_widen_uadd_optab,
     420              :   vec_widen_uadd_hi_optab,
     421              :   vec_widen_uadd_lo_optab,
     422              :   vec_widen_uadd_odd_optab,
     423              :   vec_widen_uadd_even_optab,
     424              :   vec_widen_uabd_optab,
     425              :   vec_widen_uabd_hi_optab,
     426              :   vec_widen_uabd_lo_optab,
     427              :   vec_widen_uabd_odd_optab,
     428              :   vec_widen_uabd_even_optab,
     429              :   vec_trunc_add_high_optab,
     430              :   vec_addsub_optab,
     431              :   vec_fmaddsub_optab,
     432              :   vec_fmsubadd_optab,
     433              :   sync_add_optab,
     434              :   sync_and_optab,
     435              :   sync_ior_optab,
     436              :   sync_lock_release_optab,
     437              :   sync_nand_optab,
     438              :   sync_sub_optab,
     439              :   sync_xor_optab,
     440              :   atomic_add_fetch_optab,
     441              :   atomic_add_optab,
     442              :   atomic_and_fetch_optab,
     443              :   atomic_and_optab,
     444              :   atomic_bit_test_and_set_optab,
     445              :   atomic_bit_test_and_complement_optab,
     446              :   atomic_bit_test_and_reset_optab,
     447              :   atomic_compare_and_swap_optab,
     448              :   atomic_exchange_optab,
     449              :   atomic_fetch_add_optab,
     450              :   atomic_fetch_and_optab,
     451              :   atomic_fetch_nand_optab,
     452              :   atomic_fetch_or_optab,
     453              :   atomic_fetch_sub_optab,
     454              :   atomic_fetch_xor_optab,
     455              :   atomic_load_optab,
     456              :   atomic_nand_fetch_optab,
     457              :   atomic_nand_optab,
     458              :   atomic_or_fetch_optab,
     459              :   atomic_or_optab,
     460              :   atomic_store_optab,
     461              :   atomic_sub_fetch_optab,
     462              :   atomic_sub_optab,
     463              :   atomic_xor_fetch_optab,
     464              :   atomic_xor_optab,
     465              :   atomic_add_fetch_cmp_0_optab,
     466              :   atomic_sub_fetch_cmp_0_optab,
     467              :   atomic_and_fetch_cmp_0_optab,
     468              :   atomic_or_fetch_cmp_0_optab,
     469              :   atomic_xor_fetch_cmp_0_optab,
     470              :   get_thread_pointer_optab,
     471              :   set_thread_pointer_optab,
     472              :   check_raw_ptrs_optab,
     473              :   check_war_ptrs_optab,
     474              :   vec_duplicate_optab,
     475              :   vec_series_optab,
     476              :   vec_shl_insert_optab,
     477              :   len_load_optab,
     478              :   len_store_optab,
     479              :   mask_len_strided_load_optab,
     480              :   mask_len_strided_store_optab,
     481              :   andn_optab,
     482              :   iorn_optab,
     483              :   aop_optab,
     484              :   clmul_optab,
     485              :   clmul_widen_optab,
     486              :   FIRST_CONV_OPTAB = sext_optab,
     487              :   LAST_CONVLIB_OPTAB = sstrunc_optab,
     488              :   LAST_CONV_OPTAB = select_vl_optab,
     489              :   FIRST_NORM_OPTAB = add_optab,
     490              :   LAST_NORMLIB_OPTAB = sync_lock_test_and_set_optab,
     491              :   LAST_NORM_OPTAB = clmul_widen_optab
     492              : };
     493              : 
     494              : #define NUM_OPTABS          479
     495              : #define NUM_CONVLIB_OPTABS  17
     496              : #define NUM_NORMLIB_OPTABS  83
     497              : #define NUM_OPTAB_PATTERNS  3008
     498              : typedef enum optab_tag optab;
     499              : typedef enum optab_tag convert_optab;
     500              : typedef enum optab_tag direct_optab;
     501              : 
     502              : struct optab_libcall_d
     503              : {
     504              :   char libcall_suffix;
     505              :   const char *libcall_basename;
     506              :   void (*libcall_gen) (optab, const char *name,
     507              :                        char suffix, machine_mode);
     508              : };
     509              : 
     510              : struct convert_optab_libcall_d
     511              : {
     512              :   const char *libcall_basename;
     513              :   void (*libcall_gen) (convert_optab, const char *name,
     514              :                        machine_mode, machine_mode);
     515              : };
     516              : 
     517              : /* Given an enum insn_code, access the function to construct
     518              :    the body of that kind of insn.  */
     519              : #define GEN_FCN(CODE) (insn_data[CODE].genfun)
     520              : 
     521              : #ifdef NUM_RTX_CODE
     522              : /* Contains the optab used for each rtx code, and vice-versa.  */
     523              : extern const optab code_to_optab_[NUM_RTX_CODE];
     524              : extern const enum rtx_code optab_to_code_[NUM_OPTABS];
     525              : 
     526              : static inline optab
     527    103274927 : code_to_optab (enum rtx_code code)
     528              : {
     529    103274927 :   return code_to_optab_[code];
     530              : }
     531              : 
     532              : static inline enum rtx_code
     533     47181398 : optab_to_code (optab op)
     534              : {
     535     47177440 :   return optab_to_code_[op];
     536              : }
     537              : 
     538              : extern insn_code maybe_code_for_ccmp (machine_mode);
     539              : inline insn_code
     540           34 : code_for_ccmp (machine_mode arg0)
     541              : {
     542           34 :   insn_code code = maybe_code_for_ccmp (arg0);
     543           34 :   gcc_assert (code != CODE_FOR_nothing);
     544           34 :   return code;
     545              : }
     546              : 
     547              : extern rtx maybe_gen_ccmp (machine_mode, rtx, rtx, rtx, rtx, rtx);
     548              : inline rtx
     549              : gen_ccmp (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4)
     550              : {
     551              :   rtx res = maybe_gen_ccmp (arg0, x0, x1, x2, x3, x4);
     552              :   gcc_assert (res);
     553              :   return res;
     554              : }
     555              : 
     556              : extern insn_code maybe_code_for_cmp_1 (machine_mode);
     557              : inline insn_code
     558              : code_for_cmp_1 (machine_mode arg0)
     559              : {
     560              :   insn_code code = maybe_code_for_cmp_1 (arg0);
     561              :   gcc_assert (code != CODE_FOR_nothing);
     562              :   return code;
     563              : }
     564              : 
     565              : extern rtx maybe_gen_cmp_1 (machine_mode, rtx, rtx);
     566              : inline rtx
     567        28005 : gen_cmp_1 (machine_mode arg0, rtx x0, rtx x1)
     568              : {
     569        28005 :   rtx res = maybe_gen_cmp_1 (arg0, x0, x1);
     570        28005 :   gcc_assert (res);
     571        28005 :   return res;
     572              : }
     573              : 
     574              : extern insn_code maybe_code_for_pushfl2 (machine_mode);
     575              : inline insn_code
     576              : code_for_pushfl2 (machine_mode arg0)
     577              : {
     578              :   insn_code code = maybe_code_for_pushfl2 (arg0);
     579              :   gcc_assert (code != CODE_FOR_nothing);
     580              :   return code;
     581              : }
     582              : 
     583              : extern rtx maybe_gen_pushfl2 (machine_mode, rtx, rtx);
     584              : inline rtx
     585           21 : gen_pushfl2 (machine_mode arg0, rtx x0, rtx x1)
     586              : {
     587           21 :   rtx res = maybe_gen_pushfl2 (arg0, x0, x1);
     588           21 :   gcc_assert (res);
     589           21 :   return res;
     590              : }
     591              : 
     592              : extern insn_code maybe_code_for_popfl1 (machine_mode);
     593              : inline insn_code
     594              : code_for_popfl1 (machine_mode arg0)
     595              : {
     596              :   insn_code code = maybe_code_for_popfl1 (arg0);
     597              :   gcc_assert (code != CODE_FOR_nothing);
     598              :   return code;
     599              : }
     600              : 
     601              : extern rtx maybe_gen_popfl1 (machine_mode, rtx, rtx);
     602              : inline rtx
     603           21 : gen_popfl1 (machine_mode arg0, rtx x0, rtx x1)
     604              : {
     605           21 :   rtx res = maybe_gen_popfl1 (arg0, x0, x1);
     606           21 :   gcc_assert (res);
     607           21 :   return res;
     608              : }
     609              : 
     610              : extern insn_code maybe_code_for_insv_1 (machine_mode);
     611              : inline insn_code
     612              : code_for_insv_1 (machine_mode arg0)
     613              : {
     614              :   insn_code code = maybe_code_for_insv_1 (arg0);
     615              :   gcc_assert (code != CODE_FOR_nothing);
     616              :   return code;
     617              : }
     618              : 
     619              : extern rtx maybe_gen_insv_1 (machine_mode, rtx, rtx);
     620              : inline rtx
     621         2402 : gen_insv_1 (machine_mode arg0, rtx x0, rtx x1)
     622              : {
     623         2402 :   rtx res = maybe_gen_insv_1 (arg0, x0, x1);
     624         2402 :   gcc_assert (res);
     625         2402 :   return res;
     626              : }
     627              : 
     628              : extern insn_code maybe_code_for_add3_carry (machine_mode);
     629              : inline insn_code
     630              : code_for_add3_carry (machine_mode arg0)
     631              : {
     632              :   insn_code code = maybe_code_for_add3_carry (arg0);
     633              :   gcc_assert (code != CODE_FOR_nothing);
     634              :   return code;
     635              : }
     636              : 
     637              : extern rtx maybe_gen_add3_carry (machine_mode, rtx, rtx, rtx, rtx, rtx);
     638              : inline rtx
     639         2065 : gen_add3_carry (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4)
     640              : {
     641         2065 :   rtx res = maybe_gen_add3_carry (arg0, x0, x1, x2, x3, x4);
     642         2065 :   gcc_assert (res);
     643         2065 :   return res;
     644              : }
     645              : 
     646              : extern insn_code maybe_code_for_sub3_carry (machine_mode);
     647              : inline insn_code
     648              : code_for_sub3_carry (machine_mode arg0)
     649              : {
     650              :   insn_code code = maybe_code_for_sub3_carry (arg0);
     651              :   gcc_assert (code != CODE_FOR_nothing);
     652              :   return code;
     653              : }
     654              : 
     655              : extern rtx maybe_gen_sub3_carry (machine_mode, rtx, rtx, rtx, rtx, rtx);
     656              : inline rtx
     657          228 : gen_sub3_carry (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3, rtx x4)
     658              : {
     659          228 :   rtx res = maybe_gen_sub3_carry (arg0, x0, x1, x2, x3, x4);
     660          228 :   gcc_assert (res);
     661          228 :   return res;
     662              : }
     663              : 
     664              : extern insn_code maybe_code_for_sub3_carry_ccc (machine_mode);
     665              : inline insn_code
     666              : code_for_sub3_carry_ccc (machine_mode arg0)
     667              : {
     668              :   insn_code code = maybe_code_for_sub3_carry_ccc (arg0);
     669              :   gcc_assert (code != CODE_FOR_nothing);
     670              :   return code;
     671              : }
     672              : 
     673              : extern rtx maybe_gen_sub3_carry_ccc (machine_mode, rtx, rtx, rtx);
     674              : inline rtx
     675        15635 : gen_sub3_carry_ccc (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     676              : {
     677        15635 :   rtx res = maybe_gen_sub3_carry_ccc (arg0, x0, x1, x2);
     678        15635 :   gcc_assert (res);
     679        15635 :   return res;
     680              : }
     681              : 
     682              : extern insn_code maybe_code_for_sub3_carry_ccgz (machine_mode);
     683              : inline insn_code
     684              : code_for_sub3_carry_ccgz (machine_mode arg0)
     685              : {
     686              :   insn_code code = maybe_code_for_sub3_carry_ccgz (arg0);
     687              :   gcc_assert (code != CODE_FOR_nothing);
     688              :   return code;
     689              : }
     690              : 
     691              : extern rtx maybe_gen_sub3_carry_ccgz (machine_mode, rtx, rtx, rtx);
     692              : inline rtx
     693         4474 : gen_sub3_carry_ccgz (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     694              : {
     695         4474 :   rtx res = maybe_gen_sub3_carry_ccgz (arg0, x0, x1, x2);
     696         4474 :   gcc_assert (res);
     697         4474 :   return res;
     698              : }
     699              : 
     700              : extern insn_code maybe_code_for_add3_cc_overflow_1 (machine_mode);
     701              : inline insn_code
     702              : code_for_add3_cc_overflow_1 (machine_mode arg0)
     703              : {
     704              :   insn_code code = maybe_code_for_add3_cc_overflow_1 (arg0);
     705              :   gcc_assert (code != CODE_FOR_nothing);
     706              :   return code;
     707              : }
     708              : 
     709              : extern rtx maybe_gen_add3_cc_overflow_1 (machine_mode, rtx, rtx, rtx);
     710              : inline rtx
     711         1940 : gen_add3_cc_overflow_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     712              : {
     713         1940 :   rtx res = maybe_gen_add3_cc_overflow_1 (arg0, x0, x1, x2);
     714         1940 :   gcc_assert (res);
     715         1940 :   return res;
     716              : }
     717              : 
     718              : extern insn_code maybe_code_for_test_ccno_1 (machine_mode);
     719              : inline insn_code
     720              : code_for_test_ccno_1 (machine_mode arg0)
     721              : {
     722              :   insn_code code = maybe_code_for_test_ccno_1 (arg0);
     723              :   gcc_assert (code != CODE_FOR_nothing);
     724              :   return code;
     725              : }
     726              : 
     727              : extern rtx maybe_gen_test_ccno_1 (machine_mode, rtx, rtx);
     728              : inline rtx
     729           27 : gen_test_ccno_1 (machine_mode arg0, rtx x0, rtx x1)
     730              : {
     731           27 :   rtx res = maybe_gen_test_ccno_1 (arg0, x0, x1);
     732           27 :   gcc_assert (res);
     733           27 :   return res;
     734              : }
     735              : 
     736              : extern insn_code maybe_code_for_x86_shift_adj_1 (machine_mode);
     737              : inline insn_code
     738              : code_for_x86_shift_adj_1 (machine_mode arg0)
     739              : {
     740              :   insn_code code = maybe_code_for_x86_shift_adj_1 (arg0);
     741              :   gcc_assert (code != CODE_FOR_nothing);
     742              :   return code;
     743              : }
     744              : 
     745              : extern rtx maybe_gen_x86_shift_adj_1 (machine_mode, rtx, rtx, rtx, rtx);
     746              : inline rtx
     747         2285 : gen_x86_shift_adj_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
     748              : {
     749         2285 :   rtx res = maybe_gen_x86_shift_adj_1 (arg0, x0, x1, x2, x3);
     750         2285 :   gcc_assert (res);
     751         2285 :   return res;
     752              : }
     753              : 
     754              : extern insn_code maybe_code_for_x86_shift_adj_2 (machine_mode);
     755              : inline insn_code
     756              : code_for_x86_shift_adj_2 (machine_mode arg0)
     757              : {
     758              :   insn_code code = maybe_code_for_x86_shift_adj_2 (arg0);
     759              :   gcc_assert (code != CODE_FOR_nothing);
     760              :   return code;
     761              : }
     762              : 
     763              : extern rtx maybe_gen_x86_shift_adj_2 (machine_mode, rtx, rtx, rtx);
     764              : inline rtx
     765          746 : gen_x86_shift_adj_2 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     766              : {
     767          746 :   rtx res = maybe_gen_x86_shift_adj_2 (arg0, x0, x1, x2);
     768          746 :   gcc_assert (res);
     769          746 :   return res;
     770              : }
     771              : 
     772              : extern insn_code maybe_code_for_x86_shift_adj_3 (machine_mode);
     773              : inline insn_code
     774              : code_for_x86_shift_adj_3 (machine_mode arg0)
     775              : {
     776              :   insn_code code = maybe_code_for_x86_shift_adj_3 (arg0);
     777              :   gcc_assert (code != CODE_FOR_nothing);
     778              :   return code;
     779              : }
     780              : 
     781              : extern rtx maybe_gen_x86_shift_adj_3 (machine_mode, rtx, rtx, rtx);
     782              : inline rtx
     783           40 : gen_x86_shift_adj_3 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     784              : {
     785           40 :   rtx res = maybe_gen_x86_shift_adj_3 (arg0, x0, x1, x2);
     786           40 :   gcc_assert (res);
     787           40 :   return res;
     788              : }
     789              : 
     790              : extern insn_code maybe_code_for_leave (machine_mode);
     791              : inline insn_code
     792              : code_for_leave (machine_mode arg0)
     793              : {
     794              :   insn_code code = maybe_code_for_leave (arg0);
     795              :   gcc_assert (code != CODE_FOR_nothing);
     796              :   return code;
     797              : }
     798              : 
     799              : extern rtx maybe_gen_leave (machine_mode);
     800              : inline rtx
     801       252930 : gen_leave (machine_mode arg0)
     802              : {
     803       252930 :   rtx res = maybe_gen_leave (arg0);
     804       252930 :   gcc_assert (res);
     805       252930 :   return res;
     806              : }
     807              : 
     808              : extern insn_code maybe_code_for_tbm_bextri (machine_mode);
     809              : inline insn_code
     810           18 : code_for_tbm_bextri (machine_mode arg0)
     811              : {
     812           18 :   insn_code code = maybe_code_for_tbm_bextri (arg0);
     813           18 :   gcc_assert (code != CODE_FOR_nothing);
     814           18 :   return code;
     815              : }
     816              : 
     817              : extern rtx maybe_gen_tbm_bextri (machine_mode, rtx, rtx, rtx, rtx);
     818              : inline rtx
     819              : gen_tbm_bextri (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
     820              : {
     821              :   rtx res = maybe_gen_tbm_bextri (arg0, x0, x1, x2, x3);
     822              :   gcc_assert (res);
     823              :   return res;
     824              : }
     825              : 
     826              : extern insn_code maybe_code_for_tls_global_dynamic_64 (machine_mode);
     827              : inline insn_code
     828              : code_for_tls_global_dynamic_64 (machine_mode arg0)
     829              : {
     830              :   insn_code code = maybe_code_for_tls_global_dynamic_64 (arg0);
     831              :   gcc_assert (code != CODE_FOR_nothing);
     832              :   return code;
     833              : }
     834              : 
     835              : extern rtx maybe_gen_tls_global_dynamic_64 (machine_mode, rtx, rtx, rtx, rtx);
     836              : inline rtx
     837         4402 : gen_tls_global_dynamic_64 (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
     838              : {
     839         4402 :   rtx res = maybe_gen_tls_global_dynamic_64 (arg0, x0, x1, x2, x3);
     840         4402 :   gcc_assert (res);
     841         4402 :   return res;
     842              : }
     843              : 
     844              : extern insn_code maybe_code_for_tls_local_dynamic_base_64 (machine_mode);
     845              : inline insn_code
     846              : code_for_tls_local_dynamic_base_64 (machine_mode arg0)
     847              : {
     848              :   insn_code code = maybe_code_for_tls_local_dynamic_base_64 (arg0);
     849              :   gcc_assert (code != CODE_FOR_nothing);
     850              :   return code;
     851              : }
     852              : 
     853              : extern rtx maybe_gen_tls_local_dynamic_base_64 (machine_mode, rtx, rtx, rtx);
     854              : inline rtx
     855          325 : gen_tls_local_dynamic_base_64 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     856              : {
     857          325 :   rtx res = maybe_gen_tls_local_dynamic_base_64 (arg0, x0, x1, x2);
     858          325 :   gcc_assert (res);
     859          325 :   return res;
     860              : }
     861              : 
     862              : extern insn_code maybe_code_for_tls_dynamic_gnu2_64 (machine_mode);
     863              : inline insn_code
     864              : code_for_tls_dynamic_gnu2_64 (machine_mode arg0)
     865              : {
     866              :   insn_code code = maybe_code_for_tls_dynamic_gnu2_64 (arg0);
     867              :   gcc_assert (code != CODE_FOR_nothing);
     868              :   return code;
     869              : }
     870              : 
     871              : extern rtx maybe_gen_tls_dynamic_gnu2_64 (machine_mode, rtx, rtx);
     872              : inline rtx
     873           88 : gen_tls_dynamic_gnu2_64 (machine_mode arg0, rtx x0, rtx x1)
     874              : {
     875           88 :   rtx res = maybe_gen_tls_dynamic_gnu2_64 (arg0, x0, x1);
     876           88 :   gcc_assert (res);
     877           88 :   return res;
     878              : }
     879              : 
     880              : extern insn_code maybe_code_for_pro_epilogue_adjust_stack_add (machine_mode);
     881              : inline insn_code
     882              : code_for_pro_epilogue_adjust_stack_add (machine_mode arg0)
     883              : {
     884              :   insn_code code = maybe_code_for_pro_epilogue_adjust_stack_add (arg0);
     885              :   gcc_assert (code != CODE_FOR_nothing);
     886              :   return code;
     887              : }
     888              : 
     889              : extern rtx maybe_gen_pro_epilogue_adjust_stack_add (machine_mode, rtx, rtx, rtx);
     890              : inline rtx
     891      1514658 : gen_pro_epilogue_adjust_stack_add (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     892              : {
     893      1514658 :   rtx res = maybe_gen_pro_epilogue_adjust_stack_add (arg0, x0, x1, x2);
     894      1514658 :   gcc_assert (res);
     895      1514658 :   return res;
     896              : }
     897              : 
     898              : extern insn_code maybe_code_for_pro_epilogue_adjust_stack_add_nocc (machine_mode);
     899              : inline insn_code
     900              : code_for_pro_epilogue_adjust_stack_add_nocc (machine_mode arg0)
     901              : {
     902              :   insn_code code = maybe_code_for_pro_epilogue_adjust_stack_add_nocc (arg0);
     903              :   gcc_assert (code != CODE_FOR_nothing);
     904              :   return code;
     905              : }
     906              : 
     907              : extern rtx maybe_gen_pro_epilogue_adjust_stack_add_nocc (machine_mode, rtx, rtx, rtx);
     908              : inline rtx
     909        95977 : gen_pro_epilogue_adjust_stack_add_nocc (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     910              : {
     911        95977 :   rtx res = maybe_gen_pro_epilogue_adjust_stack_add_nocc (arg0, x0, x1, x2);
     912        95977 :   gcc_assert (res);
     913        95977 :   return res;
     914              : }
     915              : 
     916              : extern insn_code maybe_code_for_pro_epilogue_adjust_stack_sub (machine_mode);
     917              : inline insn_code
     918              : code_for_pro_epilogue_adjust_stack_sub (machine_mode arg0)
     919              : {
     920              :   insn_code code = maybe_code_for_pro_epilogue_adjust_stack_sub (arg0);
     921              :   gcc_assert (code != CODE_FOR_nothing);
     922              :   return code;
     923              : }
     924              : 
     925              : extern rtx maybe_gen_pro_epilogue_adjust_stack_sub (machine_mode, rtx, rtx, rtx);
     926              : inline rtx
     927           45 : gen_pro_epilogue_adjust_stack_sub (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     928              : {
     929           45 :   rtx res = maybe_gen_pro_epilogue_adjust_stack_sub (arg0, x0, x1, x2);
     930           45 :   gcc_assert (res);
     931           45 :   return res;
     932              : }
     933              : 
     934              : extern insn_code maybe_code_for_allocate_stack_worker_probe (machine_mode);
     935              : inline insn_code
     936              : code_for_allocate_stack_worker_probe (machine_mode arg0)
     937              : {
     938              :   insn_code code = maybe_code_for_allocate_stack_worker_probe (arg0);
     939              :   gcc_assert (code != CODE_FOR_nothing);
     940              :   return code;
     941              : }
     942              : 
     943              : extern rtx maybe_gen_allocate_stack_worker_probe (machine_mode, rtx, rtx);
     944              : inline rtx
     945           45 : gen_allocate_stack_worker_probe (machine_mode arg0, rtx x0, rtx x1)
     946              : {
     947           45 :   rtx res = maybe_gen_allocate_stack_worker_probe (arg0, x0, x1);
     948           45 :   gcc_assert (res);
     949           45 :   return res;
     950              : }
     951              : 
     952              : extern insn_code maybe_code_for_adjust_stack_and_probe (machine_mode);
     953              : inline insn_code
     954              : code_for_adjust_stack_and_probe (machine_mode arg0)
     955              : {
     956              :   insn_code code = maybe_code_for_adjust_stack_and_probe (arg0);
     957              :   gcc_assert (code != CODE_FOR_nothing);
     958              :   return code;
     959              : }
     960              : 
     961              : extern rtx maybe_gen_adjust_stack_and_probe (machine_mode, rtx, rtx, rtx);
     962              : inline rtx
     963           25 : gen_adjust_stack_and_probe (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     964              : {
     965           25 :   rtx res = maybe_gen_adjust_stack_and_probe (arg0, x0, x1, x2);
     966           25 :   gcc_assert (res);
     967           25 :   return res;
     968              : }
     969              : 
     970              : extern insn_code maybe_code_for_probe_stack_range (machine_mode);
     971              : inline insn_code
     972              : code_for_probe_stack_range (machine_mode arg0)
     973              : {
     974              :   insn_code code = maybe_code_for_probe_stack_range (arg0);
     975              :   gcc_assert (code != CODE_FOR_nothing);
     976              :   return code;
     977              : }
     978              : 
     979              : extern rtx maybe_gen_probe_stack_range (machine_mode, rtx, rtx, rtx);
     980              : inline rtx
     981            0 : gen_probe_stack_range (machine_mode arg0, rtx x0, rtx x1, rtx x2)
     982              : {
     983            0 :   rtx res = maybe_gen_probe_stack_range (arg0, x0, x1, x2);
     984            0 :   gcc_assert (res);
     985            0 :   return res;
     986              : }
     987              : 
     988              : extern insn_code maybe_code_for_stack_protect_set_1 (machine_mode, machine_mode);
     989              : inline insn_code
     990              : code_for_stack_protect_set_1 (machine_mode arg0, machine_mode arg1)
     991              : {
     992              :   insn_code code = maybe_code_for_stack_protect_set_1 (arg0, arg1);
     993              :   gcc_assert (code != CODE_FOR_nothing);
     994              :   return code;
     995              : }
     996              : 
     997              : extern rtx maybe_gen_stack_protect_set_1 (machine_mode, machine_mode, rtx, rtx, rtx);
     998              : inline rtx
     999          295 : gen_stack_protect_set_1 (machine_mode arg0, machine_mode arg1, rtx x0, rtx x1, rtx x2)
    1000              : {
    1001          295 :   rtx res = maybe_gen_stack_protect_set_1 (arg0, arg1, x0, x1, x2);
    1002          295 :   gcc_assert (res);
    1003          295 :   return res;
    1004              : }
    1005              : 
    1006              : extern insn_code maybe_code_for_stack_protect_test_1 (machine_mode);
    1007              : inline insn_code
    1008          430 : code_for_stack_protect_test_1 (machine_mode arg0)
    1009              : {
    1010          430 :   insn_code code = maybe_code_for_stack_protect_test_1 (arg0);
    1011          430 :   gcc_assert (code != CODE_FOR_nothing);
    1012          430 :   return code;
    1013              : }
    1014              : 
    1015              : extern rtx maybe_gen_stack_protect_test_1 (machine_mode, rtx, rtx, rtx);
    1016              : inline rtx
    1017          328 : gen_stack_protect_test_1 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1018              : {
    1019          328 :   rtx res = maybe_gen_stack_protect_test_1 (arg0, x0, x1, x2);
    1020          328 :   gcc_assert (res);
    1021          328 :   return res;
    1022              : }
    1023              : 
    1024              : extern insn_code maybe_code_for_lwp_llwpcb (machine_mode);
    1025              : inline insn_code
    1026              : code_for_lwp_llwpcb (machine_mode arg0)
    1027              : {
    1028              :   insn_code code = maybe_code_for_lwp_llwpcb (arg0);
    1029              :   gcc_assert (code != CODE_FOR_nothing);
    1030              :   return code;
    1031              : }
    1032              : 
    1033              : extern rtx maybe_gen_lwp_llwpcb (machine_mode, rtx);
    1034              : inline rtx
    1035           18 : gen_lwp_llwpcb (machine_mode arg0, rtx x0)
    1036              : {
    1037           18 :   rtx res = maybe_gen_lwp_llwpcb (arg0, x0);
    1038           18 :   gcc_assert (res);
    1039           18 :   return res;
    1040              : }
    1041              : 
    1042              : extern insn_code maybe_code_for_lwp_slwpcb (machine_mode);
    1043              : inline insn_code
    1044              : code_for_lwp_slwpcb (machine_mode arg0)
    1045              : {
    1046              :   insn_code code = maybe_code_for_lwp_slwpcb (arg0);
    1047              :   gcc_assert (code != CODE_FOR_nothing);
    1048              :   return code;
    1049              : }
    1050              : 
    1051              : extern rtx maybe_gen_lwp_slwpcb (machine_mode, rtx);
    1052              : inline rtx
    1053           18 : gen_lwp_slwpcb (machine_mode arg0, rtx x0)
    1054              : {
    1055           18 :   rtx res = maybe_gen_lwp_slwpcb (arg0, x0);
    1056           18 :   gcc_assert (res);
    1057           18 :   return res;
    1058              : }
    1059              : 
    1060              : extern insn_code maybe_code_for_lwp_lwpval (machine_mode);
    1061              : inline insn_code
    1062           26 : code_for_lwp_lwpval (machine_mode arg0)
    1063              : {
    1064           26 :   insn_code code = maybe_code_for_lwp_lwpval (arg0);
    1065           26 :   gcc_assert (code != CODE_FOR_nothing);
    1066           26 :   return code;
    1067              : }
    1068              : 
    1069              : extern rtx maybe_gen_lwp_lwpval (machine_mode, rtx, rtx, rtx);
    1070              : inline rtx
    1071              : gen_lwp_lwpval (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1072              : {
    1073              :   rtx res = maybe_gen_lwp_lwpval (arg0, x0, x1, x2);
    1074              :   gcc_assert (res);
    1075              :   return res;
    1076              : }
    1077              : 
    1078              : extern insn_code maybe_code_for_lwp_lwpins (machine_mode);
    1079              : inline insn_code
    1080           25 : code_for_lwp_lwpins (machine_mode arg0)
    1081              : {
    1082           25 :   insn_code code = maybe_code_for_lwp_lwpins (arg0);
    1083           25 :   gcc_assert (code != CODE_FOR_nothing);
    1084           25 :   return code;
    1085              : }
    1086              : 
    1087              : extern rtx maybe_gen_lwp_lwpins (machine_mode, rtx, rtx, rtx);
    1088              : inline rtx
    1089              : gen_lwp_lwpins (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1090              : {
    1091              :   rtx res = maybe_gen_lwp_lwpins (arg0, x0, x1, x2);
    1092              :   gcc_assert (res);
    1093              :   return res;
    1094              : }
    1095              : 
    1096              : extern insn_code maybe_code_for_rdrand (machine_mode);
    1097              : inline insn_code
    1098              : code_for_rdrand (machine_mode arg0)
    1099              : {
    1100              :   insn_code code = maybe_code_for_rdrand (arg0);
    1101              :   gcc_assert (code != CODE_FOR_nothing);
    1102              :   return code;
    1103              : }
    1104              : 
    1105              : extern rtx maybe_gen_rdrand (machine_mode, rtx);
    1106              : inline rtx
    1107           84 : gen_rdrand (machine_mode arg0, rtx x0)
    1108              : {
    1109           84 :   rtx res = maybe_gen_rdrand (arg0, x0);
    1110           84 :   gcc_assert (res);
    1111           84 :   return res;
    1112              : }
    1113              : 
    1114              : extern insn_code maybe_code_for_rdseed (machine_mode);
    1115              : inline insn_code
    1116              : code_for_rdseed (machine_mode arg0)
    1117              : {
    1118              :   insn_code code = maybe_code_for_rdseed (arg0);
    1119              :   gcc_assert (code != CODE_FOR_nothing);
    1120              :   return code;
    1121              : }
    1122              : 
    1123              : extern rtx maybe_gen_rdseed (machine_mode, rtx);
    1124              : inline rtx
    1125           67 : gen_rdseed (machine_mode arg0, rtx x0)
    1126              : {
    1127           67 :   rtx res = maybe_gen_rdseed (arg0, x0);
    1128           67 :   gcc_assert (res);
    1129           67 :   return res;
    1130              : }
    1131              : 
    1132              : extern insn_code maybe_code_for_rdssp (machine_mode);
    1133              : inline insn_code
    1134              : code_for_rdssp (machine_mode arg0)
    1135              : {
    1136              :   insn_code code = maybe_code_for_rdssp (arg0);
    1137              :   gcc_assert (code != CODE_FOR_nothing);
    1138              :   return code;
    1139              : }
    1140              : 
    1141              : extern rtx maybe_gen_rdssp (machine_mode, rtx, rtx);
    1142              : inline rtx
    1143           81 : gen_rdssp (machine_mode arg0, rtx x0, rtx x1)
    1144              : {
    1145           81 :   rtx res = maybe_gen_rdssp (arg0, x0, x1);
    1146           81 :   gcc_assert (res);
    1147           81 :   return res;
    1148              : }
    1149              : 
    1150              : extern insn_code maybe_code_for_incssp (machine_mode);
    1151              : inline insn_code
    1152              : code_for_incssp (machine_mode arg0)
    1153              : {
    1154              :   insn_code code = maybe_code_for_incssp (arg0);
    1155              :   gcc_assert (code != CODE_FOR_nothing);
    1156              :   return code;
    1157              : }
    1158              : 
    1159              : extern rtx maybe_gen_incssp (machine_mode, rtx);
    1160              : inline rtx
    1161           81 : gen_incssp (machine_mode arg0, rtx x0)
    1162              : {
    1163           81 :   rtx res = maybe_gen_incssp (arg0, x0);
    1164           81 :   gcc_assert (res);
    1165           81 :   return res;
    1166              : }
    1167              : 
    1168              : extern insn_code maybe_code_for_wrss (machine_mode);
    1169              : inline insn_code
    1170           41 : code_for_wrss (machine_mode arg0)
    1171              : {
    1172           41 :   insn_code code = maybe_code_for_wrss (arg0);
    1173           41 :   gcc_assert (code != CODE_FOR_nothing);
    1174           41 :   return code;
    1175              : }
    1176              : 
    1177              : extern rtx maybe_gen_wrss (machine_mode, rtx, rtx);
    1178              : inline rtx
    1179              : gen_wrss (machine_mode arg0, rtx x0, rtx x1)
    1180              : {
    1181              :   rtx res = maybe_gen_wrss (arg0, x0, x1);
    1182              :   gcc_assert (res);
    1183              :   return res;
    1184              : }
    1185              : 
    1186              : extern insn_code maybe_code_for_wruss (machine_mode);
    1187              : inline insn_code
    1188           40 : code_for_wruss (machine_mode arg0)
    1189              : {
    1190           40 :   insn_code code = maybe_code_for_wruss (arg0);
    1191           40 :   gcc_assert (code != CODE_FOR_nothing);
    1192           40 :   return code;
    1193              : }
    1194              : 
    1195              : extern rtx maybe_gen_wruss (machine_mode, rtx, rtx);
    1196              : inline rtx
    1197              : gen_wruss (machine_mode arg0, rtx x0, rtx x1)
    1198              : {
    1199              :   rtx res = maybe_gen_wruss (arg0, x0, x1);
    1200              :   gcc_assert (res);
    1201              :   return res;
    1202              : }
    1203              : 
    1204              : extern insn_code maybe_code_for_monitorx (machine_mode);
    1205              : inline insn_code
    1206              : code_for_monitorx (machine_mode arg0)
    1207              : {
    1208              :   insn_code code = maybe_code_for_monitorx (arg0);
    1209              :   gcc_assert (code != CODE_FOR_nothing);
    1210              :   return code;
    1211              : }
    1212              : 
    1213              : extern rtx maybe_gen_monitorx (machine_mode, rtx, rtx, rtx);
    1214              : inline rtx
    1215           21 : gen_monitorx (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1216              : {
    1217           21 :   rtx res = maybe_gen_monitorx (arg0, x0, x1, x2);
    1218           21 :   gcc_assert (res);
    1219           21 :   return res;
    1220              : }
    1221              : 
    1222              : extern insn_code maybe_code_for_clzero (machine_mode);
    1223              : inline insn_code
    1224              : code_for_clzero (machine_mode arg0)
    1225              : {
    1226              :   insn_code code = maybe_code_for_clzero (arg0);
    1227              :   gcc_assert (code != CODE_FOR_nothing);
    1228              :   return code;
    1229              : }
    1230              : 
    1231              : extern rtx maybe_gen_clzero (machine_mode, rtx);
    1232              : inline rtx
    1233           19 : gen_clzero (machine_mode arg0, rtx x0)
    1234              : {
    1235           19 :   rtx res = maybe_gen_clzero (arg0, x0);
    1236           19 :   gcc_assert (res);
    1237           19 :   return res;
    1238              : }
    1239              : 
    1240              : extern insn_code maybe_code_for_movdir64b (machine_mode);
    1241              : inline insn_code
    1242              : code_for_movdir64b (machine_mode arg0)
    1243              : {
    1244              :   insn_code code = maybe_code_for_movdir64b (arg0);
    1245              :   gcc_assert (code != CODE_FOR_nothing);
    1246              :   return code;
    1247              : }
    1248              : 
    1249              : extern rtx maybe_gen_movdir64b (machine_mode, rtx, rtx);
    1250              : inline rtx
    1251           24 : gen_movdir64b (machine_mode arg0, rtx x0, rtx x1)
    1252              : {
    1253           24 :   rtx res = maybe_gen_movdir64b (arg0, x0, x1);
    1254           24 :   gcc_assert (res);
    1255           24 :   return res;
    1256              : }
    1257              : 
    1258              : extern insn_code maybe_code_for_enqcmd (int, machine_mode);
    1259              : inline insn_code
    1260           38 : code_for_enqcmd (int arg0, machine_mode arg1)
    1261              : {
    1262           38 :   insn_code code = maybe_code_for_enqcmd (arg0, arg1);
    1263           38 :   gcc_assert (code != CODE_FOR_nothing);
    1264           38 :   return code;
    1265              : }
    1266              : 
    1267              : extern rtx maybe_gen_enqcmd (int, machine_mode, rtx, rtx);
    1268              : inline rtx
    1269              : gen_enqcmd (int arg0, machine_mode arg1, rtx x0, rtx x1)
    1270              : {
    1271              :   rtx res = maybe_gen_enqcmd (arg0, arg1, x0, x1);
    1272              :   gcc_assert (res);
    1273              :   return res;
    1274              : }
    1275              : 
    1276              : extern insn_code maybe_code_for_umonitor (machine_mode);
    1277              : inline insn_code
    1278              : code_for_umonitor (machine_mode arg0)
    1279              : {
    1280              :   insn_code code = maybe_code_for_umonitor (arg0);
    1281              :   gcc_assert (code != CODE_FOR_nothing);
    1282              :   return code;
    1283              : }
    1284              : 
    1285              : extern rtx maybe_gen_umonitor (machine_mode, rtx);
    1286              : inline rtx
    1287           21 : gen_umonitor (machine_mode arg0, rtx x0)
    1288              : {
    1289           21 :   rtx res = maybe_gen_umonitor (arg0, x0);
    1290           21 :   gcc_assert (res);
    1291           21 :   return res;
    1292              : }
    1293              : 
    1294              : extern insn_code maybe_code_for_sse4_1_insertps (machine_mode);
    1295              : inline insn_code
    1296              : code_for_sse4_1_insertps (machine_mode arg0)
    1297              : {
    1298              :   insn_code code = maybe_code_for_sse4_1_insertps (arg0);
    1299              :   gcc_assert (code != CODE_FOR_nothing);
    1300              :   return code;
    1301              : }
    1302              : 
    1303              : extern rtx maybe_gen_sse4_1_insertps (machine_mode, rtx, rtx, rtx, rtx);
    1304              : inline rtx
    1305          570 : gen_sse4_1_insertps (machine_mode arg0, rtx x0, rtx x1, rtx x2, rtx x3)
    1306              : {
    1307          570 :   rtx res = maybe_gen_sse4_1_insertps (arg0, x0, x1, x2, x3);
    1308          570 :   gcc_assert (res);
    1309          570 :   return res;
    1310              : }
    1311              : 
    1312              : extern insn_code maybe_code_for_vec_set_0 (machine_mode);
    1313              : inline insn_code
    1314              : code_for_vec_set_0 (machine_mode arg0)
    1315              : {
    1316              :   insn_code code = maybe_code_for_vec_set_0 (arg0);
    1317              :   gcc_assert (code != CODE_FOR_nothing);
    1318              :   return code;
    1319              : }
    1320              : 
    1321              : extern rtx maybe_gen_vec_set_0 (machine_mode, rtx, rtx, rtx);
    1322              : inline rtx
    1323            3 : gen_vec_set_0 (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1324              : {
    1325            3 :   rtx res = maybe_gen_vec_set_0 (arg0, x0, x1, x2);
    1326            3 :   gcc_assert (res);
    1327            3 :   return res;
    1328              : }
    1329              : 
    1330              : extern insn_code maybe_code_for_vec_extract_lo (machine_mode);
    1331              : inline insn_code
    1332              : code_for_vec_extract_lo (machine_mode arg0)
    1333              : {
    1334              :   insn_code code = maybe_code_for_vec_extract_lo (arg0);
    1335              :   gcc_assert (code != CODE_FOR_nothing);
    1336              :   return code;
    1337              : }
    1338              : 
    1339              : extern rtx maybe_gen_vec_extract_lo (machine_mode, rtx, rtx);
    1340              : inline rtx
    1341          264 : gen_vec_extract_lo (machine_mode arg0, rtx x0, rtx x1)
    1342              : {
    1343          264 :   rtx res = maybe_gen_vec_extract_lo (arg0, x0, x1);
    1344          264 :   gcc_assert (res);
    1345          264 :   return res;
    1346              : }
    1347              : 
    1348              : extern insn_code maybe_code_for_vec_extract_hi (machine_mode);
    1349              : inline insn_code
    1350              : code_for_vec_extract_hi (machine_mode arg0)
    1351              : {
    1352              :   insn_code code = maybe_code_for_vec_extract_hi (arg0);
    1353              :   gcc_assert (code != CODE_FOR_nothing);
    1354              :   return code;
    1355              : }
    1356              : 
    1357              : extern rtx maybe_gen_vec_extract_hi (machine_mode, rtx, rtx);
    1358              : inline rtx
    1359          223 : gen_vec_extract_hi (machine_mode arg0, rtx x0, rtx x1)
    1360              : {
    1361          223 :   rtx res = maybe_gen_vec_extract_hi (arg0, x0, x1);
    1362          223 :   gcc_assert (res);
    1363          223 :   return res;
    1364              : }
    1365              : 
    1366              : extern insn_code maybe_code_for_vec_interleave_high (machine_mode);
    1367              : inline insn_code
    1368              : code_for_vec_interleave_high (machine_mode arg0)
    1369              : {
    1370              :   insn_code code = maybe_code_for_vec_interleave_high (arg0);
    1371              :   gcc_assert (code != CODE_FOR_nothing);
    1372              :   return code;
    1373              : }
    1374              : 
    1375              : extern rtx maybe_gen_vec_interleave_high (machine_mode, rtx, rtx, rtx);
    1376              : inline rtx
    1377            0 : gen_vec_interleave_high (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1378              : {
    1379            0 :   rtx res = maybe_gen_vec_interleave_high (arg0, x0, x1, x2);
    1380            0 :   gcc_assert (res);
    1381            0 :   return res;
    1382              : }
    1383              : 
    1384              : extern insn_code maybe_code_for_vec_interleave_low (machine_mode);
    1385              : inline insn_code
    1386              : code_for_vec_interleave_low (machine_mode arg0)
    1387              : {
    1388              :   insn_code code = maybe_code_for_vec_interleave_low (arg0);
    1389              :   gcc_assert (code != CODE_FOR_nothing);
    1390              :   return code;
    1391              : }
    1392              : 
    1393              : extern rtx maybe_gen_vec_interleave_low (machine_mode, rtx, rtx, rtx);
    1394              : inline rtx
    1395            1 : gen_vec_interleave_low (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1396              : {
    1397            1 :   rtx res = maybe_gen_vec_interleave_low (arg0, x0, x1, x2);
    1398            1 :   gcc_assert (res);
    1399            1 :   return res;
    1400              : }
    1401              : 
    1402              : extern insn_code maybe_code_for_sse3_monitor (machine_mode);
    1403              : inline insn_code
    1404              : code_for_sse3_monitor (machine_mode arg0)
    1405              : {
    1406              :   insn_code code = maybe_code_for_sse3_monitor (arg0);
    1407              :   gcc_assert (code != CODE_FOR_nothing);
    1408              :   return code;
    1409              : }
    1410              : 
    1411              : extern rtx maybe_gen_sse3_monitor (machine_mode, rtx, rtx, rtx);
    1412              : inline rtx
    1413           26 : gen_sse3_monitor (machine_mode arg0, rtx x0, rtx x1, rtx x2)
    1414              : {
    1415           26 :   rtx res = maybe_gen_sse3_monitor (arg0, x0, x1, x2);
    1416           26 :   gcc_assert (res);
    1417           26 :   return res;
    1418              : }
    1419              : #endif
    1420              : 
    1421              : extern const struct convert_optab_libcall_d convlib_def[NUM_CONVLIB_OPTABS];
    1422              : extern const struct optab_libcall_d normlib_def[NUM_NORMLIB_OPTABS];
    1423              : 
    1424              : /* Returns the active icode for the given (encoded) optab.  */
    1425              : extern enum insn_code raw_optab_handler (unsigned);
    1426              : extern bool swap_optab_enable (optab, machine_mode, bool);
    1427              : 
    1428              : /* Target-dependent globals.  */
    1429              : struct target_optabs {
    1430              :   /* Patterns that are used by optabs that are enabled for this target.  */
    1431              :   bool pat_enable[NUM_OPTAB_PATTERNS];
    1432              : 
    1433              :   /* Index VOIDmode caches if the target supports vec_gather_load for any
    1434              :      vector mode.  Every other index X caches specifically for mode X.
    1435              :      1 means yes, -1 means no.  */
    1436              :   signed char supports_vec_gather_load[NUM_MACHINE_MODES];
    1437              :   signed char supports_vec_scatter_store[NUM_MACHINE_MODES];
    1438              : };
    1439              : extern void init_all_optabs (struct target_optabs *);
    1440              : extern bool partial_vectors_supported_p (void);
    1441              : 
    1442              : extern struct target_optabs default_target_optabs;
    1443              : extern struct target_optabs *this_fn_optabs;
    1444              : #if SWITCHABLE_TARGET
    1445              : extern struct target_optabs *this_target_optabs;
    1446              : #else
    1447              : #define this_target_optabs (&default_target_optabs)
    1448              : #endif
    1449              : #endif
        

Generated by: LCOV version 2.5.0-beta

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