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 PVPROTO ((char *, ...)) ATTRIBUTE_PRINTF_1;
 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   if (len == 0)
 317     {
 318       /* Don't emit "pat", since we may try to take the address of it,
 319          which isn't what is intended.  */
 320       printf("PATTERN (insn)");
 321       return;
 322     }
 323
 324   /* We first write out the operations (XEXP or XVECEXP) in reverse
 325      order, then write "insn", then the indices in forward order.  */
 326
 327   for (i = len - 1; i >=0 ; i--)
 328     {
 329       if (path[i] >= 'a' && path[i] <= 'z')
 330         printf ("XVECEXP (");
 331       else if (path[i] >= '0' && path[i] <= '9')
 332         printf ("XEXP (");
 333       else
 334         abort ();
 335     }
 336
 337   printf ("pat");
 338
 339   for (i = 0; i < len; i++)
 340     {
 341       if (path[i] >= 'a' && path[i] <= 'z')
 342         printf (", 0, %d)", path[i] - 'a');
 343       else if (path[i] >= '0' && path[i] <= '9')
 344         printf (", %d)", path[i] - '0');
 345       else
 346         abort ();
 347     }
 348 }
 349 \f
 350 char *
 351 xmalloc (size)
 352      unsigned size;
 353 {
 354   register char *val = (char *) malloc (size);
 355
 356   if (val == 0)
 357     fatal ("virtual memory exhausted");
 358   return val;
 359 }
 360
 361 char *
 362 xrealloc (ptr, size)
 363      char *ptr;
 364      unsigned size;
 365 {
 366   char *result = (char *) realloc (ptr, size);
 367   if (!result)
 368     fatal ("virtual memory exhausted");
 369   return result;
 370 }
 371
 372 static void
 373 fatal VPROTO ((char *format, ...))
 374 {
 375 #ifndef __STDC__
 376   char *format;
 377 #endif
 378   va_list ap;
 379
 380   VA_START (ap, format);
 381
 382 #ifndef __STDC__
 383   format = va_arg (ap, char *);
 384 #endif
 385
 386   fprintf (stderr, "genextract: ");
 387   vfprintf (stderr, format, ap);
 388   va_end (ap);
 389   fprintf (stderr, "\n");
 390   exit (FATAL_EXIT_CODE);
 391 }
 392
 393 /* More 'friendly' abort that prints the line and file.
 394    config.h can #define abort fancy_abort if you like that sort of thing.  */
 395
 396 void
 397 fancy_abort ()
 398 {
 399   fatal ("Internal gcc abort.");
 400 }
 401
 402 static char *
 403 copystr (s1)
 404      char *s1;
 405 {
 406   register char *tem;
 407
 408   if (s1 == 0)
 409     return 0;
 410
 411   tem = (char *) xmalloc (strlen (s1) + 1);
 412   strcpy (tem, s1);
 413
 414   return tem;
 415 }
 416
 417 static void
 418 mybzero (b, length)
 419      register char *b;
 420      register unsigned length;
 421 {
 422   while (length-- > 0)
 423     *b++ = 0;
 424 }
 425 \f
 426 int
 427 main (argc, argv)
 428      int argc;
 429      char **argv;
 430 {
 431   rtx desc;
 432   FILE *infile;
 433   register int c, i;
 434   struct extraction *p;
 435   struct code_ptr *link;
 436
 437   obstack_init (rtl_obstack);
 438
 439   if (argc <= 1)
 440     fatal ("No input file name.");
 441
 442   infile = fopen (argv[1], "r");
 443   if (infile == 0)
 444     {
 445       perror (argv[1]);
 446       exit (FATAL_EXIT_CODE);
 447     }
 448
 449   init_rtl ();
 450
 451   /* Assign sequential codes to all entries in the machine description
 452      in parallel with the tables in insn-output.c.  */
 453
 454   insn_code_number = 0;
 455
 456   printf ("/* Generated automatically by the program `genextract'\n\
 457 from the machine description file `md'.  */\n\n");
 458
 459   printf ("#include \"config.h\"\n");
 460   printf ("#include \"system.h\"\n");
 461   printf ("#include \"rtl.h\"\n\n");
 462
 463   /* This variable exists only so it can be the "location"
 464      of any missing operand whose numbers are skipped by a given pattern.  */
 465   printf ("static rtx junk ATTRIBUTE_UNUSED;\n");
 466
 467   printf ("extern rtx recog_operand[];\n");
 468   printf ("extern rtx *recog_operand_loc[];\n");
 469   printf ("extern rtx *recog_dup_loc[];\n");
 470   printf ("extern char recog_dup_num[];\n");
 471
 472   printf ("void\ninsn_extract (insn)\n");
 473   printf ("     rtx insn;\n");
 474   printf ("{\n");
 475   printf ("  register rtx *ro = recog_operand;\n");
 476   printf ("  register rtx **ro_loc = recog_operand_loc;\n");
 477   printf ("  rtx pat = PATTERN (insn);\n");
 478   printf ("  int i ATTRIBUTE_UNUSED;\n\n");
 479   printf ("  switch (INSN_CODE (insn))\n");
 480   printf ("    {\n");
 481   printf ("    case -1:\n");
 482   printf ("      fatal_insn_not_found (insn);\n\n");
 483
 484   /* Read the machine description.  */
 485
 486   while (1)
 487     {
 488       c = read_skip_spaces (infile);
 489       if (c == EOF)
 490         break;
 491       ungetc (c, infile);
 492
 493       desc = read_rtx (infile);
 494       if (GET_CODE (desc) == DEFINE_INSN)
 495         {
 496           gen_insn (desc);
 497           ++insn_code_number;
 498         }
 499
 500       else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
 501         {
 502           struct code_ptr *link
 503             = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
 504
 505           link->insn_code = insn_code_number;
 506           link->next = peepholes;
 507           peepholes = link;
 508           ++insn_code_number;
 509         }
 510
 511       else if (GET_CODE (desc) == DEFINE_EXPAND
 512                || GET_CODE (desc) == DEFINE_SPLIT)
 513         ++insn_code_number;
 514     }
 515
 516   /* Write out code to handle peepholes and the insn_codes that it should
 517      be called for.  */
 518   if (peepholes)
 519     {
 520       for (link = peepholes; link; link = link->next)
 521         printf ("    case %d:\n", link->insn_code);
 522
 523       /* The vector in the insn says how many operands it has.
 524          And all it contains are operands.  In fact, the vector was
 525          created just for the sake of this function.  */
 526       printf ("      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n");
 527       printf ("          ro[i] = XVECEXP (pat, 0, i);\n");
 528       printf ("      break;\n\n");
 529     }
 530
 531   /* Write out all the ways to extract insn operands.  */
 532   for (p = extractions; p; p = p->next)
 533     {
 534       for (link = p->insns; link; link = link->next)
 535         printf ("    case %d:\n", link->insn_code);
 536
 537       for (i = 0; i < p->op_count; i++)
 538         {
 539           if (p->oplocs[i] == 0)
 540             {
 541               printf ("      ro[%d] = const0_rtx;\n", i);
 542               printf ("      ro_loc[%d] = &junk;\n", i);
 543             }
 544           else
 545             {
 546               printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
 547               print_path (p->oplocs[i]);
 548               printf (");\n");
 549             }
 550         }
 551
 552       for (i = 0; i < p->dup_count; i++)
 553         {
 554           printf ("      recog_dup_loc[%d] = &", i);
 555           print_path (p->duplocs[i]);
 556           printf (";\n");
 557           printf ("      recog_dup_num[%d] = %d;\n", i, p->dupnums[i]);
 558         }
 559
 560       printf ("      break;\n\n");
 561     }
 562
 563   /* This should never be reached.  Note that we would also reach this abort
 564    if we tried to extract something whose INSN_CODE was a DEFINE_EXPAND or
 565    DEFINE_SPLIT, but that is correct.  */
 566   printf ("    default:\n      abort ();\n");
 567
 568   printf ("    }\n}\n");
 569
 570   fflush (stdout);
 571   exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 572   /* NOTREACHED */
 573   return 0;
 574 }