gcc/genextract.c

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