contrib/gcc-5.0/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 #include "vec.h"
  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 typedef char *locstr;
  42
  43 struct extraction
  44 {
  45   unsigned int op_count;
  46   unsigned int dup_count;
  47   locstr *oplocs;
  48   locstr *duplocs;
  49   int *dupnums;
  50   struct code_ptr *insns;
  51   struct extraction *next;
  52 };
  53
  54 /* Holds a single insn code that uses an extraction method.  */
  55 struct code_ptr
  56 {
  57   int insn_code;
  58   struct code_ptr *next;
  59 };
  60
  61 /* All extractions needed for this machine description.  */
  62 static struct extraction *extractions;
  63
  64 /* All insn codes for old-style peepholes.  */
  65 static struct code_ptr *peepholes;
  66
  67 /* This structure is used by gen_insn and walk_rtx to accumulate the
  68    data that will be used to produce an extractions structure.  */
  69
  70
  71 struct accum_extract
  72 {
  73   vec<locstr> oplocs;
  74   vec<locstr> duplocs;
  75   vec<int> dupnums;
  76   vec<char> pathstr;
  77 };
  78
  79 int line_no;
  80
  81 /* Forward declarations.  */
  82 static void walk_rtx (rtx, struct accum_extract *);
  83
  84 static void
  85 gen_insn (rtx insn, int insn_code_number)
  86 {
  87   int i;
  88   unsigned int op_count, dup_count, j;
  89   struct extraction *p;
  90   struct code_ptr *link;
  91   struct accum_extract acc;
  92
  93   acc.oplocs.create (10);
  94   acc.duplocs.create (10);
  95   acc.dupnums.create (10);
  96   acc.pathstr.create (20);
  97
  98   /* Walk the insn's pattern, remembering at all times the path
  99      down to the walking point.  */
 100
 101   if (XVECLEN (insn, 1) == 1)
 102     walk_rtx (XVECEXP (insn, 1, 0), &acc);
 103   else
 104     for (i = XVECLEN (insn, 1) - 1; i >= 0; i--)
 105       {
 106         acc.pathstr.safe_push ('a' + i);
 107         walk_rtx (XVECEXP (insn, 1, i), &acc);
 108         acc.pathstr.pop ();
 109       }
 110
 111   link = XNEW (struct code_ptr);
 112   link->insn_code = insn_code_number;
 113
 114   /* See if we find something that already had this extraction method.  */
 115
 116   op_count = acc.oplocs.length ();
 117   dup_count = acc.duplocs.length ();
 118   gcc_assert (dup_count == acc.dupnums.length ());
 119
 120   for (p = extractions; p; p = p->next)
 121     {
 122       if (p->op_count != op_count || p->dup_count != dup_count)
 123         continue;
 124
 125       for (j = 0; j < op_count; j++)
 126         {
 127           char *a = p->oplocs[j];
 128           char *b = acc.oplocs[j];
 129           if (a != b && (!a || !b || strcmp (a, b)))
 130             break;
 131         }
 132
 133       if (j != op_count)
 134         continue;
 135
 136       for (j = 0; j < dup_count; j++)
 137         if (p->dupnums[j] != acc.dupnums[j]
 138             || strcmp (p->duplocs[j], acc.duplocs[j]))
 139           break;
 140
 141       if (j != dup_count)
 142         continue;
 143
 144       /* This extraction is the same as ours.  Just link us in.  */
 145       link->next = p->insns;
 146       p->insns = link;
 147       goto done;
 148     }
 149
 150   /* Otherwise, make a new extraction method.  We stash the arrays
 151      after the extraction structure in memory.  */
 152
 153   p = XNEWVAR (struct extraction, sizeof (struct extraction)
 154                + op_count*sizeof (char *)
 155                + dup_count*sizeof (char *)
 156                + dup_count*sizeof (int));
 157   p->op_count = op_count;
 158   p->dup_count = dup_count;
 159   p->next = extractions;
 160   extractions = p;
 161   p->insns = link;
 162   link->next = 0;
 163
 164   p->oplocs = (char **)((char *)p + sizeof (struct extraction));
 165   p->duplocs = p->oplocs + op_count;
 166   p->dupnums = (int *)(p->duplocs + dup_count);
 167
 168   memcpy (p->oplocs, acc.oplocs.address (), op_count * sizeof (locstr));
 169   memcpy (p->duplocs, acc.duplocs.address (), dup_count * sizeof (locstr));
 170   memcpy (p->dupnums, acc.dupnums.address (), dup_count * sizeof (int));
 171
 172  done:
 173   acc.oplocs.release ();
 174   acc.duplocs.release ();
 175   acc.dupnums.release ();
 176   acc.pathstr.release ();
 177 }
 178 \f
 179 /* Helper subroutine of walk_rtx: given a vec<locstr>, an index, and a
 180    string, insert the string at the index, which should either already
 181    exist and be NULL, or not yet exist within the vector.  In the latter
 182    case the vector is enlarged as appropriate.  */
 183 static void
 184 VEC_safe_set_locstr (vec<locstr> *vp, unsigned int ix, char *str)
 185 {
 186   if (ix < (*vp).length ())
 187     {
 188       if ((*vp)[ix])
 189         {
 190           message_with_line (line_no, "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 (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 (&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 (&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 (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 (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 (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 (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   rtx desc;
 399   unsigned int i;
 400   struct extraction *p;
 401   struct code_ptr *link;
 402   const char *name;
 403   int insn_code_number;
 404
 405   progname = "genextract";
 406
 407   if (!init_rtx_reader_args (argc, argv))
 408     return (FATAL_EXIT_CODE);
 409
 410   /* Read the machine description.  */
 411
 412   while ((desc = read_md_rtx (&line_no, &insn_code_number)) != NULL)
 413     {
 414        if (GET_CODE (desc) == DEFINE_INSN)
 415          gen_insn (desc, insn_code_number);
 416
 417       else if (GET_CODE (desc) == DEFINE_PEEPHOLE)
 418         {
 419           struct code_ptr *link = XNEW (struct code_ptr);
 420
 421           link->insn_code = insn_code_number;
 422           link->next = peepholes;
 423           peepholes = link;
 424         }
 425     }
 426
 427   if (have_error)
 428     return FATAL_EXIT_CODE;
 429
 430   print_header ();
 431
 432   /* Write out code to handle peepholes and the insn_codes that it should
 433      be called for.  */
 434   if (peepholes)
 435     {
 436       for (link = peepholes; link; link = link->next)
 437         printf ("    case %d:\n", link->insn_code);
 438
 439       /* The vector in the insn says how many operands it has.
 440          And all it contains are operands.  In fact, the vector was
 441          created just for the sake of this function.  We need to set the
 442          location of the operands for sake of simplifications after
 443          extraction, like eliminating subregs.  */
 444       puts ("      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
 445             "          ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
 446             "      break;\n");
 447     }
 448
 449   /* Write out all the ways to extract insn operands.  */
 450   for (p = extractions; p; p = p->next)
 451     {
 452       for (link = p->insns; link; link = link->next)
 453         {
 454           i = link->insn_code;
 455           name = get_insn_name (i);
 456           if (name)
 457             printf ("    case %d:  /* %s */\n", i, name);
 458           else
 459             printf ("    case %d:\n", i);
 460         }
 461
 462       for (i = 0; i < p->op_count; i++)
 463         {
 464           if (p->oplocs[i] == 0)
 465             {
 466               printf ("      ro[%d] = const0_rtx;\n", i);
 467               printf ("      ro_loc[%d] = &junk;\n", i);
 468             }
 469           else
 470             {
 471               printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
 472               print_path (p->oplocs[i]);
 473               puts (");");
 474             }
 475         }
 476
 477       for (i = 0; i < p->dup_count; i++)
 478         {
 479           printf ("      recog_data.dup_loc[%d] = &", i);
 480           print_path (p->duplocs[i]);
 481           puts (";");
 482           printf ("      recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
 483         }
 484
 485       puts ("      break;\n");
 486     }
 487
 488   puts ("    }\n}");
 489   fflush (stdout);
 490   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 491 }