contrib/gcc-8.0/gcc/genextract.c

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