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