gcc/genopinit.c

   1 /* Generate code to initialize optabs from machine description.
   2    Copyright (C) 1993-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 "gensupport.h"
  28
  29
  30 #define DEF_RTL_EXPR(V, N, X, C) #V,
  31
  32 static const char * const rtx_upname[] = {
  33 #include "rtl.def"
  34 };
  35
  36 #undef DEF_RTL_EXPR
  37
  38
  39 /* The entries in optabs.def are categorized:
  40      C: A "conversion" optab, which uses two modes; has libcall data.
  41      N: A "normal" optab, which uses one mode; has libcall data.
  42      D: A "direct" optab, which uses one mode; does not have libcall data.
  43      V: An "oVerflow" optab.  Like N, but does not record its code in
  44         code_to_optab.
  45
  46      CX, NX, VX: An extra pattern entry for a conversion or normal optab.
  47
  48    These patterns may be present in the MD file with names that contain
  49    the mode(s) used and the name of the operation.  This array contains
  50    a list of optabs that need to be initialized.  Within each name,
  51    $a and $b are used to match a short mode name (the part of the mode
  52    name not including `mode' and converted to lower-case).
  53
  54    $I means that only full integer modes should be considered for the
  55    next mode, and $F means that only float modes should be considered.
  56    $P means that both full and partial integer modes should be considered.
  57    $Q means that only fixed-point modes should be considered.
  58
  59    The pattern may be NULL if the optab exists only for the libcalls
  60    that we plan to attach to it, and there are no named patterns in
  61    the md files.  */
  62
  63 #define OPTAB_CL(name, pat, c, b, l)            name,
  64 #define OPTAB_CX(name, pat)
  65 #define OPTAB_CD(name, pat)                     name,
  66 #define OPTAB_NL(name, pat, c, b, s, l)         name,
  67 #define OPTAB_NC(name, pat, c)                  name,
  68 #define OPTAB_NX(name, pat)
  69 #define OPTAB_VL(name, pat, c, b, s, l)         name,
  70 #define OPTAB_VC(name, pat, c)                  name,
  71 #define OPTAB_VX(name, pat)
  72 #define OPTAB_DC(name, pat, c)                  name,
  73 #define OPTAB_D(name, pat)                      name,
  74
  75 typedef enum optab_tag {
  76   unknown_optab,
  77 #include "optabs.def"
  78   NUM_OPTABS
  79 } optab;
  80
  81 #undef OPTAB_CL
  82 #undef OPTAB_CX
  83 #undef OPTAB_CD
  84 #undef OPTAB_NL
  85 #undef OPTAB_NC
  86 #undef OPTAB_NX
  87 #undef OPTAB_VL
  88 #undef OPTAB_VC
  89 #undef OPTAB_VX
  90 #undef OPTAB_DC
  91 #undef OPTAB_D
  92
  93 #define NS "NULL"
  94 #define ZS "'\\0'"
  95 #define OPTAB_CL(o, p, c, b, l)    { #o, p, #b, ZS, #l, o, c, UNKNOWN, 1 },
  96 #define OPTAB_CX(o, p) { #o, p, NULL, NULL, NULL, o, UNKNOWN, UNKNOWN, 1 },
  97 #define OPTAB_CD(o, p) { #o, p, NS, ZS, NS, o, UNKNOWN, UNKNOWN, 2 },
  98 #define OPTAB_NL(o, p, c, b, s, l) { #o, p, #b, #s, #l, o, c, c, 3 },
  99 #define OPTAB_NC(o, p, c)          { #o, p, NS, ZS, NS, o, c, c, 3 },
 100 #define OPTAB_NX(o, p) { #o, p, NULL, NULL, NULL, o, UNKNOWN, UNKNOWN, 3 },
 101 #define OPTAB_VL(o, p, c, b, s, l) { #o, p, #b, #s, #l, o, c, UNKNOWN, 3 },
 102 #define OPTAB_VC(o, p, c)          { #o, p, NS, ZS, NS, o, c, UNKNOWN, 3 },
 103 #define OPTAB_VX(o, p) { #o, p, NULL, NULL, NULL, o, UNKNOWN, UNKNOWN, 3 },
 104 #define OPTAB_DC(o, p, c)          { #o, p, NS, ZS, NS, o, c, c, 4 },
 105 #define OPTAB_D(o, p)  { #o, p, NS, ZS, NS, o, UNKNOWN, UNKNOWN, 4 },
 106
 107 struct optab_def
 108 {
 109   const char *name;
 110   const char *pattern;
 111   const char *base;
 112   const char *suffix;
 113   const char *libcall;
 114   unsigned int op;
 115   enum rtx_code fcode;
 116   enum rtx_code rcode;
 117   unsigned int kind;
 118 };
 119
 120 static optab_def optabs[] = {
 121   { "unknown_optab", NULL, NS, ZS, NS, unknown_optab, UNKNOWN, UNKNOWN, 0 },
 122 #include "optabs.def"
 123 };
 124
 125 #undef OPTAB_CL
 126 #undef OPTAB_CX
 127 #undef OPTAB_CD
 128 #undef OPTAB_NL
 129 #undef OPTAB_NC
 130 #undef OPTAB_NX
 131 #undef OPTAB_VL
 132 #undef OPTAB_VC
 133 #undef OPTAB_VX
 134 #undef OPTAB_DC
 135 #undef OPTAB_D
 136
 137 /* Vector in which to collect insns that match.  */
 138
 139 struct pattern
 140 {
 141   const char *name;
 142   unsigned int op;
 143   unsigned int m1, m2;
 144   unsigned int sort_num;
 145 };
 146
 147
 148 static vec<pattern> patterns;
 149
 150 static bool
 151 match_pattern (pattern *p, const char *name, const char *pat)
 152 {
 153   bool force_float = false;
 154   bool force_int = false;
 155   bool force_partial_int = false;
 156   bool force_fixed = false;
 157
 158   if (pat == NULL)
 159     return false;
 160   for (; ; ++pat)
 161     {
 162       if (*pat != '$')
 163         {
 164           if (*pat != *name++)
 165             return false;
 166           if (*pat == '\0')
 167             return true;
 168           continue;
 169         }
 170       switch (*++pat)
 171         {
 172         case 'I':
 173           force_int = 1;
 174           break;
 175         case 'P':
 176           force_partial_int = 1;
 177           break;
 178         case 'F':
 179           force_float = 1;
 180           break;
 181         case 'Q':
 182           force_fixed = 1;
 183           break;
 184
 185         case 'a':
 186         case 'b':
 187           {
 188             int i;
 189
 190             /* This loop will stop at the first prefix match, so
 191                look through the modes in reverse order, in case
 192                there are extra CC modes and CC is a prefix of the
 193                CC modes (as it should be).  */
 194             for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
 195               {
 196                 const char *p, *q;
 197                 for (p = GET_MODE_NAME (i), q = name; *p; p++, q++)
 198                   if (TOLOWER (*p) != *q)
 199                     break;
 200                 if (*p == 0
 201                     && (! force_int || mode_class[i] == MODE_INT
 202                         || mode_class[i] == MODE_VECTOR_INT)
 203                     && (! force_partial_int
 204                         || mode_class[i] == MODE_INT
 205                         || mode_class[i] == MODE_PARTIAL_INT
 206                         || mode_class[i] == MODE_VECTOR_INT)
 207                     && (! force_float
 208                         || mode_class[i] == MODE_FLOAT
 209                         || mode_class[i] == MODE_DECIMAL_FLOAT
 210                         || mode_class[i] == MODE_COMPLEX_FLOAT
 211                         || mode_class[i] == MODE_VECTOR_FLOAT)
 212                     && (! force_fixed
 213                         || mode_class[i] == MODE_FRACT
 214                         || mode_class[i] == MODE_UFRACT
 215                         || mode_class[i] == MODE_ACCUM
 216                         || mode_class[i] == MODE_UACCUM
 217                         || mode_class[i] == MODE_VECTOR_FRACT
 218                         || mode_class[i] == MODE_VECTOR_UFRACT
 219                         || mode_class[i] == MODE_VECTOR_ACCUM
 220                         || mode_class[i] == MODE_VECTOR_UACCUM))
 221                   break;
 222               }
 223
 224             if (i < 0)
 225               return false;
 226             name += strlen (GET_MODE_NAME (i));
 227             if (*pat == 'a')
 228               p->m1 = i;
 229             else
 230               p->m2 = i;
 231
 232             force_int = false;
 233             force_partial_int = false;
 234             force_float = false;
 235             force_fixed = false;
 236           }
 237           break;
 238
 239         default:
 240           gcc_unreachable ();
 241         }
 242     }
 243 }
 244
 245 static void
 246 gen_insn (md_rtx_info *info)
 247 {
 248   rtx insn = info->def;
 249   const char *name = XSTR (insn, 0);
 250   pattern p;
 251   unsigned pindex;
 252
 253   /* Don't mention "unnamed" instructions.  */
 254   if (*name == 0 || *name == '*')
 255     return;
 256   p.name = name;
 257
 258   /* See if NAME matches one of the patterns we have for the optabs
 259      we know about.  */
 260   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 261     {
 262       p.m1 = p.m2 = 0;
 263       if (match_pattern (&p, name, optabs[pindex].pattern))
 264         {
 265           p.op = optabs[pindex].op;
 266           p.sort_num = (p.op << 16) | (p.m2 << 8) | p.m1;
 267           patterns.safe_push (p);
 268           return;
 269         }
 270     }
 271 }
 272
 273 static int
 274 pattern_cmp (const void *va, const void *vb)
 275 {
 276   const pattern *a = (const pattern *)va;
 277   const pattern *b = (const pattern *)vb;
 278   return a->sort_num - b->sort_num;
 279 }
 280
 281 static int
 282 optab_kind_cmp (const void *va, const void *vb)
 283 {
 284   const optab_def *a = (const optab_def *)va;
 285   const optab_def *b = (const optab_def *)vb;
 286   int diff = a->kind - b->kind;
 287   if (diff == 0)
 288     diff = a->op - b->op;
 289   return diff;
 290 }
 291
 292 static int
 293 optab_rcode_cmp (const void *va, const void *vb)
 294 {
 295   const optab_def *a = (const optab_def *)va;
 296   const optab_def *b = (const optab_def *)vb;
 297   return a->rcode - b->rcode;
 298 }
 299
 300 static const char *header_file_name = "init-opinit.h";
 301 static const char *source_file_name = "init-opinit.c";
 302
 303 static bool
 304 handle_arg (const char *arg)
 305 {
 306   switch (arg[1])
 307     {
 308     case 'h':
 309       header_file_name = &arg[2];
 310       return true;
 311     case 'c':
 312       source_file_name = &arg[2];
 313       return true;
 314     default:
 315       return false;
 316     }
 317 }
 318
 319 static FILE *
 320 open_outfile (const char *file_name)
 321 {
 322   FILE *f = fopen (file_name, "w");
 323   if (!f)
 324     fatal ("cannot open file %s: %s", file_name, xstrerror (errno));
 325   fprintf (f,
 326            "/* Generated automatically by the program `genopinit'\n"
 327            "   from the machine description file `md'.  */\n\n");
 328   return f;
 329 }
 330
 331 int
 332 main (int argc, char **argv)
 333 {
 334   FILE *h_file, *s_file;
 335   unsigned int i, j, n, last_kind[5];
 336   pattern *p;
 337
 338   progname = "genopinit";
 339
 340   if (NUM_OPTABS > 0xffff || MAX_MACHINE_MODE >= 0xff)
 341     fatal ("genopinit range assumptions invalid");
 342
 343   if (!init_rtx_reader_args_cb (argc, argv, handle_arg))
 344     return (FATAL_EXIT_CODE);
 345
 346   h_file = open_outfile (header_file_name);
 347   s_file = open_outfile (source_file_name);
 348
 349   /* Read the machine description.  */
 350   md_rtx_info info;
 351   while (read_md_rtx (&info))
 352     switch (GET_CODE (info.def))
 353       {
 354       case DEFINE_INSN:
 355       case DEFINE_EXPAND:
 356         gen_insn (&info);
 357         break;
 358
 359       default:
 360         break;
 361       }
 362
 363   /* Sort the collected patterns.  */
 364   patterns.qsort (pattern_cmp);
 365
 366   /* Now that we've handled the "extra" patterns, eliminate them from
 367      the optabs array.  That way they don't get in the way below.  */
 368   n = ARRAY_SIZE (optabs);
 369   for (i = 0; i < n; )
 370     if (optabs[i].base == NULL)
 371       optabs[i] = optabs[--n];
 372     else
 373       ++i;
 374
 375   /* Sort the (real) optabs.  Better than forcing the optabs.def file to
 376      remain sorted by kind.  We also scrogged any real ordering with the
 377      purging of the X patterns above.  */
 378   qsort (optabs, n, sizeof (optab_def), optab_kind_cmp);
 379
 380   /* Emit the optab enumeration for the header file.  */
 381   fprintf (h_file, "enum optab_tag {\n");
 382   for (i = j = 0; i < n; ++i)
 383     {
 384       optabs[i].op = i;
 385       fprintf (h_file, "  %s,\n", optabs[i].name);
 386       if (optabs[i].kind != j)
 387         last_kind[j++] = i - 1;
 388     }
 389   fprintf (h_file, "  FIRST_CONV_OPTAB = %s,\n", optabs[last_kind[0]+1].name);
 390   fprintf (h_file, "  LAST_CONVLIB_OPTAB = %s,\n", optabs[last_kind[1]].name);
 391   fprintf (h_file, "  LAST_CONV_OPTAB = %s,\n", optabs[last_kind[2]].name);
 392   fprintf (h_file, "  FIRST_NORM_OPTAB = %s,\n", optabs[last_kind[2]+1].name);
 393   fprintf (h_file, "  LAST_NORMLIB_OPTAB = %s,\n", optabs[last_kind[3]].name);
 394   fprintf (h_file, "  LAST_NORM_OPTAB = %s\n", optabs[i-1].name);
 395   fprintf (h_file, "};\n\n");
 396
 397   fprintf (h_file, "#define NUM_OPTABS          %u\n", n);
 398   fprintf (h_file, "#define NUM_CONVLIB_OPTABS  %u\n",
 399            last_kind[1] - last_kind[0]);
 400   fprintf (h_file, "#define NUM_NORMLIB_OPTABS  %u\n",
 401            last_kind[3] - last_kind[2]);
 402   fprintf (h_file, "#define NUM_OPTAB_PATTERNS  %u\n",
 403            (unsigned) patterns.length ());
 404
 405   fprintf (h_file,
 406            "typedef enum optab_tag optab;\n"
 407            "typedef enum optab_tag convert_optab;\n"
 408            "typedef enum optab_tag direct_optab;\n"
 409            "\n"
 410            "struct optab_libcall_d\n"
 411            "{\n"
 412            "  char libcall_suffix;\n"
 413            "  const char *libcall_basename;\n"
 414            "  void (*libcall_gen) (optab, const char *name,\n"
 415            "                   char suffix, machine_mode);\n"
 416            "};\n"
 417            "\n"
 418            "struct convert_optab_libcall_d\n"
 419            "{\n"
 420            "  const char *libcall_basename;\n"
 421            "  void (*libcall_gen) (convert_optab, const char *name,\n"
 422            "                   machine_mode, machine_mode);\n"
 423            "};\n"
 424            "\n"
 425            "/* Given an enum insn_code, access the function to construct\n"
 426            "   the body of that kind of insn.  */\n"
 427            "#define GEN_FCN(CODE) (insn_data[CODE].genfun)\n"
 428            "\n"
 429            "/* Contains the optab used for each rtx code, and vice-versa.  */\n"
 430            "extern const optab code_to_optab_[NUM_RTX_CODE];\n"
 431            "extern const enum rtx_code optab_to_code_[NUM_OPTABS];\n"
 432            "\n"
 433            "static inline optab\n"
 434            "code_to_optab (enum rtx_code code)\n"
 435            "{\n"
 436            "  return code_to_optab_[code];\n"
 437            "}\n"
 438            "\n"
 439            "static inline enum rtx_code\n"
 440            "optab_to_code (optab op)\n"
 441            "{\n"
 442            "  return optab_to_code_[op];\n"
 443            "}\n"
 444            "\n"
 445            "extern const struct convert_optab_libcall_d convlib_def[NUM_CONVLIB_OPTABS];\n"
 446            "extern const struct optab_libcall_d normlib_def[NUM_NORMLIB_OPTABS];\n"
 447            "\n"
 448            "/* Returns the active icode for the given (encoded) optab.  */\n"
 449            "extern enum insn_code raw_optab_handler (unsigned);\n"
 450            "extern bool swap_optab_enable (optab, machine_mode, bool);\n"
 451            "\n"
 452            "/* Target-dependent globals.  */\n"
 453            "struct target_optabs {\n"
 454            "  /* Patterns that are used by optabs that are enabled for this target.  */\n"
 455            "  bool pat_enable[NUM_OPTAB_PATTERNS];\n"
 456            "};\n"
 457            "extern void init_all_optabs (struct target_optabs *);\n"
 458            "\n"
 459            "extern struct target_optabs default_target_optabs;\n"
 460            "extern struct target_optabs *this_fn_optabs;\n"
 461            "#if SWITCHABLE_TARGET\n"
 462            "extern struct target_optabs *this_target_optabs;\n"
 463            "#else\n"
 464            "#define this_target_optabs (&default_target_optabs)\n"
 465            "#endif\n");
 466
 467   fprintf (s_file,
 468            "#include \"config.h\"\n"
 469            "#include \"system.h\"\n"
 470            "#include \"coretypes.h\"\n"
 471            "#include \"backend.h\"\n"
 472            "#include \"predict.h\"\n"
 473            "#include \"tree.h\"\n"
 474            "#include \"rtl.h\"\n"
 475            "#include \"alias.h\"\n"
 476            "#include \"varasm.h\"\n"
 477            "#include \"stor-layout.h\"\n"
 478            "#include \"calls.h\"\n"
 479            "#include \"tm_p.h\"\n"
 480            "#include \"flags.h\"\n"
 481            "#include \"insn-config.h\"\n"
 482            "#include \"expmed.h\"\n"
 483            "#include \"dojump.h\"\n"
 484            "#include \"explow.h\"\n"
 485            "#include \"emit-rtl.h\"\n"
 486            "#include \"stmt.h\"\n"
 487            "#include \"expr.h\"\n"
 488            "#include \"insn-codes.h\"\n"
 489            "#include \"optabs.h\"\n"
 490            "\n"
 491            "struct optab_pat {\n"
 492            "  unsigned scode;\n"
 493            "  enum insn_code icode;\n"
 494            "};\n\n");
 495
 496   fprintf (s_file,
 497            "static const struct optab_pat pats[NUM_OPTAB_PATTERNS] = {\n");
 498   for (i = 0; patterns.iterate (i, &p); ++i)
 499     fprintf (s_file, "  { %#08x, CODE_FOR_%s },\n", p->sort_num, p->name);
 500   fprintf (s_file, "};\n\n");
 501
 502   fprintf (s_file, "void\ninit_all_optabs (struct target_optabs *optabs)\n{\n");
 503   fprintf (s_file, "  bool *ena = optabs->pat_enable;\n");
 504   for (i = 0; patterns.iterate (i, &p); ++i)
 505     fprintf (s_file, "  ena[%u] = HAVE_%s;\n", i, p->name);
 506   fprintf (s_file, "}\n\n");
 507
 508   /* Perform a binary search on a pre-encoded optab+mode*2.  */
 509   /* ??? Perhaps even better to generate a minimal perfect hash.
 510      Using gperf directly is awkward since it's so geared to working
 511      with strings.  Plus we have no visibility into the ordering of
 512      the hash entries, which complicates the pat_enable array.  */
 513   fprintf (s_file,
 514            "static int\n"
 515            "lookup_handler (unsigned scode)\n"
 516            "{\n"
 517            "  int l = 0, h = ARRAY_SIZE (pats), m;\n"
 518            "  while (h > l)\n"
 519            "    {\n"
 520            "      m = (h + l) / 2;\n"
 521            "      if (scode == pats[m].scode)\n"
 522            "        return m;\n"
 523            "      else if (scode < pats[m].scode)\n"
 524            "        h = m;\n"
 525            "      else\n"
 526            "        l = m + 1;\n"
 527            "    }\n"
 528            "  return -1;\n"
 529            "}\n\n");
 530
 531   fprintf (s_file,
 532            "enum insn_code\n"
 533            "raw_optab_handler (unsigned scode)\n"
 534            "{\n"
 535            "  int i = lookup_handler (scode);\n"
 536            "  return (i >= 0 && this_fn_optabs->pat_enable[i]\n"
 537            "          ? pats[i].icode : CODE_FOR_nothing);\n"
 538            "}\n\n");
 539
 540   fprintf (s_file,
 541            "bool\n"
 542            "swap_optab_enable (optab op, machine_mode m, bool set)\n"
 543            "{\n"
 544            "  unsigned scode = (op << 16) | m;\n"
 545            "  int i = lookup_handler (scode);\n"
 546            "  if (i >= 0)\n"
 547            "    {\n"
 548            "      bool ret = this_fn_optabs->pat_enable[i];\n"
 549            "      this_fn_optabs->pat_enable[i] = set;\n"
 550            "      return ret;\n"
 551            "    }\n"
 552            "  else\n"
 553            "    {\n"
 554            "      gcc_assert (!set);\n"
 555            "      return false;\n"
 556            "    }\n"
 557            "}\n\n");
 558
 559   /* C++ (even G++) does not support (non-trivial) designated initializers.
 560      To work around that, generate these arrays programatically rather than
 561      by our traditional multiple inclusion of def files.  */
 562
 563   fprintf (s_file,
 564            "const struct convert_optab_libcall_d "
 565            "convlib_def[NUM_CONVLIB_OPTABS] = {\n");
 566   for (i = last_kind[0] + 1; i <= last_kind[1]; ++i)
 567     fprintf (s_file, "  { %s, %s },\n", optabs[i].base, optabs[i].libcall);
 568   fprintf (s_file, "};\n\n");
 569
 570   fprintf (s_file,
 571            "const struct optab_libcall_d "
 572            "normlib_def[NUM_NORMLIB_OPTABS] = {\n");
 573   for (i = last_kind[2] + 1; i <= last_kind[3]; ++i)
 574     fprintf (s_file, "  { %s, %s, %s },\n",
 575              optabs[i].suffix, optabs[i].base, optabs[i].libcall);
 576   fprintf (s_file, "};\n\n");
 577
 578   fprintf (s_file, "enum rtx_code const optab_to_code_[NUM_OPTABS] = {\n");
 579   for (i = 0; i < n; ++i)
 580     fprintf (s_file, "  %s,\n", rtx_upname[optabs[i].fcode]);
 581   fprintf (s_file, "};\n\n");
 582
 583   qsort (optabs, n, sizeof (optab_def), optab_rcode_cmp);
 584
 585   fprintf (s_file, "const optab code_to_optab_[NUM_RTX_CODE] = {\n");
 586   for (j = 0; optabs[j].rcode == UNKNOWN; ++j)
 587     continue;
 588   for (i = 0; i < NON_GENERATOR_NUM_RTX_CODE; ++i)
 589     {
 590       if (j < n && optabs[j].rcode == i)
 591         fprintf (s_file, "  %s,\n", optabs[j++].name);
 592       else
 593         fprintf (s_file, "  unknown_optab,\n");
 594     }
 595   fprintf (s_file, "};\n\n");
 596
 597   return (fclose (h_file) == 0 && fclose (s_file) == 0
 598           ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE);
 599 }