gcc/genextract.c

   1 /* Generate code from machine description to extract operands from insn as rtl.
   2    Copyright (C) 1987, 1991, 1992, 1993, 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 "insn-config.h"
  27
  28 #ifdef HAVE_STDLIB_H
  29 #include <stdlib.h>
  30 #endif
  31
  32 static struct obstack obstack;
  33 struct obstack *rtl_obstack = &obstack;
  34
  35 #define obstack_chunk_alloc xmalloc
  36 #define obstack_chunk_free free
  37
  38 extern void free ();
  39 extern rtx read_rtx ();
  40
  41 /* Names for patterns.  Need to allow linking with print-rtl.  */
  42 char **insn_name_ptr;
  43
  44 /* This structure contains all the information needed to describe one
  45    set of extractions methods.  Each method may be used by more than
  46    one pattern if the operands are in the same place.
  47
  48    The string for each operand describes that path to the operand and
  49    contains `0' through `9' when going into an expression and `a' through
  50    `z' when going into a vector.  We assume here that only the first operand
  51    of an rtl expression is a vector.  genrecog.c makes the same assumption
  52    (and uses the same representation) and it is currently true.  */
  53
  54 struct extraction
  55 {
  56   int op_count;
  57   char *oplocs[MAX_RECOG_OPERANDS];
  58   int dup_count;
  59   char *duplocs[MAX_DUP_OPERANDS];
  60   int dupnums[MAX_DUP_OPERANDS];
  61   struct code_ptr *insns;
  62   struct extraction *next;
  63 };
  64
  65 /* Holds a single insn code that use an extraction method.  */
  66
  67 struct code_ptr
  68 {
  69   int insn_code;
  70   struct code_ptr *next;
  71 };
  72
  73 static struct extraction *extractions;
  74
  75 /* Number instruction patterns handled, starting at 0 for first one.  */
  76
  77 static int insn_code_number;
  78
  79 /* Records the large operand number in this insn.  */
  80
  81 static int op_count;
  82
  83 /* Records the location of any operands using the string format described
  84    above.  */
  85
  86 static char *oplocs[MAX_RECOG_OPERANDS];
  87
  88 /* Number the occurrences of MATCH_DUP in each instruction,
  89    starting at 0 for the first occurrence.  */
  90
  91 static int dup_count;
  92
  93 /* Records the location of any MATCH_DUP operands.  */
  94
  95 static char *duplocs[MAX_DUP_OPERANDS];
  96
  97 /* Record the operand number of any MATCH_DUPs.  */
  98
  99 static int dupnums[MAX_DUP_OPERANDS];
 100
 101 /* Record the list of insn_codes for peepholes.  */
 102
 103 static struct code_ptr *peepholes;
 104
 105 static void walk_rtx ();
 106 static void print_path ();
 107 char *xmalloc ();
 108 char *xrealloc ();
 109 static void fatal ();
 110 static char *copystr ();
 111 static void mybzero ();
 112 void fancy_abort ();
 113 \f
 114 static void
 115 gen_insn (insn)
 116      rtx insn;
 117 {
 118   register int i;
 119   register struct extraction *p;
 120   register struct code_ptr *link;
 121
 122   op_count = 0;
 123   dup_count = 0;
 124
 125   /* No operands seen so far in this pattern.  */
 126   mybzero (oplocs, sizeof oplocs);
 127
 128   /* Walk the insn's pattern, remembering at all times the path
 129      down to the walking point.  */
 130
 131   if (XVECLEN (insn, 1) == 1)
 132     walk_rtx (XVECEXP (insn, 1, 0), "");
 133   else
 134     for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
 135       {
 136         char *path = (char *) alloca (2);
 137
 138         path[0] = 'a' + i;
 139         path[1] = 0;
 140
 141         walk_rtx (XVECEXP (insn, 1, i), path);
 142       }
 143
 144   link = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
 145   link->insn_code = insn_code_number;
 146
 147   /* See if we find something that already had this extraction method.  */
 148
 149   for (p = extractions; p; p = p->next)
 150     {
 151       if (p->op_count != op_count || p->dup_count != dup_count)
 152         continue;
 153
 154       for (i = 0; i < op_count; i++)
 155         if (p->oplocs[i] != oplocs[i]
 156             && ! (p->oplocs[i] != 0 && oplocs[i] != 0
 157                   && ! strcmp (p->oplocs[i], oplocs[i])))
 158           break;
 159
 160       if (i != op_count)
 161         continue;
 162
 163       for (i = 0; i < dup_count; i++)
 164         if (p->dupnums[i] != dupnums[i]
 165             || strcmp (p->duplocs[i], duplocs[i]))
 166           break;
 167
 168       if (i != dup_count)
 169         continue;
 170
 171       /* This extraction is the same as ours.  Just link us in.  */
 172       link->next = p->insns;
 173       p->insns = link;
 174       return;
 175     }
 176
 177   /* Otherwise, make a new extraction method.  */
 178
 179   p = (struct extraction *) xmalloc (sizeof (struct extraction));
 180   p->op_count = op_count;
 181   p->dup_count = dup_count;
 182   p->next = extractions;
 183   extractions = p;
 184   p->insns = link;
 185   link->next = 0;
 186
 187   for (i = 0; i < op_count; i++)
 188     p->oplocs[i] = oplocs[i];
 189
 190   for (i = 0; i < dup_count; i++)
 191     p->dupnums[i] = dupnums[i], p->duplocs[i] = duplocs[i];
 192 }
 193 \f
 194 static void
 195 walk_rtx (x, path)
 196      rtx x;
 197      char *path;
 198 {
 199   register RTX_CODE code;
 200   register int i;
 201   register int len;
 202   register char *fmt;
 203   int depth = strlen (path);
 204   char *newpath;
 205
 206   if (x == 0)
 207     return;
 208
 209   code = GET_CODE (x);
 210
 211   switch (code)
 212     {
 213     case PC:
 214     case CC0:
 215     case CONST_INT:
 216     case SYMBOL_REF:
 217       return;
 218
 219     case MATCH_OPERAND:
 220     case MATCH_SCRATCH:
 221       oplocs[XINT (x, 0)] = copystr (path);
 222       op_count = MAX (op_count, XINT (x, 0) + 1);
 223       break;
 224
 225     case MATCH_DUP:
 226     case MATCH_PAR_DUP:
 227       duplocs[dup_count] = copystr (path);
 228       dupnums[dup_count] = XINT (x, 0);
 229       dup_count++;
 230       break;
 231
 232     case MATCH_OP_DUP:
 233       duplocs[dup_count] = copystr (path);
 234       dupnums[dup_count] = XINT (x, 0);
 235       dup_count++;
 236
 237       newpath = (char *) alloca (depth + 2);
 238       strcpy (newpath, path);
 239       newpath[depth + 1] = 0;
 240
 241       for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
 242         {
 243           newpath[depth] = '0' + i;
 244           walk_rtx (XVECEXP (x, 1, i), newpath);
 245         }
 246       return;
 247
 248     case MATCH_OPERATOR:
 249       oplocs[XINT (x, 0)] = copystr (path);
 250       op_count = MAX (op_count, XINT (x, 0) + 1);
 251
 252       newpath = (char *) alloca (depth + 2);
 253       strcpy (newpath, path);
 254       newpath[depth + 1] = 0;
 255
 256       for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
 257         {
 258           newpath[depth] = '0' + i;
 259           walk_rtx (XVECEXP (x, 2, i), newpath);
 260         }
 261       return;
 262
 263     case MATCH_PARALLEL:
 264       oplocs[XINT (x, 0)] = copystr (path);
 265       op_count = MAX (op_count, XINT (x, 0) + 1);
 266
 267       newpath = (char *) alloca (depth + 2);
 268       strcpy (newpath, path);
 269       newpath[depth + 1] = 0;
 270
 271       for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
 272         {
 273           newpath[depth] = 'a' + i;
 274           walk_rtx (XVECEXP (x, 2, i), newpath);
 275         }
 276       return;
 277
 278     case ADDRESS:
 279       walk_rtx (XEXP (x, 0), path);
 280       return;
 281
 282     default:
 283       break;
 284     }
 285
 286   newpath = (char *) alloca (depth + 2);
 287   strcpy (newpath, path);
 288   newpath[depth + 1] = 0;
 289
 290   fmt = GET_RTX_FORMAT (code);
 291   len = GET_RTX_LENGTH (code);
 292   for (i = 0; i < len; i++)
 293     {
 294       if (fmt[i] == 'e' || fmt[i] == 'u')
 295         {
 296           newpath[depth] = '0' + i;
 297           walk_rtx (XEXP (x, i), newpath);
 298         }
 299       else if (fmt[i] == 'E')
 300         {
 301           int j;
 302           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 303             {
 304               newpath[depth] = 'a' + j;
 305               walk_rtx (XVECEXP (x, i, j), newpath);
 306             }
 307         }
 308     }
 309 }
 310
 311 /* Given a PATH, representing a path down the instruction's
 312    pattern from the root to a certain point, output code to
 313    evaluate to the rtx at that point.  */
 314
 315 static void
 316 print_path (path)
 317      char *path;
 318 {
 319   register int len = strlen (path);
 320   register int i;
 321
 322   /* We first write out the operations (XEXP or XVECEXP) in reverse
 323      order, then write "insn", then the indices in forward order.  */
 324
 325   for (i = len - 1; i >=0 ; i--)
 326     {
 327       if (path[i] >= 'a' && path[i] <= 'z')
 328         printf ("XVECEXP (");
 329       else if (path[i] >= '0' && path[i] <= '9')
 330         printf ("XEXP (");
 331       else
 332         abort ();
 333     }
 334
 335   printf ("pat");
 336
 337   for (i = 0; i < len; i++)
 338     {
 339       if (path[i] >= 'a' && path[i] <= 'z')
 340         printf (", 0, %d)", path[i] - 'a');
 341       else if (path[i] >= '0' && path[i] <= '9')
 342         printf (", %d)", path[i] - '0');
 343       else
 344         abort ();
 345     }
 346 }
 347 \f
 348 char *
 349 xmalloc (size)
 350      unsigned size;
 351 {
 352   register char *val = (char *) malloc (size);
 353
 354   if (val == 0)
 355     fatal ("virtual memory exhausted");
 356   return val;
 357 }
 358
 359 char *
 360 xrealloc (ptr, size)
 361      char *ptr;
 362      unsigned size;
 363 {
 364   char *result = (char *) realloc (ptr, size);
 365   if (!result)
 366     fatal ("virtual memory exhausted");
 367   return result;
 368 }
 369
 370 static void
 371 fatal (s, a1, a2)
 372      char *s;
 373 {
 374   fprintf (stderr, "genextract: ");
 375   fprintf (stderr, s, a1, a2);
 376   fprintf (stderr, "\n");
 377   exit (FATAL_EXIT_CODE);
 378 }
 379
 380 /* More 'friendly' abort that prints the line and file.
 381    config.h can #define abort fancy_abort if you like that sort of thing.  */
 382
 383 void
 384 fancy_abort ()
 385 {
 386   fatal ("Internal gcc abort.");
 387 }
 388
 389 static char *
 390 copystr (s1)
 391      char *s1;
 392 {
 393   register char *tem;
 394
 395   if (s1 == 0)
 396     return 0;
 397
 398   tem = (char *) xmalloc (strlen (s1) + 1);
 399   strcpy (tem, s1);
 400
 401   return tem;
 402 }
 403
 404 static void
 405 mybzero (b, length)
 406      register char *b;
 407      register unsigned length;
 408 {
 409   while (length-- > 0)
 410     *b++ = 0;
 411 }
 412 \f
 413 int
 414 main (argc, argv)
 415      int argc;
 416      char **argv;
 417 {
 418   rtx desc;
 419   FILE *infile;
 420   register int c, i;
 421   struct extraction *p;
 422   struct code_ptr *link;
 423
 424   obstack_init (rtl_obstack);
 425
 426   if (argc <= 1)
 427     fatal ("No input file name.");
 428
 429   infile = fopen (argv[1], "r");
 430   if (infile == 0)
 431     {
 432       perror (argv[1]);
 433       exit (FATAL_EXIT_CODE);
 434     }
 435
 436   init_rtl ();
 437
 438   /* Assign sequential codes to all entries in the machine description
 439      in parallel with the tables in insn-output.c.  */
 440
 441   insn_code_number = 0;
 442
 443   printf ("/* Generated automatically by the program `genextract'\n\
 444 from the machine description file `md'.  */\n\n");
 445
 446   printf ("#include \"config.h\"\n");
 447   printf ("#include <stdio.h>\n");
 448   printf ("#include \"rtl.h\"\n\n");
 449
 450   /* This variable exists only so it can be the "location"
 451      of any missing operand whose numbers are skipped by a given pattern.  */
 452   printf ("static rtx junk;\n");
 453
 454   printf ("extern rtx recog_operand[];\n");
 455   printf ("extern rtx *recog_operand_loc[];\n");
 456   printf ("extern rtx *recog_dup_loc[];\n");
 457   printf ("extern char recog_dup_num[];\n");
 458
 459   printf ("void\ninsn_extract (insn)\n");
 460   printf ("     rtx insn;\n");
 461   printf ("{\n");
 462   printf ("  register rtx *ro = recog_operand;\n");
 463   printf ("  register rtx **ro_loc = recog_operand_loc;\n");
 464   printf ("  rtx pat = PATTERN (insn);\n");
 465   printf ("  int i;\n\n");
 466   printf ("  switch (INSN_CODE (insn))\n");
 467   printf ("    {\n");
 468   printf ("    case -1:\n");
 469   printf ("      fatal_insn_not_found (insn);\n\n");
 470
 471   /* Read the machine description.  */
 472
 473   while (1)
 474     {
 475       c = read_skip_spaces (infile);
 476       if (c == EOF)
 477         break;
 478       ungetc (c, infile);
 479
 480       desc = read_rtx (infile);
 481       if (GET_CODE (desc) == DEFINE_INSN)
 482         {
 483           gen_insn (desc);
 484           ++insn_code_number;
 485         }
 486
 487       else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
 488         {
 489           struct code_ptr *link
 490             = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
 491
 492           link->insn_code = insn_code_number;
 493           link->next = peepholes;
 494           peepholes = link;
 495           ++insn_code_number;
 496         }
 497
 498       else if (GET_CODE (desc) == DEFINE_EXPAND
 499                || GET_CODE (desc) == DEFINE_SPLIT)
 500         ++insn_code_number;
 501     }
 502
 503   /* Write out code to handle peepholes and the insn_codes that it should
 504      be called for.  */
 505   if (peepholes)
 506     {
 507       for (link = peepholes; link; link = link->next)
 508         printf ("    case %d:\n", link->insn_code);
 509
 510       /* The vector in the insn says how many operands it has.
 511          And all it contains are operands.  In fact, the vector was
 512          created just for the sake of this function.  */
 513       printf ("      for (i = XVECLEN (pat, 0); i >= 0; i--)\n");
 514       printf ("          ro[i] = XVECEXP (pat, 0, i);\n");
 515       printf ("      break;\n\n");
 516     }
 517
 518   /* Write out all the ways to extract insn operands.  */
 519   for (p = extractions; p; p = p->next)
 520     {
 521       for (link = p->insns; link; link = link->next)
 522         printf ("    case %d:\n", link->insn_code);
 523
 524       for (i = 0; i < p->op_count; i++)
 525         {
 526           if (p->oplocs[i] == 0)
 527             {
 528               printf ("      ro[%d] = const0_rtx;\n", i);
 529               printf ("      ro_loc[%d] = &junk;\n", i);
 530             }
 531           else
 532             {
 533               printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
 534               print_path (p->oplocs[i]);
 535               printf (");\n");
 536             }
 537         }
 538
 539       for (i = 0; i < p->dup_count; i++)
 540         {
 541           printf ("      recog_dup_loc[%d] = &", i);
 542           print_path (p->duplocs[i]);
 543           printf (";\n");
 544           printf ("      recog_dup_num[%d] = %d;\n", i, p->dupnums[i]);
 545         }
 546
 547       printf ("      break;\n\n");
 548     }
 549
 550   /* This should never be reached.  Note that we would also reach this abort
 551    if we tried to extract something whose INSN_CODE was a DEFINE_EXPAND or
 552    DEFINE_SPLIT, but that is correct.  */
 553   printf ("    default:\n      abort ();\n");
 554
 555   printf ("    }\n}\n");
 556
 557   fflush (stdout);
 558   exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 559   /* NOTREACHED */
 560   return 0;
 561 }