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