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