gcc/genextract.c

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