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, 1999, 2000, 2003
   3    Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22
  23 #include "bconfig.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "errors.h"
  29 #include "insn-config.h"
  30 #include "gensupport.h"
  31
  32
  33 /* This structure contains all the information needed to describe one
  34    set of extractions methods.  Each method may be used by more than
  35    one pattern if the operands are in the same place.
  36
  37    The string for each operand describes that path to the operand and
  38    contains `0' through `9' when going into an expression and `a' through
  39    `z' when going into a vector.  We assume here that only the first operand
  40    of an rtl expression is a vector.  genrecog.c makes the same assumption
  41    (and uses the same representation) and it is currently true.  */
  42
  43 struct extraction
  44 {
  45   int op_count;
  46   char *oplocs[MAX_RECOG_OPERANDS];
  47   int dup_count;
  48   char *duplocs[MAX_DUP_OPERANDS];
  49   int dupnums[MAX_DUP_OPERANDS];
  50   struct code_ptr *insns;
  51   struct extraction *next;
  52 };
  53
  54 /* Holds a single insn code that use an extraction method.  */
  55
  56 struct code_ptr
  57 {
  58   int insn_code;
  59   struct code_ptr *next;
  60 };
  61
  62 static struct extraction *extractions;
  63
  64 /* Holds an array of names indexed by insn_code_number.  */
  65 static char **insn_name_ptr = 0;
  66 static int insn_name_ptr_size = 0;
  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 (rtx);
  99 static void walk_rtx (rtx, const char *);
 100 static void print_path (const char *);
 101 static void record_insn_name (int, const char *);
 102
 103 static void
 104 gen_insn (rtx insn)
 105 {
 106   int i;
 107   struct extraction *p;
 108   struct code_ptr *link;
 109
 110   op_count = 0;
 111   dup_count = 0;
 112
 113   /* No operands seen so far in this pattern.  */
 114   memset (oplocs, 0, sizeof oplocs);
 115
 116   /* Walk the insn's pattern, remembering at all times the path
 117      down to the walking point.  */
 118
 119   if (XVECLEN (insn, 1) == 1)
 120     walk_rtx (XVECEXP (insn, 1, 0), "");
 121   else
 122     for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
 123       {
 124         char path[2];
 125
 126         path[0] = 'a' + i;
 127         path[1] = 0;
 128
 129         walk_rtx (XVECEXP (insn, 1, i), path);
 130       }
 131
 132   link = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
 133   link->insn_code = insn_code_number;
 134
 135   /* See if we find something that already had this extraction method.  */
 136
 137   for (p = extractions; p; p = p->next)
 138     {
 139       if (p->op_count != op_count || p->dup_count != dup_count)
 140         continue;
 141
 142       for (i = 0; i < op_count; i++)
 143         if (p->oplocs[i] != oplocs[i]
 144             && ! (p->oplocs[i] != 0 && oplocs[i] != 0
 145                   && ! strcmp (p->oplocs[i], oplocs[i])))
 146           break;
 147
 148       if (i != op_count)
 149         continue;
 150
 151       for (i = 0; i < dup_count; i++)
 152         if (p->dupnums[i] != dupnums[i]
 153             || strcmp (p->duplocs[i], duplocs[i]))
 154           break;
 155
 156       if (i != dup_count)
 157         continue;
 158
 159       /* This extraction is the same as ours.  Just link us in.  */
 160       link->next = p->insns;
 161       p->insns = link;
 162       return;
 163     }
 164
 165   /* Otherwise, make a new extraction method.  */
 166
 167   p = (struct extraction *) xmalloc (sizeof (struct extraction));
 168   p->op_count = op_count;
 169   p->dup_count = dup_count;
 170   p->next = extractions;
 171   extractions = p;
 172   p->insns = link;
 173   link->next = 0;
 174
 175   for (i = 0; i < op_count; i++)
 176     p->oplocs[i] = oplocs[i];
 177
 178   for (i = 0; i < dup_count; i++)
 179     p->dupnums[i] = dupnums[i], p->duplocs[i] = duplocs[i];
 180 }
 181 \f
 182 static void
 183 walk_rtx (rtx x, const char *path)
 184 {
 185   RTX_CODE code;
 186   int i;
 187   int len;
 188   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       duplocs[dup_count] = xstrdup (path);
 213       dupnums[dup_count] = XINT (x, 0);
 214       dup_count++;
 215       break;
 216
 217     case MATCH_PAR_DUP:
 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 *) xmalloc (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] = (code == MATCH_OP_DUP ? '0' : 'a') + i;
 230           walk_rtx (XVECEXP (x, 1, i), newpath);
 231         }
 232       free (newpath);
 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 *) xmalloc (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       free (newpath);
 249       return;
 250
 251     case MATCH_PARALLEL:
 252       oplocs[XINT (x, 0)] = xstrdup (path);
 253       op_count = MAX (op_count, XINT (x, 0) + 1);
 254
 255       newpath = (char *) xmalloc (depth + 2);
 256       strcpy (newpath, path);
 257       newpath[depth + 1] = 0;
 258
 259       for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
 260         {
 261           newpath[depth] = 'a' + i;
 262           walk_rtx (XVECEXP (x, 2, i), newpath);
 263         }
 264       free (newpath);
 265       return;
 266
 267     case ADDRESS:
 268       walk_rtx (XEXP (x, 0), path);
 269       return;
 270
 271     default:
 272       break;
 273     }
 274
 275   newpath = (char *) xmalloc (depth + 2);
 276   strcpy (newpath, path);
 277   newpath[depth + 1] = 0;
 278
 279   fmt = GET_RTX_FORMAT (code);
 280   len = GET_RTX_LENGTH (code);
 281   for (i = 0; i < len; i++)
 282     {
 283       if (fmt[i] == 'e' || fmt[i] == 'u')
 284         {
 285           newpath[depth] = '0' + i;
 286           walk_rtx (XEXP (x, i), newpath);
 287         }
 288       else if (fmt[i] == 'E')
 289         {
 290           int j;
 291           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 292             {
 293               newpath[depth] = 'a' + j;
 294               walk_rtx (XVECEXP (x, i, j), newpath);
 295             }
 296         }
 297     }
 298   free (newpath);
 299 }
 300
 301 /* Given a PATH, representing a path down the instruction's
 302    pattern from the root to a certain point, output code to
 303    evaluate to the rtx at that point.  */
 304
 305 static void
 306 print_path (const char *path)
 307 {
 308   int len = strlen (path);
 309   int i;
 310
 311   if (len == 0)
 312     {
 313       /* Don't emit "pat", since we may try to take the address of it,
 314          which isn't what is intended.  */
 315       printf("PATTERN (insn)");
 316       return;
 317     }
 318
 319   /* We first write out the operations (XEXP or XVECEXP) in reverse
 320      order, then write "insn", then the indices in forward order.  */
 321
 322   for (i = len - 1; i >= 0 ; i--)
 323     {
 324       if (ISLOWER(path[i]))
 325         printf ("XVECEXP (");
 326       else if (ISDIGIT(path[i]))
 327         printf ("XEXP (");
 328       else
 329         abort ();
 330     }
 331
 332   printf ("pat");
 333
 334   for (i = 0; i < len; i++)
 335     {
 336       if (ISLOWER(path[i]))
 337         printf (", 0, %d)", path[i] - 'a');
 338       else if (ISDIGIT(path[i]))
 339         printf (", %d)", path[i] - '0');
 340       else
 341         abort ();
 342     }
 343 }
 344 \f
 345
 346 int
 347 main (int argc, char **argv)
 348 {
 349   rtx desc;
 350   int i;
 351   struct extraction *p;
 352   struct code_ptr *link;
 353   const char *name;
 354
 355   progname = "genextract";
 356
 357   if (argc <= 1)
 358     fatal ("no input file name");
 359
 360   if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
 361     return (FATAL_EXIT_CODE);
 362
 363   /* Assign sequential codes to all entries in the machine description
 364      in parallel with the tables in insn-output.c.  */
 365
 366   insn_code_number = 0;
 367
 368   printf ("/* Generated automatically by the program `genextract'\n\
 369 from the machine description file `md'.  */\n\n");
 370
 371   printf ("#include \"config.h\"\n");
 372   printf ("#include \"system.h\"\n");
 373   printf ("#include \"coretypes.h\"\n");
 374   printf ("#include \"tm.h\"\n");
 375   printf ("#include \"rtl.h\"\n");
 376   printf ("#include \"insn-config.h\"\n");
 377   printf ("#include \"recog.h\"\n");
 378   printf ("#include \"toplev.h\"\n\n");
 379
 380   /* This variable exists only so it can be the "location"
 381      of any missing operand whose numbers are skipped by a given pattern.  */
 382   printf ("static rtx junk ATTRIBUTE_UNUSED;\n");
 383
 384   printf ("void\ninsn_extract (rtx insn)\n");
 385   printf ("{\n");
 386   printf ("  rtx *ro = recog_data.operand;\n");
 387   printf ("  rtx **ro_loc = recog_data.operand_loc;\n");
 388   printf ("  rtx pat = PATTERN (insn);\n");
 389   printf ("  int i ATTRIBUTE_UNUSED;\n\n");
 390   printf ("  memset (ro, 0, sizeof (*ro) * MAX_RECOG_OPERANDS);\n");
 391   printf ("  memset (ro_loc, 0, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n");
 392   printf ("  switch (INSN_CODE (insn))\n");
 393   printf ("    {\n");
 394   printf ("    case -1:\n");
 395   printf ("      fatal_insn_not_found (insn);\n\n");
 396
 397   /* Read the machine description.  */
 398
 399   while (1)
 400     {
 401       int line_no;
 402
 403       desc = read_md_rtx (&line_no, &insn_code_number);
 404       if (desc == NULL)
 405         break;
 406
 407        if (GET_CODE (desc) == DEFINE_INSN)
 408         {
 409           record_insn_name (insn_code_number, XSTR (desc, 0));
 410           gen_insn (desc);
 411         }
 412
 413       else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
 414         {
 415           struct code_ptr *link
 416             = (struct code_ptr *) xmalloc (sizeof (struct code_ptr));
 417
 418           link->insn_code = insn_code_number;
 419           link->next = peepholes;
 420           peepholes = link;
 421         }
 422     }
 423
 424   /* Write out code to handle peepholes and the insn_codes that it should
 425      be called for.  */
 426   if (peepholes)
 427     {
 428       for (link = peepholes; link; link = link->next)
 429         printf ("    case %d:\n", link->insn_code);
 430
 431       /* The vector in the insn says how many operands it has.
 432          And all it contains are operands.  In fact, the vector was
 433          created just for the sake of this function.  We need to set the
 434          location of the operands for sake of simplifications after
 435          extraction, like eliminating subregs.  */
 436       printf ("      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n");
 437       printf ("          ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n");
 438       printf ("      break;\n\n");
 439     }
 440
 441   /* Write out all the ways to extract insn operands.  */
 442   for (p = extractions; p; p = p->next)
 443     {
 444       for (link = p->insns; link; link = link->next)
 445         {
 446           i = link->insn_code;
 447           name = get_insn_name (i);
 448           if (name)
 449             printf ("    case %d:  /* %s */\n", i, name);
 450           else
 451             printf ("    case %d:\n", i);
 452         }
 453
 454       for (i = 0; i < p->op_count; i++)
 455         {
 456           if (p->oplocs[i] == 0)
 457             {
 458               printf ("      ro[%d] = const0_rtx;\n", i);
 459               printf ("      ro_loc[%d] = &junk;\n", i);
 460             }
 461           else
 462             {
 463               printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
 464               print_path (p->oplocs[i]);
 465               printf (");\n");
 466             }
 467         }
 468
 469       for (i = 0; i < p->dup_count; i++)
 470         {
 471           printf ("      recog_data.dup_loc[%d] = &", i);
 472           print_path (p->duplocs[i]);
 473           printf (";\n");
 474           printf ("      recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
 475         }
 476
 477       printf ("      break;\n\n");
 478     }
 479
 480   /* This should never be reached.  Note that we would also reach this abort
 481    if we tried to extract something whose INSN_CODE was a DEFINE_EXPAND or
 482    DEFINE_SPLIT, but that is correct.  */
 483   printf ("    default:\n      abort ();\n");
 484
 485   printf ("    }\n}\n");
 486
 487   fflush (stdout);
 488   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 489 }
 490
 491 /* Define this so we can link with print-rtl.o to get debug_rtx function.  */
 492 const char *
 493 get_insn_name (code)
 494      int code ATTRIBUTE_UNUSED;
 495 {
 496   if (code < insn_name_ptr_size)
 497     return insn_name_ptr[code];
 498   else
 499     return NULL;
 500 }
 501
 502 static void
 503 record_insn_name (code, name)
 504      int code;
 505      const char *name;
 506 {
 507   static const char *last_real_name = "insn";
 508   static int last_real_code = 0;
 509   char *new;
 510
 511   if (insn_name_ptr_size <= code)
 512     {
 513       int new_size;
 514       new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
 515       insn_name_ptr =
 516         (char **) xrealloc (insn_name_ptr, sizeof(char *) * new_size);
 517       memset (insn_name_ptr + insn_name_ptr_size, 0,
 518               sizeof(char *) * (new_size - insn_name_ptr_size));
 519       insn_name_ptr_size = new_size;
 520     }
 521
 522   if (!name || name[0] == '\0')
 523     {
 524       new = xmalloc (strlen (last_real_name) + 10);
 525       sprintf (new, "%s+%d", last_real_name, code - last_real_code);
 526     }
 527   else
 528     {
 529       last_real_name = new = xstrdup (name);
 530       last_real_code = code;
 531     }
 532
 533   insn_name_ptr[code] = new;
 534 }