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 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  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 consecutive
  50    widths in the same mode class (e.g, QImode and HImode).  $I means that
  51    only full integer modes should be considered for the next mode, and $F
  52    means that only float modes should be considered.
  53    $P means that both full and partial integer modes should be considered.
  54
  55    $V means to emit 'v' if the first mode is a MODE_FLOAT mode.
  56
  57    For some optabs, we store the operation by RTL codes.  These are only
  58    used for comparisons.  In that case, $c and $C are the lower-case and
  59    upper-case forms of the comparison, respectively.  */
  60
  61 static const char * const optabs[] =
  62 { "sext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(extend$a$b2$)",
  63   "zext_optab->handlers[$B][$A].insn_code = CODE_FOR_$(zero_extend$a$b2$)",
  64   "sfix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix$F$a$I$b2$)",
  65   "ufix_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns$F$a$b2$)",
  66   "sfixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
  67   "ufixtrunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
  68   "sfloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(float$I$a$F$b2$)",
  69   "ufloat_optab->handlers[$B][$A].insn_code = CODE_FOR_$(floatuns$I$a$F$b2$)",
  70   "trunc_optab->handlers[$B][$A].insn_code = CODE_FOR_$(trunc$a$b2$)",
  71   "add_optab->handlers[$A].insn_code = CODE_FOR_$(add$P$a3$)",
  72   "addv_optab->handlers[$A].insn_code =\n\
  73     add_optab->handlers[$A].insn_code = CODE_FOR_$(add$F$a3$)",
  74   "addv_optab->handlers[$A].insn_code = CODE_FOR_$(addv$I$a3$)",
  75   "sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$P$a3$)",
  76   "subv_optab->handlers[$A].insn_code =\n\
  77     sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$F$a3$)",
  78   "subv_optab->handlers[$A].insn_code = CODE_FOR_$(subv$I$a3$)",
  79   "smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$P$a3$)",
  80   "smulv_optab->handlers[$A].insn_code =\n\
  81     smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$F$a3$)",
  82   "smulv_optab->handlers[$A].insn_code = CODE_FOR_$(mulv$I$a3$)",
  83   "umul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(umul$a3_highpart$)",
  84   "smul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(smul$a3_highpart$)",
  85   "smul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(mul$a$b3$)$N",
  86   "umul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umul$a$b3$)$N",
  87   "usmul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(usmul$a$b3$)$N",
  88   "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$a3$)",
  89   "sdivv_optab->handlers[$A].insn_code = CODE_FOR_$(div$V$I$a3$)",
  90   "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
  91   "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
  92   "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
  93   "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
  94   "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
  95   "fmod_optab->handlers[$A].insn_code = CODE_FOR_$(fmod$a3$)",
  96   "remainder_optab->handlers[$A].insn_code = CODE_FOR_$(remainder$a3$)",
  97   "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
  98   "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
  99   "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
 100   "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
 101   "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
 102   "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
 103   "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
 104   "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
 105   "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
 106   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$a3$)",
 107   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$a3$)",
 108   "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
 109   "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
 110   "pow_optab->handlers[$A].insn_code = CODE_FOR_$(pow$a3$)",
 111   "atan2_optab->handlers[$A].insn_code = CODE_FOR_$(atan2$a3$)",
 112   "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
 113   "negv_optab->handlers[$A].insn_code =\n\
 114     neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$F$a2$)",
 115   "negv_optab->handlers[$A].insn_code = CODE_FOR_$(negv$I$a2$)",
 116   "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
 117   "absv_optab->handlers[$A].insn_code =\n\
 118     abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$F$a2$)",
 119   "absv_optab->handlers[$A].insn_code = CODE_FOR_$(absv$I$a2$)",
 120   "copysign_optab->handlers[$A].insn_code = CODE_FOR_$(copysign$F$a3$)",
 121   "isinf_optab->handlers[$A].insn_code = CODE_FOR_$(isinf$a2$)",
 122   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
 123   "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
 124   "lfloor_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lfloor$F$a$I$b2$)",
 125   "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
 126   "lceil_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lceil$F$a$I$b2$)",
 127   "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
 128   "btrunc_optab->handlers[$A].insn_code = CODE_FOR_$(btrunc$a2$)",
 129   "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
 130   "rint_optab->handlers[$A].insn_code = CODE_FOR_$(rint$a2$)",
 131   "lrint_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lrint$F$a$I$b2$)",
 132   "lround_optab->handlers[$B][$A].insn_code = CODE_FOR_$(lround$F$a$I$b2$)",
 133   "sincos_optab->handlers[$A].insn_code = CODE_FOR_$(sincos$a3$)",
 134   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
 135   "asin_optab->handlers[$A].insn_code = CODE_FOR_$(asin$a2$)",
 136   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
 137   "acos_optab->handlers[$A].insn_code = CODE_FOR_$(acos$a2$)",
 138   "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
 139   "exp10_optab->handlers[$A].insn_code = CODE_FOR_$(exp10$a2$)",
 140   "exp2_optab->handlers[$A].insn_code = CODE_FOR_$(exp2$a2$)",
 141   "expm1_optab->handlers[$A].insn_code = CODE_FOR_$(expm1$a2$)",
 142   "ldexp_optab->handlers[$A].insn_code = CODE_FOR_$(ldexp$a3$)",
 143   "scalb_optab->handlers[$A].insn_code = CODE_FOR_$(scalb$a3$)",
 144   "logb_optab->handlers[$A].insn_code = CODE_FOR_$(logb$a2$)",
 145   "ilogb_optab->handlers[$A].insn_code = CODE_FOR_$(ilogb$a2$)",
 146   "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
 147   "log10_optab->handlers[$A].insn_code = CODE_FOR_$(log10$a2$)",
 148   "log2_optab->handlers[$A].insn_code = CODE_FOR_$(log2$a2$)",
 149   "log1p_optab->handlers[$A].insn_code = CODE_FOR_$(log1p$a2$)",
 150   "tan_optab->handlers[$A].insn_code = CODE_FOR_$(tan$a2$)",
 151   "atan_optab->handlers[$A].insn_code = CODE_FOR_$(atan$a2$)",
 152   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 153   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 154   "bswap_optab->handlers[$A].insn_code = CODE_FOR_$(bswap$a2$)",
 155   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 156   "clz_optab->handlers[$A].insn_code = CODE_FOR_$(clz$a2$)",
 157   "ctz_optab->handlers[$A].insn_code = CODE_FOR_$(ctz$a2$)",
 158   "popcount_optab->handlers[$A].insn_code = CODE_FOR_$(popcount$a2$)",
 159   "parity_optab->handlers[$A].insn_code = CODE_FOR_$(parity$a2$)",
 160   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 161   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 162   "movmisalign_optab->handlers[$A].insn_code = CODE_FOR_$(movmisalign$a$)",
 163   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 164   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 165   "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
 166   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 167   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 168   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 169   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 170   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 171   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 172   "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
 173   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 174   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 175   "movmem_optab[$A] = CODE_FOR_$(movmem$a$)",
 176   "cmpstr_optab[$A] = CODE_FOR_$(cmpstr$a$)",
 177   "cmpstrn_optab[$A] = CODE_FOR_$(cmpstrn$a$)",
 178   "cmpmem_optab[$A] = CODE_FOR_$(cmpmem$a$)",
 179   "setmem_optab[$A] = CODE_FOR_$(setmem$a$)",
 180   "sync_add_optab[$A] = CODE_FOR_$(sync_add$I$a$)",
 181   "sync_sub_optab[$A] = CODE_FOR_$(sync_sub$I$a$)",
 182   "sync_ior_optab[$A] = CODE_FOR_$(sync_ior$I$a$)",
 183   "sync_and_optab[$A] = CODE_FOR_$(sync_and$I$a$)",
 184   "sync_xor_optab[$A] = CODE_FOR_$(sync_xor$I$a$)",
 185   "sync_nand_optab[$A] = CODE_FOR_$(sync_nand$I$a$)",
 186   "sync_old_add_optab[$A] = CODE_FOR_$(sync_old_add$I$a$)",
 187   "sync_old_sub_optab[$A] = CODE_FOR_$(sync_old_sub$I$a$)",
 188   "sync_old_ior_optab[$A] = CODE_FOR_$(sync_old_ior$I$a$)",
 189   "sync_old_and_optab[$A] = CODE_FOR_$(sync_old_and$I$a$)",
 190   "sync_old_xor_optab[$A] = CODE_FOR_$(sync_old_xor$I$a$)",
 191   "sync_old_nand_optab[$A] = CODE_FOR_$(sync_old_nand$I$a$)",
 192   "sync_new_add_optab[$A] = CODE_FOR_$(sync_new_add$I$a$)",
 193   "sync_new_sub_optab[$A] = CODE_FOR_$(sync_new_sub$I$a$)",
 194   "sync_new_ior_optab[$A] = CODE_FOR_$(sync_new_ior$I$a$)",
 195   "sync_new_and_optab[$A] = CODE_FOR_$(sync_new_and$I$a$)",
 196   "sync_new_xor_optab[$A] = CODE_FOR_$(sync_new_xor$I$a$)",
 197   "sync_new_nand_optab[$A] = CODE_FOR_$(sync_new_nand$I$a$)",
 198   "sync_compare_and_swap[$A] = CODE_FOR_$(sync_compare_and_swap$I$a$)",
 199   "sync_compare_and_swap_cc[$A] = CODE_FOR_$(sync_compare_and_swap_cc$I$a$)",
 200   "sync_lock_test_and_set[$A] = CODE_FOR_$(sync_lock_test_and_set$I$a$)",
 201   "sync_lock_release[$A] = CODE_FOR_$(sync_lock_release$I$a$)",
 202   "vec_set_optab->handlers[$A].insn_code = CODE_FOR_$(vec_set$a$)",
 203   "vec_extract_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract$a$)",
 204   "vec_extract_even_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract_even$a$)",
 205   "vec_extract_odd_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract_odd$a$)",
 206   "vec_interleave_high_optab->handlers[$A].insn_code = CODE_FOR_$(vec_interleave_high$a$)",
 207   "vec_interleave_low_optab->handlers[$A].insn_code = CODE_FOR_$(vec_interleave_low$a$)",
 208   "vec_init_optab->handlers[$A].insn_code = CODE_FOR_$(vec_init$a$)",
 209   "vec_shl_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shl_$a$)",
 210   "vec_shr_optab->handlers[$A].insn_code = CODE_FOR_$(vec_shr_$a$)",
 211   "vec_realign_load_optab->handlers[$A].insn_code = CODE_FOR_$(vec_realign_load_$a$)",
 212   "vcond_gen_code[$A] = CODE_FOR_$(vcond$a$)",
 213   "vcondu_gen_code[$A] = CODE_FOR_$(vcondu$a$)",
 214   "ssum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_ssum$I$a3$)",
 215   "usum_widen_optab->handlers[$A].insn_code = CODE_FOR_$(widen_usum$I$a3$)",
 216   "udot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(udot_prod$I$a$)",
 217   "sdot_prod_optab->handlers[$A].insn_code = CODE_FOR_$(sdot_prod$I$a$)",
 218   "reduc_smax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smax_$a$)",
 219   "reduc_umax_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umax_$a$)",
 220   "reduc_smin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_smin_$a$)",
 221   "reduc_umin_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_umin_$a$)",
 222   "reduc_splus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_splus_$a$)" ,
 223   "reduc_uplus_optab->handlers[$A].insn_code = CODE_FOR_$(reduc_uplus_$a$)",
 224   "vec_widen_umult_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_umult_hi_$a$)",
 225   "vec_widen_umult_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_umult_lo_$a$)",
 226   "vec_widen_smult_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_smult_hi_$a$)",
 227   "vec_widen_smult_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_widen_smult_lo_$a$)",
 228   "vec_unpacks_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_hi_$a$)",
 229   "vec_unpacks_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacks_lo_$a$)",
 230   "vec_unpacku_hi_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_hi_$a$)",
 231   "vec_unpacku_lo_optab->handlers[$A].insn_code = CODE_FOR_$(vec_unpacku_lo_$a$)",
 232   "vec_pack_trunc_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_trunc_$a$)",
 233   "vec_pack_ssat_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_ssat_$a$)",
 234   "vec_pack_usat_optab->handlers[$A].insn_code = CODE_FOR_$(vec_pack_usat_$a$)"
 235 };
 236
 237 static void gen_insn (rtx);
 238
 239 static void
 240 gen_insn (rtx insn)
 241 {
 242   const char *name = XSTR (insn, 0);
 243   int m1 = 0, m2 = 0, op = 0;
 244   size_t pindex;
 245   int i;
 246   const char *np, *pp, *p, *q;
 247
 248   /* Don't mention instructions whose names are the null string.
 249      They are in the machine description just to be recognized.  */
 250   if (*name == 0)
 251     return;
 252
 253   /* See if NAME matches one of the patterns we have for the optabs we know
 254      about.  */
 255
 256   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 257     {
 258       int force_float = 0, force_int = 0, force_partial_int = 0;
 259       int force_consec = 0;
 260       int matches = 1;
 261
 262       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 263         ;
 264
 265       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 266            pp++)
 267         {
 268           if (*pp != '$')
 269             {
 270               if (*pp != *np++)
 271                 break;
 272             }
 273           else
 274             switch (*++pp)
 275               {
 276               case 'N':
 277                 force_consec = 1;
 278                 break;
 279               case 'I':
 280                 force_int = 1;
 281                 break;
 282               case 'P':
 283                 force_partial_int = 1;
 284                 break;
 285               case 'F':
 286                 force_float = 1;
 287                 break;
 288               case 'V':
 289                 break;
 290               case 'c':
 291                 for (op = 0; op < NUM_RTX_CODE; op++)
 292                   {
 293                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 294                       if (*p != *q)
 295                         break;
 296
 297                     /* We have to be concerned about matching "gt" and
 298                        missing "gtu", e.g., so verify we have reached the
 299                        end of thing we are to match.  */
 300                     if (*p == 0 && *q == 0
 301                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 302                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 303                       break;
 304                   }
 305
 306                 if (op == NUM_RTX_CODE)
 307                   matches = 0;
 308                 else
 309                   np += strlen (GET_RTX_NAME(op));
 310                 break;
 311               case 'a':
 312               case 'b':
 313                 /* This loop will stop at the first prefix match, so
 314                    look through the modes in reverse order, in case
 315                    there are extra CC modes and CC is a prefix of the
 316                    CC modes (as it should be).  */
 317                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 318                   {
 319                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 320                       if (TOLOWER (*p) != *q)
 321                         break;
 322
 323                     if (*p == 0
 324                         && (! force_int || mode_class[i] == MODE_INT
 325                             || mode_class[i] == MODE_VECTOR_INT)
 326                         && (! force_partial_int
 327                             || mode_class[i] == MODE_INT
 328                             || mode_class[i] == MODE_PARTIAL_INT
 329                             || mode_class[i] == MODE_VECTOR_INT)
 330                         && (! force_float
 331                             || mode_class[i] == MODE_FLOAT
 332                             || mode_class[i] == MODE_DECIMAL_FLOAT
 333                             || mode_class[i] == MODE_COMPLEX_FLOAT
 334                             || mode_class[i] == MODE_VECTOR_FLOAT))
 335                       break;
 336                   }
 337
 338                 if (i < 0)
 339                   matches = 0;
 340                 else if (*pp == 'a')
 341                   m1 = i, np += strlen (GET_MODE_NAME(i));
 342                 else
 343                   m2 = i, np += strlen (GET_MODE_NAME(i));
 344
 345                 force_int = force_partial_int = force_float = 0;
 346                 break;
 347
 348               default:
 349                 gcc_unreachable ();
 350               }
 351         }
 352
 353       if (matches && pp[0] == '$' && pp[1] == ')'
 354           && *np == 0
 355           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 356         break;
 357     }
 358
 359   if (pindex == ARRAY_SIZE (optabs))
 360     return;
 361
 362   /* We found a match.  If this pattern is only conditionally present,
 363      write out the "if" and two extra blanks.  */
 364
 365   if (*XSTR (insn, 2) != 0)
 366     printf ("  if (HAVE_%s)\n  ", name);
 367
 368   printf ("  ");
 369
 370   /* Now write out the initialization, making all required substitutions.  */
 371   for (pp = optabs[pindex]; *pp; pp++)
 372     {
 373       if (*pp != '$')
 374         putchar (*pp);
 375       else
 376         switch (*++pp)
 377           {
 378           case '(':  case ')':
 379           case 'I':  case 'F':  case 'N':
 380             break;
 381           case 'V':
 382             if (SCALAR_FLOAT_MODE_P (m1))
 383               printf ("v");
 384             break;
 385           case 'a':
 386             for (np = GET_MODE_NAME(m1); *np; np++)
 387               putchar (TOLOWER (*np));
 388             break;
 389           case 'b':
 390             for (np = GET_MODE_NAME(m2); *np; np++)
 391               putchar (TOLOWER (*np));
 392             break;
 393           case 'A':
 394             printf ("%smode", GET_MODE_NAME(m1));
 395             break;
 396           case 'B':
 397             printf ("%smode", GET_MODE_NAME(m2));
 398             break;
 399           case 'c':
 400             printf ("%s", GET_RTX_NAME(op));
 401             break;
 402           case 'C':
 403             for (np = GET_RTX_NAME(op); *np; np++)
 404               putchar (TOUPPER (*np));
 405             break;
 406           }
 407     }
 408
 409   printf (";\n");
 410 }
 411
 412 extern int main (int, char **);
 413
 414 int
 415 main (int argc, char **argv)
 416 {
 417   rtx desc;
 418
 419   progname = "genopinit";
 420
 421   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 422     return (FATAL_EXIT_CODE);
 423
 424   printf ("/* Generated automatically by the program `genopinit'\n\
 425 from the machine description file `md'.  */\n\n");
 426
 427   printf ("#include \"config.h\"\n");
 428   printf ("#include \"system.h\"\n");
 429   printf ("#include \"coretypes.h\"\n");
 430   printf ("#include \"tm.h\"\n");
 431   printf ("#include \"rtl.h\"\n");
 432   printf ("#include \"flags.h\"\n");
 433   printf ("#include \"insn-config.h\"\n");
 434   printf ("#include \"recog.h\"\n");
 435   printf ("#include \"expr.h\"\n");
 436   printf ("#include \"optabs.h\"\n");
 437   printf ("#include \"reload.h\"\n\n");
 438
 439   printf ("void\ninit_all_optabs (void)\n{\n");
 440
 441   puts ("\
 442 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 443   int i, j;\n\
 444 #endif\n");
 445
 446   /* Read the machine description.  */
 447
 448   while (1)
 449     {
 450       int line_no, insn_code_number = 0;
 451
 452       desc = read_md_rtx (&line_no, &insn_code_number);
 453       if (desc == NULL)
 454         break;
 455
 456       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 457         gen_insn (desc);
 458     }
 459
 460   puts ("\
 461 \n\
 462 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 463   /* This flag says the same insns that convert to a signed fixnum\n\
 464      also convert validly to an unsigned one.  */\n\
 465   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 466     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 467       ufixtrunc_optab->handlers[i][j].insn_code\n\
 468       = sfixtrunc_optab->handlers[i][j].insn_code;\n\
 469 #endif\n\
 470 }");
 471
 472   fflush (stdout);
 473   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 474 }