gcc/genopinit.c

   1 /* Generate code to initialize optabs from machine description.
   2    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 #include "bconfig.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "errors.h"
  29 #include "gensupport.h"
  30
  31
  32 /* Many parts of GCC use arrays that are indexed by machine mode and
  33    contain the insn codes for pattern in the MD file that perform a given
  34    operation on operands of that mode.
  35
  36    These patterns are present in the MD file with names that contain
  37    the mode(s) used and the name of the operation.  This program
  38    writes a function `init_all_optabs' that initializes the optabs with
  39    all the insn codes of the relevant patterns present in the MD file.
  40
  41    This array contains a list of optabs that need to be initialized.  Within
  42    each string, the name of the pattern to be matched against is delimited
  43    with $( and $).  In the string, $a and $b are used to match a short mode
  44    name (the part of the mode name not including `mode' and converted to
  45    lower-case).  When writing out the initializer, the entire string is
  46    used.  $A and $B are replaced with the full name of the mode; $a and $b
  47    are replaced with the short form of the name, as above.
  48
  49    If $N is present in the pattern, it means the two modes must be in
  50    the same mode class, and $b must be greater than $a (e.g, QImode
  51    and HImode).
  52
  53    $I means that only full integer modes should be considered for the
  54    next mode, and $F means that only float modes should be considered.
  55    $P means that both full and partial integer modes should be considered.
  56    $Q means that only fixed-point modes should be considered.
  57
  58    $V means to emit 'v' if the first mode is a MODE_FLOAT mode.
  59
  60    For some optabs, we store the operation by RTL codes.  These are only
  61    used for comparisons.  In that case, $c and $C are the lower-case and
  62    upper-case forms of the comparison, respectively.  */
  63
  64 static const char * const optabs[] =
  65 { "set_convert_optab_handler (sext_optab, $B, $A, CODE_FOR_$(extend$a$b2$))",
  66   "set_convert_optab_handler (zext_optab, $B, $A, CODE_FOR_$(zero_extend$a$b2$))",
  67   "set_convert_optab_handler (sfix_optab, $B, $A, CODE_FOR_$(fix$F$a$I$b2$))",
  68   "set_convert_optab_handler (ufix_optab, $B, $A, CODE_FOR_$(fixuns$F$a$b2$))",
  69   "set_convert_optab_handler (sfixtrunc_optab, $B, $A, CODE_FOR_$(fix_trunc$F$a$I$b2$))",
  70   "set_convert_optab_handler (ufixtrunc_optab, $B, $A, CODE_FOR_$(fixuns_trunc$F$a$I$b2$))",
  71   "set_convert_optab_handler (sfloat_optab, $B, $A, CODE_FOR_$(float$I$a$F$b2$))",
  72   "set_convert_optab_handler (ufloat_optab, $B, $A, CODE_FOR_$(floatuns$I$a$F$b2$))",
  73   "set_convert_optab_handler (trunc_optab, $B, $A, CODE_FOR_$(trunc$a$b2$))",
  74   "set_convert_optab_handler (fract_optab, $B, $A, CODE_FOR_$(fract$a$b2$))",
  75   "set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$I$a$Q$b2$))",
  76   "set_convert_optab_handler (fractuns_optab, $B, $A, CODE_FOR_$(fractuns$Q$a$I$b2$))",
  77   "set_convert_optab_handler (satfract_optab, $B, $A, CODE_FOR_$(satfract$a$Q$b2$))",
  78   "set_convert_optab_handler (satfractuns_optab, $B, $A, CODE_FOR_$(satfractuns$I$a$Q$b2$))",
  79   "set_convert_optab_handler (vec_load_lanes_optab, $A, $B, CODE_FOR_$(vec_load_lanes$a$b$))",
  80   "set_convert_optab_handler (vec_store_lanes_optab, $A, $B, CODE_FOR_$(vec_store_lanes$a$b$))",
  81   "set_optab_handler (add_optab, $A, CODE_FOR_$(add$P$a3$))",
  82   "set_optab_handler (addv_optab, $A, CODE_FOR_$(add$F$a3$)),\n\
  83     set_optab_handler (add_optab, $A, CODE_FOR_$(add$F$a3$))",
  84   "set_optab_handler (addv_optab, $A, CODE_FOR_$(addv$I$a3$))",
  85   "set_optab_handler (add_optab, $A, CODE_FOR_$(add$Q$a3$))",
  86   "set_optab_handler (ssadd_optab, $A, CODE_FOR_$(ssadd$Q$a3$))",
  87   "set_optab_handler (usadd_optab, $A, CODE_FOR_$(usadd$Q$a3$))",
  88   "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$P$a3$))",
  89   "set_optab_handler (subv_optab, $A, CODE_FOR_$(sub$F$a3$)),\n\
  90     set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$F$a3$))",
  91   "set_optab_handler (subv_optab, $A, CODE_FOR_$(subv$I$a3$))",
  92   "set_optab_handler (sub_optab, $A, CODE_FOR_$(sub$Q$a3$))",
  93   "set_optab_handler (sssub_optab, $A, CODE_FOR_$(sssub$Q$a3$))",
  94   "set_optab_handler (ussub_optab, $A, CODE_FOR_$(ussub$Q$a3$))",
  95   "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$Q$a3$))",
  96   "set_optab_handler (ssmul_optab, $A, CODE_FOR_$(ssmul$Q$a3$))",
  97   "set_optab_handler (usmul_optab, $A, CODE_FOR_$(usmul$Q$a3$))",
  98   "set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$P$a3$))",
  99   "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mul$F$a3$)),\n\
 100     set_optab_handler (smul_optab, $A, CODE_FOR_$(mul$F$a3$))",
 101   "set_optab_handler (smulv_optab, $A, CODE_FOR_$(mulv$I$a3$))",
 102   "set_optab_handler (umul_highpart_optab, $A, CODE_FOR_$(umul$a3_highpart$))",
 103   "set_optab_handler (smul_highpart_optab, $A, CODE_FOR_$(smul$a3_highpart$))",
 104   "set_widening_optab_handler (smul_widen_optab, $B, $A, CODE_FOR_$(mul$a$b3$)$N)",
 105   "set_widening_optab_handler (umul_widen_optab, $B, $A, CODE_FOR_$(umul$a$b3$)$N)",
 106   "set_widening_optab_handler (usmul_widen_optab, $B, $A, CODE_FOR_$(usmul$a$b3$)$N)",
 107   "set_widening_optab_handler (smadd_widen_optab, $B, $A, CODE_FOR_$(madd$a$b4$)$N)",
 108   "set_widening_optab_handler (umadd_widen_optab, $B, $A, CODE_FOR_$(umadd$a$b4$)$N)",
 109   "set_widening_optab_handler (ssmadd_widen_optab, $B, $A, CODE_FOR_$(ssmadd$a$b4$)$N)",
 110   "set_widening_optab_handler (usmadd_widen_optab, $B, $A, CODE_FOR_$(usmadd$a$b4$)$N)",
 111   "set_widening_optab_handler (smsub_widen_optab, $B, $A, CODE_FOR_$(msub$a$b4$)$N)",
 112   "set_widening_optab_handler (umsub_widen_optab, $B, $A, CODE_FOR_$(umsub$a$b4$)$N)",
 113   "set_widening_optab_handler (ssmsub_widen_optab, $B, $A, CODE_FOR_$(ssmsub$a$b4$)$N)",
 114   "set_widening_optab_handler (usmsub_widen_optab, $B, $A, CODE_FOR_$(usmsub$a$b4$)$N)",
 115   "set_optab_handler (sdiv_optab, $A, CODE_FOR_$(div$a3$))",
 116   "set_optab_handler (ssdiv_optab, $A, CODE_FOR_$(ssdiv$Q$a3$))",
 117   "set_optab_handler (sdivv_optab, $A, CODE_FOR_$(div$V$I$a3$))",
 118   "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$I$a3$))",
 119   "set_optab_handler (udiv_optab, $A, CODE_FOR_$(udiv$Q$a3$))",
 120   "set_optab_handler (usdiv_optab, $A, CODE_FOR_$(usdiv$Q$a3$))",
 121   "set_optab_handler (sdivmod_optab, $A, CODE_FOR_$(divmod$a4$))",
 122   "set_optab_handler (udivmod_optab, $A, CODE_FOR_$(udivmod$a4$))",
 123   "set_optab_handler (smod_optab, $A, CODE_FOR_$(mod$a3$))",
 124   "set_optab_handler (umod_optab, $A, CODE_FOR_$(umod$a3$))",
 125   "set_optab_handler (fmod_optab, $A, CODE_FOR_$(fmod$a3$))",
 126   "set_optab_handler (remainder_optab, $A, CODE_FOR_$(remainder$a3$))",
 127   "set_optab_handler (ftrunc_optab, $A, CODE_FOR_$(ftrunc$F$a2$))",
 128   "set_optab_handler (and_optab, $A, CODE_FOR_$(and$a3$))",
 129   "set_optab_handler (ior_optab, $A, CODE_FOR_$(ior$a3$))",
 130   "set_optab_handler (xor_optab, $A, CODE_FOR_$(xor$a3$))",
 131   "set_optab_handler (ashl_optab, $A, CODE_FOR_$(ashl$a3$))",
 132   "set_optab_handler (ssashl_optab, $A, CODE_FOR_$(ssashl$Q$a3$))",
 133   "set_optab_handler (usashl_optab, $A, CODE_FOR_$(usashl$Q$a3$))",
 134   "set_optab_handler (ashr_optab, $A, CODE_FOR_$(ashr$a3$))",
 135   "set_optab_handler (lshr_optab, $A, CODE_FOR_$(lshr$a3$))",
 136   "set_optab_handler (rotl_optab, $A, CODE_FOR_$(rotl$a3$))",
 137   "set_optab_handler (rotr_optab, $A, CODE_FOR_$(rotr$a3$))",
 138   "set_optab_handler (vashr_optab, $A, CODE_FOR_$(vashr$a3$))",
 139   "set_optab_handler (vlshr_optab, $A, CODE_FOR_$(vlshr$a3$))",
 140   "set_optab_handler (vashl_optab, $A, CODE_FOR_$(vashl$a3$))",
 141   "set_optab_handler (vrotl_optab, $A, CODE_FOR_$(vrotl$a3$))",
 142   "set_optab_handler (vrotr_optab, $A, CODE_FOR_$(vrotr$a3$))",
 143   "set_optab_handler (smin_optab, $A, CODE_FOR_$(smin$a3$))",
 144   "set_optab_handler (smax_optab, $A, CODE_FOR_$(smax$a3$))",
 145   "set_optab_handler (umin_optab, $A, CODE_FOR_$(umin$I$a3$))",
 146   "set_optab_handler (umax_optab, $A, CODE_FOR_$(umax$I$a3$))",
 147   "set_optab_handler (pow_optab, $A, CODE_FOR_$(pow$a3$))",
 148   "set_optab_handler (atan2_optab, $A, CODE_FOR_$(atan2$a3$))",
 149   "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$P$a2$))",
 150   "set_optab_handler (negv_optab, $A, CODE_FOR_$(neg$F$a2$)),\n\
 151     set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$F$a2$))",
 152   "set_optab_handler (negv_optab, $A, CODE_FOR_$(negv$I$a2$))",
 153   "set_optab_handler (neg_optab, $A, CODE_FOR_$(neg$Q$a2$))",
 154   "set_optab_handler (ssneg_optab, $A, CODE_FOR_$(ssneg$Q$a2$))",
 155   "set_optab_handler (usneg_optab, $A, CODE_FOR_$(usneg$Q$a2$))",
 156   "set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$P$a2$))",
 157   "set_optab_handler (absv_optab, $A, CODE_FOR_$(abs$F$a2$)),\n\
 158     set_optab_handler (abs_optab, $A, CODE_FOR_$(abs$F$a2$))",
 159   "set_optab_handler (absv_optab, $A, CODE_FOR_$(absv$I$a2$))",
 160   "set_optab_handler (copysign_optab, $A, CODE_FOR_$(copysign$F$a3$))",
 161   "set_optab_handler (signbit_optab, $A, CODE_FOR_$(signbit$F$a2$))",
 162   "set_optab_handler (isinf_optab, $A, CODE_FOR_$(isinf$a2$))",
 163   "set_optab_handler (sqrt_optab, $A, CODE_FOR_$(sqrt$a2$))",
 164   "set_optab_handler (floor_optab, $A, CODE_FOR_$(floor$a2$))",
 165   "set_convert_optab_handler (lfloor_optab, $B, $A, CODE_FOR_$(lfloor$F$a$I$b2$))",
 166   "set_optab_handler (fma_optab, $A, CODE_FOR_$(fma$a4$))",
 167   "set_optab_handler (fms_optab, $A, CODE_FOR_$(fms$a4$))",
 168   "set_optab_handler (fnma_optab, $A, CODE_FOR_$(fnma$a4$))",
 169   "set_optab_handler (fnms_optab, $A, CODE_FOR_$(fnms$a4$))",
 170   "set_optab_handler (ceil_optab, $A, CODE_FOR_$(ceil$a2$))",
 171   "set_convert_optab_handler (lceil_optab, $B, $A, CODE_FOR_$(lceil$F$a$I$b2$))",
 172   "set_optab_handler (round_optab, $A, CODE_FOR_$(round$a2$))",
 173   "set_optab_handler (btrunc_optab, $A, CODE_FOR_$(btrunc$a2$))",
 174   "set_optab_handler (nearbyint_optab, $A, CODE_FOR_$(nearbyint$a2$))",
 175   "set_optab_handler (rint_optab, $A, CODE_FOR_$(rint$a2$))",
 176   "set_convert_optab_handler (lrint_optab, $B, $A, CODE_FOR_$(lrint$F$a$I$b2$))",
 177   "set_convert_optab_handler (lround_optab, $B, $A, CODE_FOR_$(lround$F$a$I$b2$))",
 178   "set_optab_handler (sincos_optab, $A, CODE_FOR_$(sincos$a3$))",
 179   "set_optab_handler (sin_optab, $A, CODE_FOR_$(sin$a2$))",
 180   "set_optab_handler (asin_optab, $A, CODE_FOR_$(asin$a2$))",
 181   "set_optab_handler (cos_optab, $A, CODE_FOR_$(cos$a2$))",
 182   "set_optab_handler (acos_optab, $A, CODE_FOR_$(acos$a2$))",
 183   "set_optab_handler (exp_optab, $A, CODE_FOR_$(exp$a2$))",
 184   "set_optab_handler (exp10_optab, $A, CODE_FOR_$(exp10$a2$))",
 185   "set_optab_handler (exp2_optab, $A, CODE_FOR_$(exp2$a2$))",
 186   "set_optab_handler (expm1_optab, $A, CODE_FOR_$(expm1$a2$))",
 187   "set_optab_handler (ldexp_optab, $A, CODE_FOR_$(ldexp$a3$))",
 188   "set_optab_handler (scalb_optab, $A, CODE_FOR_$(scalb$a3$))",
 189   "set_optab_handler (significand_optab, $A, CODE_FOR_$(significand$a2$))",
 190   "set_optab_handler (logb_optab, $A, CODE_FOR_$(logb$a2$))",
 191   "set_optab_handler (ilogb_optab, $A, CODE_FOR_$(ilogb$a2$))",
 192   "set_optab_handler (log_optab, $A, CODE_FOR_$(log$a2$))",
 193   "set_optab_handler (log10_optab, $A, CODE_FOR_$(log10$a2$))",
 194   "set_optab_handler (log2_optab, $A, CODE_FOR_$(log2$a2$))",
 195   "set_optab_handler (log1p_optab, $A, CODE_FOR_$(log1p$a2$))",
 196   "set_optab_handler (tan_optab, $A, CODE_FOR_$(tan$a2$))",
 197   "set_optab_handler (atan_optab, $A, CODE_FOR_$(atan$a2$))",
 198   "set_optab_handler (strlen_optab, $A, CODE_FOR_$(strlen$a$))",
 199   "set_optab_handler (one_cmpl_optab, $A, CODE_FOR_$(one_cmpl$a2$))",
 200   "set_optab_handler (bswap_optab, $A, CODE_FOR_$(bswap$a2$))",
 201   "set_optab_handler (ffs_optab, $A, CODE_FOR_$(ffs$a2$))",
 202   "set_optab_handler (clz_optab, $A, CODE_FOR_$(clz$a2$))",
 203   "set_optab_handler (ctz_optab, $A, CODE_FOR_$(ctz$a2$))",
 204   "set_optab_handler (clrsb_optab, $A, CODE_FOR_$(clrsb$a2$))",
 205   "set_optab_handler (popcount_optab, $A, CODE_FOR_$(popcount$a2$))",
 206   "set_optab_handler (parity_optab, $A, CODE_FOR_$(parity$a2$))",
 207   "set_optab_handler (mov_optab, $A, CODE_FOR_$(mov$a$))",
 208   "set_optab_handler (movstrict_optab, $A, CODE_FOR_$(movstrict$a$))",
 209   "set_optab_handler (movmisalign_optab, $A, CODE_FOR_$(movmisalign$a$))",
 210   "set_optab_handler (storent_optab, $A, CODE_FOR_$(storent$a$))",
 211   "set_optab_handler (addcc_optab, $A, CODE_FOR_$(add$acc$))",
 212   "set_direct_optab_handler (movcc_optab, $A, CODE_FOR_$(mov$acc$))",
 213   "set_optab_handler (cbranch_optab, $A, CODE_FOR_$(cbranch$a4$))",
 214   "set_optab_handler (cmov_optab, $A, CODE_FOR_$(cmov$a6$))",
 215   "set_optab_handler (cstore_optab, $A, CODE_FOR_$(cstore$a4$))",
 216   "set_optab_handler (ctrap_optab, $A, CODE_FOR_$(ctrap$a4$))",
 217   "set_optab_handler (push_optab, $A, CODE_FOR_$(push$a1$))",
 218   "set_direct_optab_handler (reload_in_optab, $A, CODE_FOR_$(reload_in$a$))",
 219   "set_direct_optab_handler (reload_out_optab, $A, CODE_FOR_$(reload_out$a$))",
 220   "set_direct_optab_handler (movmem_optab, $A, CODE_FOR_$(movmem$a$))",
 221   "set_direct_optab_handler (cmpstr_optab, $A, CODE_FOR_$(cmpstr$a$))",
 222   "set_direct_optab_handler (cmpstrn_optab, $A, CODE_FOR_$(cmpstrn$a$))",
 223   "set_direct_optab_handler (cmpmem_optab, $A, CODE_FOR_$(cmpmem$a$))",
 224   "set_direct_optab_handler (setmem_optab, $A, CODE_FOR_$(setmem$a$))",
 225   "set_direct_optab_handler (sync_add_optab, $A, CODE_FOR_$(sync_add$I$a$))",
 226   "set_direct_optab_handler (sync_sub_optab, $A, CODE_FOR_$(sync_sub$I$a$))",
 227   "set_direct_optab_handler (sync_ior_optab, $A, CODE_FOR_$(sync_ior$I$a$))",
 228   "set_direct_optab_handler (sync_and_optab, $A, CODE_FOR_$(sync_and$I$a$))",
 229   "set_direct_optab_handler (sync_xor_optab, $A, CODE_FOR_$(sync_xor$I$a$))",
 230   "set_direct_optab_handler (sync_nand_optab, $A, CODE_FOR_$(sync_nand$I$a$))",
 231   "set_optab_handler (sync_old_add_optab, $A, CODE_FOR_$(sync_old_add$I$a$))",
 232   "set_optab_handler (sync_old_sub_optab, $A, CODE_FOR_$(sync_old_sub$I$a$))",
 233   "set_optab_handler (sync_old_ior_optab, $A, CODE_FOR_$(sync_old_ior$I$a$))",
 234   "set_optab_handler (sync_old_and_optab, $A, CODE_FOR_$(sync_old_and$I$a$))",
 235   "set_optab_handler (sync_old_xor_optab, $A, CODE_FOR_$(sync_old_xor$I$a$))",
 236   "set_optab_handler (sync_old_nand_optab, $A, CODE_FOR_$(sync_old_nand$I$a$))",
 237   "set_optab_handler (sync_new_add_optab, $A, CODE_FOR_$(sync_new_add$I$a$))",
 238   "set_optab_handler (sync_new_sub_optab, $A, CODE_FOR_$(sync_new_sub$I$a$))",
 239   "set_optab_handler (sync_new_ior_optab, $A, CODE_FOR_$(sync_new_ior$I$a$))",
 240   "set_optab_handler (sync_new_and_optab, $A, CODE_FOR_$(sync_new_and$I$a$))",
 241   "set_optab_handler (sync_new_xor_optab, $A, CODE_FOR_$(sync_new_xor$I$a$))",
 242   "set_optab_handler (sync_new_nand_optab, $A, CODE_FOR_$(sync_new_nand$I$a$))",
 243   "set_optab_handler (sync_compare_and_swap_optab, $A, CODE_FOR_$(sync_compare_and_swap$I$a$))",
 244   "set_optab_handler (sync_lock_test_and_set_optab, $A, CODE_FOR_$(sync_lock_test_and_set$I$a$))",
 245   "set_direct_optab_handler (sync_lock_release_optab, $A, CODE_FOR_$(sync_lock_release$I$a$))",
 246   "set_direct_optab_handler (atomic_exchange_optab, $A, CODE_FOR_$(atomic_exchange$I$a$))",
 247   "set_direct_optab_handler (atomic_compare_and_swap_optab, $A, CODE_FOR_$(atomic_compare_and_swap$I$a$))",
 248   "set_direct_optab_handler (atomic_load_optab, $A, CODE_FOR_$(atomic_load$I$a$))",
 249   "set_direct_optab_handler (atomic_store_optab, $A, CODE_FOR_$(atomic_store$I$a$))",
 250   "set_direct_optab_handler (atomic_add_fetch_optab, $A, CODE_FOR_$(atomic_add_fetch$I$a$))",
 251   "set_direct_optab_handler (atomic_sub_fetch_optab, $A, CODE_FOR_$(atomic_sub_fetch$I$a$))",
 252   "set_direct_optab_handler (atomic_and_fetch_optab, $A, CODE_FOR_$(atomic_and_fetch$I$a$))",
 253   "set_direct_optab_handler (atomic_nand_fetch_optab, $A, CODE_FOR_$(atomic_nand_fetch$I$a$))",
 254   "set_direct_optab_handler (atomic_xor_fetch_optab, $A, CODE_FOR_$(atomic_xor_fetch$I$a$))",
 255   "set_direct_optab_handler (atomic_or_fetch_optab, $A, CODE_FOR_$(atomic_or_fetch$I$a$))",
 256   "set_direct_optab_handler (atomic_fetch_add_optab, $A, CODE_FOR_$(atomic_fetch_add$I$a$))",
 257   "set_direct_optab_handler (atomic_fetch_sub_optab, $A, CODE_FOR_$(atomic_fetch_sub$I$a$))",
 258   "set_direct_optab_handler (atomic_fetch_and_optab, $A, CODE_FOR_$(atomic_fetch_and$I$a$))",
 259   "set_direct_optab_handler (atomic_fetch_nand_optab, $A, CODE_FOR_$(atomic_fetch_nand$I$a$))",
 260   "set_direct_optab_handler (atomic_fetch_xor_optab, $A, CODE_FOR_$(atomic_fetch_xor$I$a$))",
 261   "set_direct_optab_handler (atomic_fetch_or_optab, $A, CODE_FOR_$(atomic_fetch_or$I$a$))",
 262   "set_direct_optab_handler (atomic_add_optab, $A, CODE_FOR_$(atomic_add$I$a$))",
 263   "set_direct_optab_handler (atomic_sub_optab, $A, CODE_FOR_$(atomic_sub$I$a$))",
 264   "set_direct_optab_handler (atomic_and_optab, $A, CODE_FOR_$(atomic_and$I$a$))",
 265   "set_direct_optab_handler (atomic_nand_optab, $A, CODE_FOR_$(atomic_nand$I$a$))",
 266   "set_direct_optab_handler (atomic_xor_optab, $A, CODE_FOR_$(atomic_xor$I$a$))",
 267   "set_direct_optab_handler (atomic_or_optab, $A, CODE_FOR_$(atomic_or$I$a$))",
 268   "set_optab_handler (vec_set_optab, $A, CODE_FOR_$(vec_set$a$))",
 269   "set_optab_handler (vec_extract_optab, $A, CODE_FOR_$(vec_extract$a$))",
 270   "set_optab_handler (vec_init_optab, $A, CODE_FOR_$(vec_init$a$))",
 271   "set_optab_handler (vec_shl_optab, $A, CODE_FOR_$(vec_shl_$a$))",
 272   "set_optab_handler (vec_shr_optab, $A, CODE_FOR_$(vec_shr_$a$))",
 273   "set_optab_handler (vec_realign_load_optab, $A, CODE_FOR_$(vec_realign_load_$a$))",
 274   "set_direct_optab_handler (vec_perm_optab, $A, CODE_FOR_$(vec_perm$a$))",
 275   "set_direct_optab_handler (vec_perm_const_optab, $A, CODE_FOR_$(vec_perm_const$a$))",
 276   "set_convert_optab_handler (vcond_optab, $A, $B, CODE_FOR_$(vcond$a$b$))",
 277   "set_convert_optab_handler (vcondu_optab, $A, $B, CODE_FOR_$(vcondu$a$b$))",
 278   "set_optab_handler (ssum_widen_optab, $A, CODE_FOR_$(widen_ssum$I$a3$))",
 279   "set_optab_handler (usum_widen_optab, $A, CODE_FOR_$(widen_usum$I$a3$))",
 280   "set_optab_handler (udot_prod_optab, $A, CODE_FOR_$(udot_prod$I$a$))",
 281   "set_optab_handler (sdot_prod_optab, $A, CODE_FOR_$(sdot_prod$I$a$))",
 282   "set_optab_handler (reduc_smax_optab, $A, CODE_FOR_$(reduc_smax_$a$))",
 283   "set_optab_handler (reduc_umax_optab, $A, CODE_FOR_$(reduc_umax_$a$))",
 284   "set_optab_handler (reduc_smin_optab, $A, CODE_FOR_$(reduc_smin_$a$))",
 285   "set_optab_handler (reduc_umin_optab, $A, CODE_FOR_$(reduc_umin_$a$))",
 286   "set_optab_handler (reduc_splus_optab, $A, CODE_FOR_$(reduc_splus_$a$))" ,
 287   "set_optab_handler (reduc_uplus_optab, $A, CODE_FOR_$(reduc_uplus_$a$))",
 288   "set_optab_handler (vec_widen_umult_hi_optab, $A, CODE_FOR_$(vec_widen_umult_hi_$a$))",
 289   "set_optab_handler (vec_widen_umult_lo_optab, $A, CODE_FOR_$(vec_widen_umult_lo_$a$))",
 290   "set_optab_handler (vec_widen_smult_hi_optab, $A, CODE_FOR_$(vec_widen_smult_hi_$a$))",
 291   "set_optab_handler (vec_widen_smult_lo_optab, $A, CODE_FOR_$(vec_widen_smult_lo_$a$))",
 292   "set_optab_handler (vec_widen_ushiftl_hi_optab, $A, CODE_FOR_$(vec_widen_ushiftl_hi_$a$))",
 293   "set_optab_handler (vec_widen_ushiftl_lo_optab, $A, CODE_FOR_$(vec_widen_ushiftl_lo_$a$))",
 294   "set_optab_handler (vec_widen_sshiftl_hi_optab, $A, CODE_FOR_$(vec_widen_sshiftl_hi_$a$))",
 295   "set_optab_handler (vec_widen_sshiftl_lo_optab, $A, CODE_FOR_$(vec_widen_sshiftl_lo_$a$))",
 296   "set_optab_handler (vec_unpacks_hi_optab, $A, CODE_FOR_$(vec_unpacks_hi_$a$))",
 297   "set_optab_handler (vec_unpacks_lo_optab, $A, CODE_FOR_$(vec_unpacks_lo_$a$))",
 298   "set_optab_handler (vec_unpacku_hi_optab, $A, CODE_FOR_$(vec_unpacku_hi_$a$))",
 299   "set_optab_handler (vec_unpacku_lo_optab, $A, CODE_FOR_$(vec_unpacku_lo_$a$))",
 300   "set_optab_handler (vec_unpacks_float_hi_optab, $A, CODE_FOR_$(vec_unpacks_float_hi_$a$))",
 301   "set_optab_handler (vec_unpacks_float_lo_optab, $A, CODE_FOR_$(vec_unpacks_float_lo_$a$))",
 302   "set_optab_handler (vec_unpacku_float_hi_optab, $A, CODE_FOR_$(vec_unpacku_float_hi_$a$))",
 303   "set_optab_handler (vec_unpacku_float_lo_optab, $A, CODE_FOR_$(vec_unpacku_float_lo_$a$))",
 304   "set_optab_handler (vec_pack_trunc_optab, $A, CODE_FOR_$(vec_pack_trunc_$a$))",
 305   "set_optab_handler (vec_pack_ssat_optab, $A, CODE_FOR_$(vec_pack_ssat_$a$))",
 306   "set_optab_handler (vec_pack_usat_optab, $A, CODE_FOR_$(vec_pack_usat_$a$))",
 307   "set_optab_handler (vec_pack_sfix_trunc_optab, $A, CODE_FOR_$(vec_pack_sfix_trunc_$a$))",
 308   "set_optab_handler (vec_pack_ufix_trunc_optab, $A, CODE_FOR_$(vec_pack_ufix_trunc_$a$))"
 309 };
 310
 311 static void gen_insn (rtx);
 312
 313 static void
 314 gen_insn (rtx insn)
 315 {
 316   const char *name = XSTR (insn, 0);
 317   int m1 = 0, m2 = 0, op = 0;
 318   size_t pindex;
 319   int i;
 320   const char *np, *pp, *p, *q;
 321
 322   /* Don't mention instructions whose names are the null string.
 323      They are in the machine description just to be recognized.  */
 324   if (*name == 0)
 325     return;
 326
 327   /* See if NAME matches one of the patterns we have for the optabs we know
 328      about.  */
 329
 330   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 331     {
 332       int force_float = 0, force_int = 0, force_partial_int = 0;
 333       int force_fixed = 0;
 334       int force_wider = 0;
 335       int matches = 1;
 336
 337       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 338         ;
 339
 340       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 341            pp++)
 342         {
 343           if (*pp != '$')
 344             {
 345               if (*pp != *np++)
 346                 break;
 347             }
 348           else
 349             switch (*++pp)
 350               {
 351               case 'N':
 352                 force_wider = 1;
 353                 break;
 354               case 'I':
 355                 force_int = 1;
 356                 break;
 357               case 'P':
 358                 force_partial_int = 1;
 359                 break;
 360               case 'F':
 361                 force_float = 1;
 362                 break;
 363               case 'Q':
 364                 force_fixed = 1;
 365                 break;
 366               case 'V':
 367                 break;
 368               case 'c':
 369                 for (op = 0; op < NUM_RTX_CODE; op++)
 370                   {
 371                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 372                       if (*p != *q)
 373                         break;
 374
 375                     /* We have to be concerned about matching "gt" and
 376                        missing "gtu", e.g., so verify we have reached the
 377                        end of thing we are to match.  */
 378                     if (*p == 0 && *q == 0
 379                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 380                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 381                       break;
 382                   }
 383
 384                 if (op == NUM_RTX_CODE)
 385                   matches = 0;
 386                 else
 387                   np += strlen (GET_RTX_NAME(op));
 388                 break;
 389               case 'a':
 390               case 'b':
 391                 /* This loop will stop at the first prefix match, so
 392                    look through the modes in reverse order, in case
 393                    there are extra CC modes and CC is a prefix of the
 394                    CC modes (as it should be).  */
 395                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 396                   {
 397                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 398                       if (TOLOWER (*p) != *q)
 399                         break;
 400
 401                     if (*p == 0
 402                         && (! force_int || mode_class[i] == MODE_INT
 403                             || mode_class[i] == MODE_VECTOR_INT)
 404                         && (! force_partial_int
 405                             || mode_class[i] == MODE_INT
 406                             || mode_class[i] == MODE_PARTIAL_INT
 407                             || mode_class[i] == MODE_VECTOR_INT)
 408                         && (! force_float
 409                             || mode_class[i] == MODE_FLOAT
 410                             || mode_class[i] == MODE_DECIMAL_FLOAT
 411                             || mode_class[i] == MODE_COMPLEX_FLOAT
 412                             || mode_class[i] == MODE_VECTOR_FLOAT)
 413                         && (! force_fixed
 414                             || mode_class[i] == MODE_FRACT
 415                             || mode_class[i] == MODE_UFRACT
 416                             || mode_class[i] == MODE_ACCUM
 417                             || mode_class[i] == MODE_UACCUM
 418                             || mode_class[i] == MODE_VECTOR_FRACT
 419                             || mode_class[i] == MODE_VECTOR_UFRACT
 420                             || mode_class[i] == MODE_VECTOR_ACCUM
 421                             || mode_class[i] == MODE_VECTOR_UACCUM)
 422                         && (! force_wider
 423                             || *pp == 'a'
 424                             || m1 < i))
 425                       break;
 426                   }
 427
 428                 if (i < 0)
 429                   matches = 0;
 430                 else if (*pp == 'a')
 431                   m1 = i, np += strlen (GET_MODE_NAME(i));
 432                 else
 433                   m2 = i, np += strlen (GET_MODE_NAME(i));
 434
 435                 force_int = force_partial_int = force_float = force_fixed = 0;
 436                 break;
 437
 438               default:
 439                 gcc_unreachable ();
 440               }
 441         }
 442
 443       if (matches && pp[0] == '$' && pp[1] == ')'
 444           && *np == 0)
 445         break;
 446     }
 447
 448   if (pindex == ARRAY_SIZE (optabs))
 449     return;
 450
 451   /* We found a match.  If this pattern is only conditionally present,
 452      write out the "if" and two extra blanks.  */
 453
 454   if (*XSTR (insn, 2) != 0)
 455     printf ("  if (HAVE_%s)\n  ", name);
 456
 457   printf ("  ");
 458
 459   /* Now write out the initialization, making all required substitutions.  */
 460   for (pp = optabs[pindex]; *pp; pp++)
 461     {
 462       if (*pp != '$')
 463         putchar (*pp);
 464       else
 465         switch (*++pp)
 466           {
 467           case '(':  case ')':
 468           case 'I':  case 'F':  case 'N':
 469             break;
 470           case 'V':
 471             if (SCALAR_FLOAT_MODE_P (m1))
 472               printf ("v");
 473             break;
 474           case 'a':
 475             for (np = GET_MODE_NAME(m1); *np; np++)
 476               putchar (TOLOWER (*np));
 477             break;
 478           case 'b':
 479             for (np = GET_MODE_NAME(m2); *np; np++)
 480               putchar (TOLOWER (*np));
 481             break;
 482           case 'A':
 483             printf ("%smode", GET_MODE_NAME(m1));
 484             break;
 485           case 'B':
 486             printf ("%smode", GET_MODE_NAME(m2));
 487             break;
 488           case 'c':
 489             printf ("%s", GET_RTX_NAME(op));
 490             break;
 491           case 'C':
 492             for (np = GET_RTX_NAME(op); *np; np++)
 493               putchar (TOUPPER (*np));
 494             break;
 495           }
 496     }
 497
 498   printf (";\n");
 499 }
 500
 501 extern int main (int, char **);
 502
 503 int
 504 main (int argc, char **argv)
 505 {
 506   rtx desc;
 507
 508   progname = "genopinit";
 509
 510   if (!init_rtx_reader_args (argc, argv))
 511     return (FATAL_EXIT_CODE);
 512
 513   printf ("/* Generated automatically by the program `genopinit'\n\
 514 from the machine description file `md'.  */\n\n");
 515
 516   printf ("#include \"config.h\"\n");
 517   printf ("#include \"system.h\"\n");
 518   printf ("#include \"coretypes.h\"\n");
 519   printf ("#include \"tm.h\"\n");
 520   printf ("#include \"rtl.h\"\n");
 521   printf ("#include \"tm_p.h\"\n");
 522   printf ("#include \"flags.h\"\n");
 523   printf ("#include \"insn-config.h\"\n");
 524   printf ("#include \"recog.h\"\n");
 525   printf ("#include \"expr.h\"\n");
 526   printf ("#include \"optabs.h\"\n");
 527   printf ("#include \"reload.h\"\n\n");
 528
 529   printf ("void\ninit_all_optabs (void)\n{\n");
 530
 531   puts ("\
 532 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 533   int i, j;\n\
 534 #endif\n");
 535
 536   /* Read the machine description.  */
 537
 538   while (1)
 539     {
 540       int line_no, insn_code_number = 0;
 541
 542       desc = read_md_rtx (&line_no, &insn_code_number);
 543       if (desc == NULL)
 544         break;
 545
 546       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 547         gen_insn (desc);
 548     }
 549
 550   puts ("\
 551 \n\
 552 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 553   /* This flag says the same insns that convert to a signed fixnum\n\
 554      also convert validly to an unsigned one.  */\n\
 555   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 556     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 557       set_convert_optab_handler\n\
 558         (ufixtrunc_optab, (enum machine_mode) i, (enum machine_mode) j,\n\
 559          convert_optab_handler (sfixtrunc_optab, (enum machine_mode) i,\n\
 560                                                  (enum machine_mode) j));\n\
 561 #endif\n\
 562 }");
 563
 564   fflush (stdout);
 565   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 566 }