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, 2007, 2008
   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 3, 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 COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  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 "read-md.h"
  30 #include "gensupport.h"
  31 #include "vec.h"
  32 #include "vecprim.h"
  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 typedef char *locstr;
  45
  46 struct extraction
  47 {
  48   unsigned int op_count;
  49   unsigned int dup_count;
  50   locstr *oplocs;
  51   locstr *duplocs;
  52   int *dupnums;
  53   struct code_ptr *insns;
  54   struct extraction *next;
  55 };
  56
  57 /* Holds a single insn code that uses an extraction method.  */
  58 struct code_ptr
  59 {
  60   int insn_code;
  61   struct code_ptr *next;
  62 };
  63
  64 /* All extractions needed for this machine description.  */
  65 static struct extraction *extractions;
  66
  67 /* All insn codes for old-style peepholes.  */
  68 static struct code_ptr *peepholes;
  69
  70 /* This structure is used by gen_insn and walk_rtx to accumulate the
  71    data that will be used to produce an extractions structure.  */
  72
  73 DEF_VEC_P(locstr);
  74 DEF_VEC_ALLOC_P(locstr,heap);
  75
  76 struct accum_extract
  77 {
  78   VEC(locstr,heap) *oplocs;
  79   VEC(locstr,heap) *duplocs;
  80   VEC(int,heap)    *dupnums;
  81   VEC(char,heap)   *pathstr;
  82 };
  83
  84 int line_no;
  85
  86 /* Forward declarations.  */
  87 static void walk_rtx (rtx, struct accum_extract *);
  88
  89 static void
  90 gen_insn (rtx insn, int insn_code_number)
  91 {
  92   int i;
  93   unsigned int op_count, dup_count, j;
  94   struct extraction *p;
  95   struct code_ptr *link;
  96   struct accum_extract acc;
  97
  98   acc.oplocs  = VEC_alloc (locstr,heap, 10);
  99   acc.duplocs = VEC_alloc (locstr,heap, 10);
 100   acc.dupnums = VEC_alloc (int,heap,    10);
 101   acc.pathstr = VEC_alloc (char,heap,   20);
 102
 103   /* Walk the insn's pattern, remembering at all times the path
 104      down to the walking point.  */
 105
 106   if (XVECLEN (insn, 1) == 1)
 107     walk_rtx (XVECEXP (insn, 1, 0), &acc);
 108   else
 109     for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
 110       {
 111         VEC_safe_push (char,heap, acc.pathstr, 'a' + i);
 112         walk_rtx (XVECEXP (insn, 1, i), &acc);
 113         VEC_pop (char, acc.pathstr);
 114       }
 115
 116   link = XNEW (struct code_ptr);
 117   link->insn_code = insn_code_number;
 118
 119   /* See if we find something that already had this extraction method.  */
 120
 121   op_count = VEC_length (locstr, acc.oplocs);
 122   dup_count = VEC_length (locstr, acc.duplocs);
 123   gcc_assert (dup_count == VEC_length (int, acc.dupnums));
 124
 125   for (p = extractions; p; p = p->next)
 126     {
 127       if (p->op_count != op_count || p->dup_count != dup_count)
 128         continue;
 129
 130       for (j = 0; j < op_count; j++)
 131         {
 132           char *a = p->oplocs[j];
 133           char *b = VEC_index (locstr, acc.oplocs, j);
 134           if (a != b && (!a || !b || strcmp (a, b)))
 135             break;
 136         }
 137
 138       if (j != op_count)
 139         continue;
 140
 141       for (j = 0; j < dup_count; j++)
 142         if (p->dupnums[j] != VEC_index (int, acc.dupnums, j)
 143             || strcmp (p->duplocs[j], VEC_index (locstr, acc.duplocs, j)))
 144           break;
 145
 146       if (j != dup_count)
 147         continue;
 148
 149       /* This extraction is the same as ours.  Just link us in.  */
 150       link->next = p->insns;
 151       p->insns = link;
 152       goto done;
 153     }
 154
 155   /* Otherwise, make a new extraction method.  We stash the arrays
 156      after the extraction structure in memory.  */
 157
 158   p = XNEWVAR (struct extraction, sizeof (struct extraction)
 159                + op_count*sizeof (char *)
 160                + dup_count*sizeof (char *)
 161                + dup_count*sizeof (int));
 162   p->op_count = op_count;
 163   p->dup_count = dup_count;
 164   p->next = extractions;
 165   extractions = p;
 166   p->insns = link;
 167   link->next = 0;
 168
 169   p->oplocs = (char **)((char *)p + sizeof (struct extraction));
 170   p->duplocs = p->oplocs + op_count;
 171   p->dupnums = (int *)(p->duplocs + dup_count);
 172
 173   memcpy(p->oplocs,  VEC_address(locstr,acc.oplocs),   op_count*sizeof(locstr));
 174   memcpy(p->duplocs, VEC_address(locstr,acc.duplocs), dup_count*sizeof(locstr));
 175   memcpy(p->dupnums, VEC_address(int,   acc.dupnums), dup_count*sizeof(int));
 176
 177  done:
 178   VEC_free (locstr,heap, acc.oplocs);
 179   VEC_free (locstr,heap, acc.duplocs);
 180   VEC_free (int,heap,    acc.dupnums);
 181   VEC_free (char,heap,   acc.pathstr);
 182 }
 183 \f
 184 /* Helper subroutine of walk_rtx: given a VEC(locstr), an index, and a
 185    string, insert the string at the index, which should either already
 186    exist and be NULL, or not yet exist within the vector.  In the latter
 187    case the vector is enlarged as appropriate.  */
 188 static void
 189 VEC_safe_set_locstr (VEC(locstr,heap) **vp, unsigned int ix, char *str)
 190 {
 191   if (ix < VEC_length (locstr, *vp))
 192     {
 193       if (VEC_index (locstr, *vp, ix))
 194         {
 195           message_with_line (line_no, "repeated operand number %d", ix);
 196           have_error = 1;
 197         }
 198       else
 199         VEC_replace (locstr, *vp, ix, str);
 200     }
 201   else
 202     {
 203       while (ix > VEC_length (locstr, *vp))
 204         VEC_safe_push (locstr, heap, *vp, 0);
 205       VEC_safe_push (locstr, heap, *vp, str);
 206     }
 207 }
 208
 209 /* Another helper subroutine of walk_rtx: given a VEC(char), convert it
 210    to a NUL-terminated string in malloc memory.  */
 211 static char *
 212 VEC_char_to_string (VEC(char,heap) *v)
 213 {
 214   size_t n = VEC_length (char, v);
 215   char *s = XNEWVEC (char, n + 1);
 216   memcpy (s, VEC_address (char, v), n);
 217   s[n] = '\0';
 218   return s;
 219 }
 220
 221 static void
 222 walk_rtx (rtx x, struct accum_extract *acc)
 223 {
 224   RTX_CODE code;
 225   int i, len, base;
 226   const char *fmt;
 227
 228   if (x == 0)
 229     return;
 230
 231   code = GET_CODE (x);
 232   switch (code)
 233     {
 234     case PC:
 235     case CC0:
 236     case CONST_INT:
 237     case SYMBOL_REF:
 238       return;
 239
 240     case MATCH_OPERAND:
 241     case MATCH_SCRATCH:
 242       VEC_safe_set_locstr (&acc->oplocs, XINT (x, 0),
 243                            VEC_char_to_string (acc->pathstr));
 244       break;
 245
 246     case MATCH_OPERATOR:
 247     case MATCH_PARALLEL:
 248       VEC_safe_set_locstr (&acc->oplocs, XINT (x, 0),
 249                            VEC_char_to_string (acc->pathstr));
 250
 251       base = (code == MATCH_OPERATOR ? '0' : 'a');
 252       for (i = XVECLEN (x, 2) - 1; i >= 0; i--)
 253         {
 254           VEC_safe_push (char,heap, acc->pathstr, base + i);
 255           walk_rtx (XVECEXP (x, 2, i), acc);
 256           VEC_pop (char, acc->pathstr);
 257         }
 258       return;
 259
 260     case MATCH_DUP:
 261     case MATCH_PAR_DUP:
 262     case MATCH_OP_DUP:
 263       VEC_safe_push (locstr,heap, acc->duplocs,
 264                      VEC_char_to_string (acc->pathstr));
 265       VEC_safe_push (int,heap, acc->dupnums, XINT (x, 0));
 266
 267       if (code == MATCH_DUP)
 268         break;
 269
 270       base = (code == MATCH_OP_DUP ? '0' : 'a');
 271       for (i = XVECLEN (x, 1) - 1; i >= 0; i--)
 272         {
 273           VEC_safe_push (char,heap, acc->pathstr, base + i);
 274           walk_rtx (XVECEXP (x, 1, i), acc);
 275           VEC_pop (char, acc->pathstr);
 276         }
 277       return;
 278
 279     default:
 280       break;
 281     }
 282
 283   fmt = GET_RTX_FORMAT (code);
 284   len = GET_RTX_LENGTH (code);
 285   for (i = 0; i < len; i++)
 286     {
 287       if (fmt[i] == 'e' || fmt[i] == 'u')
 288         {
 289           VEC_safe_push (char,heap, acc->pathstr, '0' + i);
 290           walk_rtx (XEXP (x, i), acc);
 291           VEC_pop (char, acc->pathstr);
 292         }
 293       else if (fmt[i] == 'E')
 294         {
 295           int j;
 296           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 297             {
 298               VEC_safe_push (char,heap, acc->pathstr, 'a' + j);
 299               walk_rtx (XVECEXP (x, i, j), acc);
 300               VEC_pop (char, acc->pathstr);
 301             }
 302         }
 303     }
 304 }
 305
 306 /* Given a PATH, representing a path down the instruction's
 307    pattern from the root to a certain point, output code to
 308    evaluate to the rtx at that point.  */
 309
 310 static void
 311 print_path (const char *path)
 312 {
 313   int len = strlen (path);
 314   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       fputs ("PATTERN (insn)", stdout);
 321       return;
 322     }
 323
 324   /* We first write out the operations (XEXP or XVECEXP) in reverse
 325      order, then write "pat", then the indices in forward order.  */
 326
 327   for (i = len - 1; i >= 0 ; i--)
 328     {
 329       if (ISLOWER (path[i]))
 330         fputs ("XVECEXP (", stdout);
 331       else if (ISDIGIT (path[i]))
 332         fputs ("XEXP (", stdout);
 333       else
 334         gcc_unreachable ();
 335     }
 336
 337   fputs ("pat", stdout);
 338
 339   for (i = 0; i < len; i++)
 340     {
 341       if (ISLOWER (path[i]))
 342         printf (", 0, %d)", path[i] - 'a');
 343       else if (ISDIGIT(path[i]))
 344         printf (", %d)", path[i] - '0');
 345       else
 346         gcc_unreachable ();
 347     }
 348 }
 349 \f
 350 static void
 351 print_header (void)
 352 {
 353   /* N.B. Code below avoids putting squiggle braces in column 1 inside
 354      a string, because this confuses some editors' syntax highlighting
 355      engines.  */
 356
 357   puts ("\
 358 /* Generated automatically by the program `genextract'\n\
 359    from the machine description file `md'.  */\n\
 360 \n\
 361 #include \"config.h\"\n\
 362 #include \"system.h\"\n\
 363 #include \"coretypes.h\"\n\
 364 #include \"tm.h\"\n\
 365 #include \"rtl.h\"\n\
 366 #include \"insn-config.h\"\n\
 367 #include \"recog.h\"\n\
 368 #include \"diagnostic-core.h\"\n\
 369 #include \"toplev.h\"\n\
 370 \n\
 371 /* This variable is used as the \"location\" of any missing operand\n\
 372    whose numbers are skipped by a given pattern.  */\n\
 373 static rtx junk ATTRIBUTE_UNUSED;\n");
 374
 375   puts ("\
 376 void\n\
 377 insn_extract (rtx insn)\n{\n\
 378   rtx *ro = recog_data.operand;\n\
 379   rtx **ro_loc = recog_data.operand_loc;\n\
 380   rtx pat = PATTERN (insn);\n\
 381   int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
 382 \n\
 383 #ifdef ENABLE_CHECKING\n\
 384   memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
 385   memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
 386 #endif\n");
 387
 388   puts ("\
 389   switch (INSN_CODE (insn))\n\
 390     {\n\
 391     default:\n\
 392       /* Control reaches here if insn_extract has been called with an\n\
 393          unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
 394          corresponds to a DEFINE_EXPAND in the machine description;\n\
 395          either way, a bug.  */\n\
 396       if (INSN_CODE (insn) < 0)\n\
 397         fatal_insn (\"unrecognizable insn:\", insn);\n\
 398       else\n\
 399         fatal_insn (\"insn with invalid code number:\", insn);\n");
 400 }
 401
 402 int
 403 main (int argc, char **argv)
 404 {
 405   rtx desc;
 406   unsigned int i;
 407   struct extraction *p;
 408   struct code_ptr *link;
 409   const char *name;
 410   int insn_code_number;
 411
 412   progname = "genextract";
 413
 414   if (!init_rtx_reader_args (argc, argv))
 415     return (FATAL_EXIT_CODE);
 416
 417   /* Read the machine description.  */
 418
 419   while ((desc = read_md_rtx (&line_no, &insn_code_number)) != NULL)
 420     {
 421        if (GET_CODE (desc) == DEFINE_INSN)
 422          gen_insn (desc, insn_code_number);
 423
 424       else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
 425         {
 426           struct code_ptr *link = XNEW (struct code_ptr);
 427
 428           link->insn_code = insn_code_number;
 429           link->next = peepholes;
 430           peepholes = link;
 431         }
 432     }
 433
 434   if (have_error)
 435     return FATAL_EXIT_CODE;
 436
 437   print_header ();
 438
 439   /* Write out code to handle peepholes and the insn_codes that it should
 440      be called for.  */
 441   if (peepholes)
 442     {
 443       for (link = peepholes; link; link = link->next)
 444         printf ("    case %d:\n", link->insn_code);
 445
 446       /* The vector in the insn says how many operands it has.
 447          And all it contains are operands.  In fact, the vector was
 448          created just for the sake of this function.  We need to set the
 449          location of the operands for sake of simplifications after
 450          extraction, like eliminating subregs.  */
 451       puts ("      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
 452             "          ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
 453             "      break;\n");
 454     }
 455
 456   /* Write out all the ways to extract insn operands.  */
 457   for (p = extractions; p; p = p->next)
 458     {
 459       for (link = p->insns; link; link = link->next)
 460         {
 461           i = link->insn_code;
 462           name = get_insn_name (i);
 463           if (name)
 464             printf ("    case %d:  /* %s */\n", i, name);
 465           else
 466             printf ("    case %d:\n", i);
 467         }
 468
 469       for (i = 0; i < p->op_count; i++)
 470         {
 471           if (p->oplocs[i] == 0)
 472             {
 473               printf ("      ro[%d] = const0_rtx;\n", i);
 474               printf ("      ro_loc[%d] = &junk;\n", i);
 475             }
 476           else
 477             {
 478               printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
 479               print_path (p->oplocs[i]);
 480               puts (");");
 481             }
 482         }
 483
 484       for (i = 0; i < p->dup_count; i++)
 485         {
 486           printf ("      recog_data.dup_loc[%d] = &", i);
 487           print_path (p->duplocs[i]);
 488           puts (";");
 489           printf ("      recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
 490         }
 491
 492       puts ("      break;\n");
 493     }
 494
 495   puts ("    }\n}");
 496   fflush (stdout);
 497   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 498 }