gcc/genopinit.c

   1 /* Generate code to initialize optabs from machine description.
   2    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #include "hconfig.h"
  24 #include "system.h"
  25 #include "rtl.h"
  26 #include "obstack.h"
  27 #include "errors.h"
  28 #include "gensupport.h"
  29
  30 static struct obstack obstack;
  31 struct obstack *rtl_obstack = &obstack;
  32
  33 #define obstack_chunk_alloc xmalloc
  34 #define obstack_chunk_free free
  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 * const 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   "cbranch_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cbranch%a4%)",
 119   "cmov_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cmov%a6%)",
 120   "cstore_optab->handlers[(int) %A].insn_code = CODE_FOR_%(cstore%a4%)",
 121   "reload_in_optab[(int) %A] = CODE_FOR_%(reload_in%a%)",
 122   "reload_out_optab[(int) %A] = CODE_FOR_%(reload_out%a%)",
 123   "movstr_optab[(int) %A] = CODE_FOR_%(movstr%a%)",
 124   "clrstr_optab[(int) %A] = CODE_FOR_%(clrstr%a%)" };
 125
 126 static void gen_insn PARAMS ((rtx));
 127
 128 static void
 129 gen_insn (insn)
 130      rtx insn;
 131 {
 132   const char *name = XSTR (insn, 0);
 133   int m1 = 0, m2 = 0, op = 0;
 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 (*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               putchar (TOLOWER (*np));
 258             break;
 259           case 'b':
 260             for (np = GET_MODE_NAME(m2); *np; np++)
 261               putchar (TOLOWER (*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               putchar (TOUPPER (*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 extern int main PARAMS ((int, char **));
 310
 311 int
 312 main (argc, argv)
 313      int argc;
 314      char **argv;
 315 {
 316   rtx desc;
 317
 318   progname = "genopinit";
 319   obstack_init (rtl_obstack);
 320
 321   if (argc <= 1)
 322     fatal ("No input file name.");
 323
 324   if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
 325     return (FATAL_EXIT_CODE);
 326
 327   printf ("/* Generated automatically by the program `genopinit'\n\
 328 from the machine description file `md'.  */\n\n");
 329
 330   printf ("#include \"config.h\"\n");
 331   printf ("#include \"system.h\"\n");
 332   printf ("#include \"rtl.h\"\n");
 333   printf ("#include \"flags.h\"\n");
 334   printf ("#include \"insn-flags.h\"\n");
 335   printf ("#include \"insn-codes.h\"\n");
 336   printf ("#include \"insn-config.h\"\n");
 337   printf ("#include \"recog.h\"\n");
 338   printf ("#include \"expr.h\"\n");
 339   printf ("#include \"reload.h\"\n\n");
 340
 341   printf ("void\ninit_all_optabs ()\n{\n");
 342
 343   /* Read the machine description.  */
 344
 345   while (1)
 346     {
 347       int line_no, insn_code_number = 0;
 348
 349       desc = read_md_rtx (&line_no, &insn_code_number);
 350       if (desc == NULL)
 351         break;
 352
 353       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 354         gen_insn (desc);
 355     }
 356
 357   printf ("}\n");
 358
 359   fflush (stdout);
 360   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 361 }
 362
 363 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 364 const char *
 365 get_insn_name (code)
 366      int code ATTRIBUTE_UNUSED;
 367 {
 368   return NULL;
 369 }