gcc/genopinit.c

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