gcc/genopinit.c

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