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 #undef ENABLE_RTL_CHECKING\n\
 369 #undef ENABLE_RTL_FLAG_CHECKING\n\
 370 #include \"coretypes.h\"\n\
 371 #include \"tm.h\"\n\
 372 #include \"rtl.h\"\n\
 373 #include \"insn-config.h\"\n\
 374 #include \"recog.h\"\n\
 375 #include \"diagnostic-core.h\"\n\
 376 \n\
 377 /* This variable is used as the \"location\" of any missing operand\n\
 378    whose numbers are skipped by a given pattern.  */\n\
 379 static rtx junk ATTRIBUTE_UNUSED;\n");
 380
 381   puts ("\
 382 void\n\
 383 insn_extract (rtx_insn *insn)\n{\n\
 384   rtx *ro = recog_data.operand;\n\
 385   rtx **ro_loc = recog_data.operand_loc;\n\
 386   rtx pat = PATTERN (insn);\n\
 387   int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
 388 \n\
 389   if (flag_checking)\n\
 390     {\n\
 391       memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
 392       memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
 393     }\n");
 394
 395   puts ("\
 396   switch (INSN_CODE (insn))\n\
 397     {\n\
 398     default:\n\
 399       /* Control reaches here if insn_extract has been called with an\n\
 400          unrecognizable insn (code -1), or an insn whose INSN_CODE\n\
 401          corresponds to a DEFINE_EXPAND in the machine description;\n\
 402          either way, a bug.  */\n\
 403       if (INSN_CODE (insn) < 0)\n\
 404         fatal_insn (\"unrecognizable insn:\", insn);\n\
 405       else\n\
 406         fatal_insn (\"insn with invalid code number:\", insn);\n");
 407 }
 408
 409 int
 410 main (int argc, const char **argv)
 411 {
 412   unsigned int i;
 413   struct extraction *p;
 414   struct code_ptr *link;
 415   const char *name;
 416
 417   progname = "genextract";
 418
 419   if (!init_rtx_reader_args (argc, argv))
 420     return (FATAL_EXIT_CODE);
 421
 422   /* Read the machine description.  */
 423
 424   md_rtx_info info;
 425   while (read_md_rtx (&info))
 426     switch (GET_CODE (info.def))
 427       {
 428       case DEFINE_INSN:
 429         gen_insn (&info);
 430         break;
 431
 432       case DEFINE_PEEPHOLE:
 433         {
 434           struct code_ptr *link = XNEW (struct code_ptr);
 435
 436           link->insn_code = info.index;
 437           link->next = peepholes;
 438           peepholes = link;
 439         }
 440         break;
 441
 442       default:
 443         break;
 444     }
 445
 446   if (have_error)
 447     return FATAL_EXIT_CODE;
 448
 449   print_header ();
 450
 451   /* Write out code to handle peepholes and the insn_codes that it should
 452      be called for.  */
 453   if (peepholes)
 454     {
 455       for (link = peepholes; link; link = link->next)
 456         printf ("    case %d:\n", link->insn_code);
 457
 458       /* The vector in the insn says how many operands it has.
 459          And all it contains are operands.  In fact, the vector was
 460          created just for the sake of this function.  We need to set the
 461          location of the operands for sake of simplifications after
 462          extraction, like eliminating subregs.  */
 463       puts ("      for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)\n"
 464             "          ro[i] = *(ro_loc[i] = &XVECEXP (pat, 0, i));\n"
 465             "      break;\n");
 466     }
 467
 468   /* Write out all the ways to extract insn operands.  */
 469   for (p = extractions; p; p = p->next)
 470     {
 471       for (link = p->insns; link; link = link->next)
 472         {
 473           i = link->insn_code;
 474           name = get_insn_name (i);
 475           if (name)
 476             printf ("    case %d:  /* %s */\n", i, name);
 477           else
 478             printf ("    case %d:\n", i);
 479         }
 480
 481       for (i = 0; i < p->op_count; i++)
 482         {
 483           if (p->oplocs[i] == 0)
 484             {
 485               printf ("      ro[%d] = const0_rtx;\n", i);
 486               printf ("      ro_loc[%d] = &junk;\n", i);
 487             }
 488           else
 489             {
 490               printf ("      ro[%d] = *(ro_loc[%d] = &", i, i);
 491               print_path (p->oplocs[i]);
 492               puts (");");
 493             }
 494         }
 495
 496       for (i = 0; i < p->dup_count; i++)
 497         {
 498           printf ("      recog_data.dup_loc[%d] = &", i);
 499           print_path (p->duplocs[i]);
 500           puts (";");
 501           printf ("      recog_data.dup_num[%d] = %d;\n", i, p->dupnums[i]);
 502         }
 503
 504       puts ("      break;\n");
 505     }
 506
 507   puts ("    }\n}");
 508   fflush (stdout);
 509   return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
 510 }