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