gcc/genopinit.c

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