gcc/genextract.c

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