gcc/genopinit.c

   1 /* Generate code to initialize optabs from machine description.
   2    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #include "hconfig.h"
  24 #include "system.h"
  25 #include "rtl.h"
  26 #include "errors.h"
  27 #include "gensupport.h"
  28
  29
  30 /* Many parts of GCC use arrays that are indexed by machine mode and
  31    contain the insn codes for pattern in the MD file that perform a given
  32    operation on operands of that mode.
  33
  34    These patterns are present in the MD file with names that contain
  35    the mode(s) used and the name of the operation.  This program
  36    writes a function `init_all_optabs' that initializes the optabs with
  37    all the insn codes of the relevant patterns present in the MD file.
  38
  39    This array contains a list of optabs that need to be initialized.  Within
  40    each string, the name of the pattern to be matched against is delimited
  41    with $( and $).  In the string, $a and $b are used to match a short mode
  42    name (the part of the mode name not including `mode' and converted to
  43    lower-case).  When writing out the initializer, the entire string is
  44    used.  $A and $B are replaced with the full name of the mode; $a and $b
  45    are replaced with the short form of the name, as above.
  46
  47    If $N is present in the pattern, it means the two modes must be consecutive
  48    widths in the same mode class (e.g, QImode and HImode).  $I means that
  49    only integer modes should be considered for the next mode, and $F means
  50    that only float modes should be considered.
  51
  52    For some optabs, we store the operation by RTL codes.  These are only
  53    used for comparisons.  In that case, $c and $C are the lower-case and
  54    upper-case forms of the comparison, respectively.  */
  55
  56 const char * const optabs[] =
  57 { "extendtab[$B][$A][0] = CODE_FOR_$(extend$a$b2$)",
  58   "extendtab[$B][$A][1] = CODE_FOR_$(zero_extend$a$b2$)",
  59   "fixtab[$A][$B][0] = CODE_FOR_$(fix$F$a$I$b2$)",
  60   "fixtab[$A][$B][1] = CODE_FOR_$(fixuns$F$a$b2$)",
  61   "fixtrunctab[$A][$B][0] = CODE_FOR_$(fix_trunc$F$a$I$b2$)",
  62   "fixtrunctab[$A][$B][1] = CODE_FOR_$(fixuns_trunc$F$a$I$b2$)",
  63   "floattab[$B][$A][0] = CODE_FOR_$(float$I$a$F$b2$)",
  64   "floattab[$B][$A][1] = CODE_FOR_$(floatuns$I$a$F$b2$)",
  65   "add_optab->handlers[$A].insn_code = CODE_FOR_$(add$a3$)",
  66   "sub_optab->handlers[$A].insn_code = CODE_FOR_$(sub$a3$)",
  67   "smul_optab->handlers[$A].insn_code = CODE_FOR_$(mul$a3$)",
  68   "umul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(umul$a3_highpart$)",
  69   "smul_highpart_optab->handlers[$A].insn_code = CODE_FOR_$(smul$a3_highpart$)",
  70   "smul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(mul$a$b3$)$N",
  71   "umul_widen_optab->handlers[$B].insn_code = CODE_FOR_$(umul$a$b3$)$N",
  72   "sdiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$I$a3$)",
  73   "udiv_optab->handlers[$A].insn_code = CODE_FOR_$(udiv$I$a3$)",
  74   "sdivmod_optab->handlers[$A].insn_code = CODE_FOR_$(divmod$a4$)",
  75   "udivmod_optab->handlers[$A].insn_code = CODE_FOR_$(udivmod$a4$)",
  76   "smod_optab->handlers[$A].insn_code = CODE_FOR_$(mod$a3$)",
  77   "umod_optab->handlers[$A].insn_code = CODE_FOR_$(umod$a3$)",
  78   "flodiv_optab->handlers[$A].insn_code = CODE_FOR_$(div$F$a3$)",
  79   "ftrunc_optab->handlers[$A].insn_code = CODE_FOR_$(ftrunc$F$a2$)",
  80   "and_optab->handlers[$A].insn_code = CODE_FOR_$(and$a3$)",
  81   "ior_optab->handlers[$A].insn_code = CODE_FOR_$(ior$a3$)",
  82   "xor_optab->handlers[$A].insn_code = CODE_FOR_$(xor$a3$)",
  83   "ashl_optab->handlers[$A].insn_code = CODE_FOR_$(ashl$a3$)",
  84   "ashr_optab->handlers[$A].insn_code = CODE_FOR_$(ashr$a3$)",
  85   "lshr_optab->handlers[$A].insn_code = CODE_FOR_$(lshr$a3$)",
  86   "rotl_optab->handlers[$A].insn_code = CODE_FOR_$(rotl$a3$)",
  87   "rotr_optab->handlers[$A].insn_code = CODE_FOR_$(rotr$a3$)",
  88   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(smin$I$a3$)",
  89   "smin_optab->handlers[$A].insn_code = CODE_FOR_$(min$F$a3$)",
  90   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(smax$I$a3$)",
  91   "smax_optab->handlers[$A].insn_code = CODE_FOR_$(max$F$a3$)",
  92   "umin_optab->handlers[$A].insn_code = CODE_FOR_$(umin$I$a3$)",
  93   "umax_optab->handlers[$A].insn_code = CODE_FOR_$(umax$I$a3$)",
  94   "neg_optab->handlers[$A].insn_code = CODE_FOR_$(neg$a2$)",
  95   "abs_optab->handlers[$A].insn_code = CODE_FOR_$(abs$a2$)",
  96   "sqrt_optab->handlers[$A].insn_code = CODE_FOR_$(sqrt$a2$)",
  97   "sin_optab->handlers[$A].insn_code = CODE_FOR_$(sin$a2$)",
  98   "cos_optab->handlers[$A].insn_code = CODE_FOR_$(cos$a2$)",
  99   "strlen_optab->handlers[$A].insn_code = CODE_FOR_$(strlen$a$)",
 100   "one_cmpl_optab->handlers[$A].insn_code = CODE_FOR_$(one_cmpl$a2$)",
 101   "ffs_optab->handlers[$A].insn_code = CODE_FOR_$(ffs$a2$)",
 102   "mov_optab->handlers[$A].insn_code = CODE_FOR_$(mov$a$)",
 103   "movstrict_optab->handlers[$A].insn_code = CODE_FOR_$(movstrict$a$)",
 104   "cmp_optab->handlers[$A].insn_code = CODE_FOR_$(cmp$a$)",
 105   "tst_optab->handlers[$A].insn_code = CODE_FOR_$(tst$a$)",
 106   "bcc_gen_fctn[$C] = gen_$(b$c$)",
 107   "setcc_gen_code[$C] = CODE_FOR_$(s$c$)",
 108   "movcc_gen_code[$A] = CODE_FOR_$(mov$acc$)",
 109   "cbranch_optab->handlers[$A].insn_code = CODE_FOR_$(cbranch$a4$)",
 110   "cmov_optab->handlers[$A].insn_code = CODE_FOR_$(cmov$a6$)",
 111   "cstore_optab->handlers[$A].insn_code = CODE_FOR_$(cstore$a4$)",
 112   "reload_in_optab[$A] = CODE_FOR_$(reload_in$a$)",
 113   "reload_out_optab[$A] = CODE_FOR_$(reload_out$a$)",
 114   "movstr_optab[$A] = CODE_FOR_$(movstr$a$)",
 115   "clrstr_optab[$A] = CODE_FOR_$(clrstr$a$)" };
 116
 117 static void gen_insn PARAMS ((rtx));
 118
 119 static void
 120 gen_insn (insn)
 121      rtx insn;
 122 {
 123   const char *name = XSTR (insn, 0);
 124   int m1 = 0, m2 = 0, op = 0;
 125   size_t pindex;
 126   int i;
 127   const char *np, *pp, *p, *q;
 128
 129   /* Don't mention instructions whose names are the null string.
 130      They are in the machine description just to be recognized.  */
 131   if (*name == 0)
 132     return;
 133
 134   /* See if NAME matches one of the patterns we have for the optabs we know
 135      about.  */
 136
 137   for (pindex = 0; pindex < sizeof optabs / sizeof optabs[0]; pindex++)
 138     {
 139       int force_float = 0, force_int = 0;
 140       int force_consec = 0;
 141       int matches = 1;
 142
 143       for (pp = optabs[pindex]; pp[0] != '$' || pp[1] != '('; pp++)
 144         ;
 145
 146       for (pp += 2, np = name; matches && ! (pp[0] == '$' && pp[1] == ')');
 147            pp++)
 148         {
 149           if (*pp != '$')
 150             {
 151               if (*pp != *np++)
 152                 break;
 153             }
 154           else
 155             switch (*++pp)
 156               {
 157               case 'N':
 158                 force_consec = 1;
 159                 break;
 160               case 'I':
 161                 force_int = 1;
 162                 break;
 163               case 'F':
 164                 force_float = 1;
 165                 break;
 166               case 'c':
 167                 for (op = 0; op < NUM_RTX_CODE; op++)
 168                   {
 169                     for (p = GET_RTX_NAME(op), q = np; *p; p++, q++)
 170                       if (*p != *q)
 171                         break;
 172
 173                     /* We have to be concerned about matching "gt" and
 174                        missing "gtu", e.g., so verify we have reached the
 175                        end of thing we are to match.  */
 176                     if (*p == 0 && *q == 0 && GET_RTX_CLASS(op) == '<')
 177                       break;
 178                   }
 179
 180                 if (op == NUM_RTX_CODE)
 181                   matches = 0;
 182                 else
 183                   np += strlen (GET_RTX_NAME(op));
 184                 break;
 185               case 'a':
 186               case 'b':
 187                 /* This loop will stop at the first prefix match, so
 188                    look through the modes in reverse order, in case
 189                    EXTRA_CC_MODES was used and CC is a prefix of the
 190                    CC modes (as it should be).  */
 191                 for (i = ((int) MAX_MACHINE_MODE) - 1; i >= 0; i--)
 192                   {
 193                     for (p = GET_MODE_NAME(i), q = np; *p; p++, q++)
 194                       if (TOLOWER (*p) != *q)
 195                         break;
 196
 197                     if (*p == 0
 198                         && (! force_int || mode_class[i] == MODE_INT)
 199                         && (! force_float || mode_class[i] == MODE_FLOAT))
 200                       break;
 201                   }
 202
 203                 if (i < 0)
 204                   matches = 0;
 205                 else if (*pp == 'a')
 206                   m1 = i, np += strlen (GET_MODE_NAME(i));
 207                 else
 208                   m2 = i, np += strlen (GET_MODE_NAME(i));
 209
 210                 force_int = force_float = 0;
 211                 break;
 212
 213               default:
 214                 abort ();
 215               }
 216         }
 217
 218       if (matches && pp[0] == '$' && pp[1] == ')'
 219           && *np == 0
 220           && (! force_consec || (int) GET_MODE_WIDER_MODE(m1) == m2))
 221         break;
 222     }
 223
 224   if (pindex == sizeof optabs / sizeof optabs[0])
 225     return;
 226
 227   /* We found a match.  If this pattern is only conditionally present,
 228      write out the "if" and two extra blanks.  */
 229
 230   if (*XSTR (insn, 2) != 0)
 231     printf ("  if (HAVE_%s)\n  ", name);
 232
 233   printf ("  ");
 234
 235   /* Now write out the initialization, making all required substitutions.  */
 236   for (pp = optabs[pindex]; *pp; pp++)
 237     {
 238       if (*pp != '$')
 239         putchar (*pp);
 240       else
 241         switch (*++pp)
 242           {
 243           case '(':  case ')':
 244           case 'I':  case 'F':  case 'N':
 245             break;
 246           case 'a':
 247             for (np = GET_MODE_NAME(m1); *np; np++)
 248               putchar (TOLOWER (*np));
 249             break;
 250           case 'b':
 251             for (np = GET_MODE_NAME(m2); *np; np++)
 252               putchar (TOLOWER (*np));
 253             break;
 254           case 'A':
 255             printf ("(int) %smode", GET_MODE_NAME(m1));
 256             break;
 257           case 'B':
 258             printf ("(int) %smode", GET_MODE_NAME(m2));
 259             break;
 260           case 'c':
 261             printf ("%s", GET_RTX_NAME(op));
 262             break;
 263           case 'C':
 264             printf ("(int) ");
 265             for (np = GET_RTX_NAME(op); *np; np++)
 266               putchar (TOUPPER (*np));
 267             break;
 268           }
 269     }
 270
 271   printf (";\n");
 272 }
 273
 274 extern int main PARAMS ((int, char **));
 275
 276 int
 277 main (argc, argv)
 278      int argc;
 279      char **argv;
 280 {
 281   rtx desc;
 282
 283   progname = "genopinit";
 284
 285   if (argc <= 1)
 286     fatal ("No input file name.");
 287
 288   if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
 289     return (FATAL_EXIT_CODE);
 290
 291   printf ("/* Generated automatically by the program `genopinit'\n\
 292 from the machine description file `md'.  */\n\n");
 293
 294   printf ("#include \"config.h\"\n");
 295   printf ("#include \"system.h\"\n");
 296   printf ("#include \"rtl.h\"\n");
 297   printf ("#include \"flags.h\"\n");
 298   printf ("#include \"insn-flags.h\"\n");
 299   printf ("#include \"insn-codes.h\"\n");
 300   printf ("#include \"insn-config.h\"\n");
 301   printf ("#include \"recog.h\"\n");
 302   printf ("#include \"expr.h\"\n");
 303   printf ("#include \"reload.h\"\n\n");
 304
 305   printf ("void\ninit_all_optabs ()\n{\n");
 306
 307   /* Read the machine description.  */
 308
 309   while (1)
 310     {
 311       int line_no, insn_code_number = 0;
 312
 313       desc = read_md_rtx (&line_no, &insn_code_number);
 314       if (desc == NULL)
 315         break;
 316
 317       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 318         gen_insn (desc);
 319     }
 320
 321   printf ("}\n");
 322
 323   fflush (stdout);
 324   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 325 }
 326
 327 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 328 const char *
 329 get_insn_name (code)
 330      int code ATTRIBUTE_UNUSED;
 331 {
 332   return NULL;
 333 }