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 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, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, 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   "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$a3$)",
  88   "sdivv_optab->handlers[$A].insn_code = CODE_FOR_$(div$V$I$a3$)",
  89   "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
  90   "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
  91   "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
  92   "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
  93   "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
  94   "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
  95   "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
  96   "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
  97   "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
  98   "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
  99   "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
 100   "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
 101   "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
 102   "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
 103   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$I$a3$)",
 104   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(min$F$a3$)",
 105   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$I$a3$)",
 106   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(max$F$a3$)",
 107   "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
 108   "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
 109   "pow_optab->handlers[$A].insn_code = CODE_FOR_$(pow$a3$)",
 110   "atan2_optab->handlers[$A].insn_code = CODE_FOR_$(atan2$a3$)",
 111   "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$P$a2$)",
 112   "negv_optab->handlers[$A].insn_code =\n\
 113     neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$F$a2$)",
 114   "negv_optab->handlers[$A].insn_code = CODE_FOR_$(negv$I$a2$)",
 115   "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$P$a2$)",
 116   "absv_optab->handlers[$A].insn_code =\n\
 117     abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$F$a2$)",
 118   "absv_optab->handlers[$A].insn_code = CODE_FOR_$(absv$I$a2$)",
 119   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
 120   "floor_optab->handlers[$A].insn_code = CODE_FOR_$(floor$a2$)",
 121   "ceil_optab->handlers[$A].insn_code = CODE_FOR_$(ceil$a2$)",
 122   "round_optab->handlers[$A].insn_code = CODE_FOR_$(round$a2$)",
 123   "trunc_optab->handlers[$A].insn_code = CODE_FOR_$(trunc$a2$)",
 124   "nearbyint_optab->handlers[$A].insn_code = CODE_FOR_$(nearbyint$a2$)",
 125   "sincos_optab->handlers[$A].insn_code = CODE_FOR_$(sincos$a3$)",
 126   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
 127   "asin_optab->handlers[$A].insn_code = CODE_FOR_$(asin$a2$)",
 128   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
 129   "acos_optab->handlers[$A].insn_code = CODE_FOR_$(acos$a2$)",
 130   "exp_optab->handlers[$A].insn_code = CODE_FOR_$(exp$a2$)",
 131   "exp10_optab->handlers[$A].insn_code = CODE_FOR_$(exp10$a2$)",
 132   "exp2_optab->handlers[$A].insn_code = CODE_FOR_$(exp2$a2$)",
 133   "logb_optab->handlers[$A].insn_code = CODE_FOR_$(logb$a2$)",
 134   "ilogb_optab->handlers[$A].insn_code = CODE_FOR_$(ilogb$a2$)",
 135   "log_optab->handlers[$A].insn_code = CODE_FOR_$(log$a2$)",
 136   "log10_optab->handlers[$A].insn_code = CODE_FOR_$(log10$a2$)",
 137   "log2_optab->handlers[$A].insn_code = CODE_FOR_$(log2$a2$)",
 138   "tan_optab->handlers[$A].insn_code = CODE_FOR_$(tan$a2$)",
 139   "atan_optab->handlers[$A].insn_code = CODE_FOR_$(atan$a2$)",
 140   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 141   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 142   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 143   "clz_optab->handlers[$A].insn_code = CODE_FOR_$(clz$a2$)",
 144   "ctz_optab->handlers[$A].insn_code = CODE_FOR_$(ctz$a2$)",
 145   "popcount_optab->handlers[$A].insn_code = CODE_FOR_$(popcount$a2$)",
 146   "parity_optab->handlers[$A].insn_code = CODE_FOR_$(parity$a2$)",
 147   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 148   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 149   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 150   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 151   "addcc_optab->handlers[$A].insn_code = CODE_FOR_$(add$acc$)",
 152   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 153   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 154   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 155   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 156   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 157   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 158   "push_optab->handlers[$A].insn_code = CODE_FOR_$(push$a1$)",
 159   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 160   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 161   "movstr_optab[$A] = CODE_FOR_$(movstr$a$)",
 162   "clrstr_optab[$A] = CODE_FOR_$(clrstr$a$)",
 163   "cmpstr_optab[$A] = CODE_FOR_$(cmpstr$a$)",
 164   "cmpmem_optab[$A] = CODE_FOR_$(cmpmem$a$)",
 165   "vec_set_optab->handlers[$A].insn_code = CODE_FOR_$(vec_set$a$)",
 166   "vec_extract_optab->handlers[$A].insn_code = CODE_FOR_$(vec_extract$a$)",
 167   "vec_init_optab->handlers[$A].insn_code = CODE_FOR_$(vec_init$a$)" };
 168
 169 static void gen_insn (rtx);
 170
 171 static void
 172 gen_insn (rtx insn)
 173 {
 174   const char *name = XSTR (insn, 0);
 175   int m1 = 0, m2 = 0, op = 0;
 176   size_t pindex;
 177   int i;
 178   const char *np, *pp, *p, *q;
 179
 180   /* Don't mention instructions whose names are the null string.
 181      They are in the machine description just to be recognized.  */
 182   if (*name == 0)
 183     return;
 184
 185   /* See if NAME matches one of the patterns we have for the optabs we know
 186      about.  */
 187
 188   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 189     {
 190       int force_float = 0, force_int = 0, force_partial_int = 0;
 191       int force_consec = 0;
 192       int matches = 1;
 193
 194       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 195         ;
 196
 197       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 198            pp++)
 199         {
 200           if (*pp != '$')
 201             {
 202               if (*pp != *np++)
 203                 break;
 204             }
 205           else
 206             switch (*++pp)
 207               {
 208               case 'N':
 209                 force_consec = 1;
 210                 break;
 211               case 'I':
 212                 force_int = 1;
 213                 break;
 214               case 'P':
 215                 force_partial_int = 1;
 216                 break;
 217               case 'F':
 218                 force_float = 1;
 219                 break;
 220               case 'V':
 221                 break;
 222               case 'c':
 223                 for (op = 0; op < NUM_RTX_CODE; op++)
 224                   {
 225                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 226                       if (*p != *q)
 227                         break;
 228
 229                     /* We have to be concerned about matching "gt" and
 230                        missing "gtu", e.g., so verify we have reached the
 231                        end of thing we are to match.  */
 232                     if (*p == 0 && *q == 0
 233                         && (GET_RTX_CLASS (op) == RTX_COMPARE
 234                             || GET_RTX_CLASS (op) == RTX_COMM_COMPARE))
 235                       break;
 236                   }
 237
 238                 if (op == NUM_RTX_CODE)
 239                   matches = 0;
 240                 else
 241                   np += strlen (GET_RTX_NAME(op));
 242                 break;
 243               case 'a':
 244               case 'b':
 245                 /* This loop will stop at the first prefix match, so
 246                    look through the modes in reverse order, in case
 247                    there are extra CC modes and CC is a prefix of the
 248                    CC modes (as it should be).  */
 249                 for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 250                   {
 251                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 252                       if (TOLOWER (*p) != *q)
 253                         break;
 254
 255                     if (*p == 0
 256                         && (! force_int || mode_class[i] == MODE_INT
 257                             || mode_class[i] == MODE_VECTOR_INT)
 258                         && (! force_partial_int
 259                             || mode_class[i] == MODE_INT
 260                             || mode_class[i] == MODE_PARTIAL_INT
 261                             || mode_class[i] == MODE_VECTOR_INT)
 262                         && (! force_float || mode_class[i] == MODE_FLOAT
 263                             || mode_class[i] == MODE_VECTOR_FLOAT))
 264                       break;
 265                   }
 266
 267                 if (i < 0)
 268                   matches = 0;
 269                 else if (*pp == 'a')
 270                   m1 = i, np += strlen (GET_MODE_NAME(i));
 271                 else
 272                   m2 = i, np += strlen (GET_MODE_NAME(i));
 273
 274                 force_int = force_partial_int = force_float = 0;
 275                 break;
 276
 277               default:
 278                 abort ();
 279               }
 280         }
 281
 282       if (matches && pp[0] == '$' && pp[1] == ')'
 283           && *np == 0
 284           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 285         break;
 286     }
 287
 288   if (pindex == ARRAY_SIZE (optabs))
 289     return;
 290
 291   /* We found a match.  If this pattern is only conditionally present,
 292      write out the "if" and two extra blanks.  */
 293
 294   if (*XSTR (insn, 2) != 0)
 295     printf ("  if (HAVE_%s)\n  ", name);
 296
 297   printf ("  ");
 298
 299   /* Now write out the initialization, making all required substitutions.  */
 300   for (pp = optabs[pindex]; *pp; pp++)
 301     {
 302       if (*pp != '$')
 303         putchar (*pp);
 304       else
 305         switch (*++pp)
 306           {
 307           case '(':  case ')':
 308           case 'I':  case 'F':  case 'N':
 309             break;
 310           case 'V':
 311             if (GET_MODE_CLASS (m1) == MODE_FLOAT)
 312               printf ("v");
 313             break;
 314           case 'a':
 315             for (np = GET_MODE_NAME(m1); *np; np++)
 316               putchar (TOLOWER (*np));
 317             break;
 318           case 'b':
 319             for (np = GET_MODE_NAME(m2); *np; np++)
 320               putchar (TOLOWER (*np));
 321             break;
 322           case 'A':
 323             printf ("%smode", GET_MODE_NAME(m1));
 324             break;
 325           case 'B':
 326             printf ("%smode", GET_MODE_NAME(m2));
 327             break;
 328           case 'c':
 329             printf ("%s", GET_RTX_NAME(op));
 330             break;
 331           case 'C':
 332             for (np = GET_RTX_NAME(op); *np; np++)
 333               putchar (TOUPPER (*np));
 334             break;
 335           }
 336     }
 337
 338   printf (";\n");
 339 }
 340
 341 extern int main (int, char **);
 342
 343 int
 344 main (int argc, char **argv)
 345 {
 346   rtx desc;
 347
 348   progname = "genopinit";
 349
 350   if (argc <= 1)
 351     fatal ("no input file name");
 352
 353   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 354     return (FATAL_EXIT_CODE);
 355
 356   printf ("/* Generated automatically by the program `genopinit'\n\
 357 from the machine description file `md'.  */\n\n");
 358
 359   printf ("#include \"config.h\"\n");
 360   printf ("#include \"system.h\"\n");
 361   printf ("#include \"coretypes.h\"\n");
 362   printf ("#include \"tm.h\"\n");
 363   printf ("#include \"rtl.h\"\n");
 364   printf ("#include \"flags.h\"\n");
 365   printf ("#include \"insn-config.h\"\n");
 366   printf ("#include \"recog.h\"\n");
 367   printf ("#include \"expr.h\"\n");
 368   printf ("#include \"optabs.h\"\n");
 369   printf ("#include \"reload.h\"\n\n");
 370
 371   printf ("void\ninit_all_optabs (void)\n{\n");
 372
 373   puts ("\
 374 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 375   int i, j;\n\
 376 #endif\n");
 377
 378   /* Read the machine description.  */
 379
 380   while (1)
 381     {
 382       int line_no, insn_code_number = 0;
 383
 384       desc = read_md_rtx (&line_no, &insn_code_number);
 385       if (desc == NULL)
 386         break;
 387
 388       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 389         gen_insn (desc);
 390     }
 391
 392   puts ("\
 393 \n\
 394 #ifdef FIXUNS_TRUNC_LIKE_FIX_TRUNC\n\
 395   /* This flag says the same insns that convert to a signed fixnum\n\
 396      also convert validly to an unsigned one.  */\n\
 397   for (i = 0; i < NUM_MACHINE_MODES; i++)\n\
 398     for (j = 0; j < NUM_MACHINE_MODES; j++)\n\
 399       ufixtrunc_optab->handlers[i][j].insn_code\n\
 400       = sfixtrunc_optab->handlers[i][j].insn_code;\n\
 401 #endif\n\
 402 }");
 403
 404   fflush (stdout);
 405   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 406 }
 407
 408 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 409 const char *
 410 get_insn_name (int code ATTRIBUTE_UNUSED)
 411 {
 412   return NULL;
 413 }