gcc/genextract.c

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