gcc/genextract.c

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