gcc/genopinit.c

   1 /* Generate code to initialize optabs from machine description.
   2    Copyright (C) 1993-2013 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 typedef struct optab_def_d
 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 } optab_def;
 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 typedef struct pattern_d
 140 {
 141   const char *name;
 142   unsigned int op;
 143   unsigned int m1, m2;
 144   unsigned int sort_num;
 145 } pattern;
 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 (rtx insn)
 247 {
 248   const char *name = XSTR (insn, 0);
 249   pattern p;
 250   unsigned pindex;
 251
 252   /* Don't mention "unnamed" instructions.  */
 253   if (*name == 0 || *name == '*')
 254     return;
 255   p.name = name;
 256
 257   /* See if NAME matches one of the patterns we have for the optabs
 258      we know about.  */
 259   for (pindex = 0; pindex < ARRAY_SIZE (optabs); pindex++)
 260     {
 261       p.m1 = p.m2 = 0;
 262       if (match_pattern (&p, name, optabs[pindex].pattern))
 263         {
 264           p.op = optabs[pindex].op;
 265           p.sort_num = (p.op << 16) | (p.m2 << 8) | p.m1;
 266           patterns.safe_push (p);
 267           return;
 268         }
 269     }
 270 }
 271
 272 static int
 273 pattern_cmp (const void *va, const void *vb)
 274 {
 275   const pattern *a = (const pattern *)va;
 276   const pattern *b = (const pattern *)vb;
 277   return a->sort_num - b->sort_num;
 278 }
 279
 280 static int
 281 optab_kind_cmp (const void *va, const void *vb)
 282 {
 283   const optab_def *a = (const optab_def *)va;
 284   const optab_def *b = (const optab_def *)vb;
 285   int diff = a->kind - b->kind;
 286   if (diff == 0)
 287     diff = a->op - b->op;
 288   return diff;
 289 }
 290
 291 static int
 292 optab_rcode_cmp (const void *va, const void *vb)
 293 {
 294   const optab_def *a = (const optab_def *)va;
 295   const optab_def *b = (const optab_def *)vb;
 296   return a->rcode - b->rcode;
 297 }
 298
 299 static const char *header_file_name = "init-opinit.h";
 300 static const char *source_file_name = "init-opinit.c";
 301
 302 static bool
 303 handle_arg (const char *arg)
 304 {
 305   switch (arg[1])
 306     {
 307     case 'h':
 308       header_file_name = &arg[2];
 309       return true;
 310     case 'c':
 311       source_file_name = &arg[2];
 312       return true;
 313     default:
 314       return false;
 315     }
 316 }
 317
 318 static FILE *
 319 open_outfile (const char *file_name)
 320 {
 321   FILE *f = fopen (file_name, "w");
 322   if (!f)
 323     fatal ("cannot open file %s: %s", file_name, xstrerror (errno));
 324   fprintf (f,
 325            "/* Generated automatically by the program `genopinit'\n"
 326            "   from the machine description file `md'.  */\n\n");
 327   return f;
 328 }
 329
 330 int
 331 main (int argc, char **argv)
 332 {
 333   FILE *h_file, *s_file;
 334   unsigned int i, j, n, last_kind[5];
 335   pattern *p;
 336
 337   progname = "genopinit";
 338
 339   if (NUM_OPTABS > 0xffff || MAX_MACHINE_MODE >= 0xff)
 340     fatal ("genopinit range assumptions invalid");
 341
 342   if (!init_rtx_reader_args_cb (argc, argv, handle_arg))
 343     return (FATAL_EXIT_CODE);
 344
 345   h_file = open_outfile (header_file_name);
 346   s_file = open_outfile (source_file_name);
 347
 348   /* Read the machine description.  */
 349   while (1)
 350     {
 351       int line_no, insn_code_number = 0;
 352       rtx desc = read_md_rtx (&line_no, &insn_code_number);
 353       if (desc == NULL)
 354         break;
 355       if (GET_CODE (desc) == DEFINE_INSN || GET_CODE (desc) == DEFINE_EXPAND)
 356         gen_insn (desc);
 357     }
 358
 359   /* Sort the collected patterns.  */
 360   qsort (patterns.address (), patterns.length (),
 361          sizeof (pattern), pattern_cmp);
 362
 363   /* Now that we've handled the "extra" patterns, eliminate them from
 364      the optabs array.  That way they don't get in the way below.  */
 365   n = ARRAY_SIZE (optabs);
 366   for (i = 0; i < n; )
 367     if (optabs[i].base == NULL)
 368       optabs[i] = optabs[--n];
 369     else
 370       ++i;
 371
 372   /* Sort the (real) optabs.  Better than forcing the optabs.def file to
 373      remain sorted by kind.  We also scrogged any real ordering with the
 374      purging of the X patterns above.  */
 375   qsort (optabs, n, sizeof(optab_def), optab_kind_cmp);
 376
 377   /* Emit the optab enumeration for the header file.  */
 378   fprintf (h_file, "enum optab_tag {\n");
 379   for (i = j = 0; i < n; ++i)
 380     {
 381       optabs[i].op = i;
 382       fprintf (h_file, "  %s,\n", optabs[i].name);
 383       if (optabs[i].kind != j)
 384         last_kind[j++] = i - 1;
 385     }
 386   fprintf (h_file, "  FIRST_CONV_OPTAB = %s,\n", optabs[last_kind[0]+1].name);
 387   fprintf (h_file, "  LAST_CONVLIB_OPTAB = %s,\n", optabs[last_kind[1]].name);
 388   fprintf (h_file, "  LAST_CONV_OPTAB = %s,\n", optabs[last_kind[2]].name);
 389   fprintf (h_file, "  FIRST_NORM_OPTAB = %s,\n", optabs[last_kind[2]+1].name);
 390   fprintf (h_file, "  LAST_NORMLIB_OPTAB = %s,\n", optabs[last_kind[3]].name);
 391   fprintf (h_file, "  LAST_NORM_OPTAB = %s\n", optabs[i-1].name);
 392   fprintf (h_file, "};\n\n");
 393
 394   fprintf (h_file, "#define NUM_OPTABS          %u\n", n);
 395   fprintf (h_file, "#define NUM_CONVLIB_OPTABS  %u\n",
 396            last_kind[1] - last_kind[0]);
 397   fprintf (h_file, "#define NUM_NORMLIB_OPTABS  %u\n",
 398            last_kind[3] - last_kind[2]);
 399   fprintf (h_file, "#define NUM_OPTAB_PATTERNS  %u\n",
 400            (unsigned) patterns.length ());
 401
 402   fprintf (s_file,
 403            "#include \"config.h\"\n"
 404            "#include \"system.h\"\n"
 405            "#include \"coretypes.h\"\n"
 406            "#include \"tm.h\"\n"
 407            "#include \"rtl.h\"\n"
 408            "#include \"tm_p.h\"\n"
 409            "#include \"flags.h\"\n"
 410            "#include \"insn-config.h\"\n"
 411            "#include \"expr.h\"\n"
 412            "#include \"optabs.h\"\n"
 413            "\n"
 414            "struct optab_pat {\n"
 415            "  unsigned scode;\n"
 416            "  enum insn_code icode;\n"
 417            "};\n\n");
 418
 419   fprintf (s_file,
 420            "static const struct optab_pat pats[NUM_OPTAB_PATTERNS] = {\n");
 421   for (i = 0; patterns.iterate (i, &p); ++i)
 422     fprintf (s_file, "  { %#08x, CODE_FOR_%s },\n", p->sort_num, p->name);
 423   fprintf (s_file, "};\n\n");
 424
 425   fprintf (s_file, "void\ninit_all_optabs (void)\n{\n");
 426   fprintf (s_file, "  bool *ena = this_target_optabs->pat_enable;\n");
 427   for (i = 0; patterns.iterate (i, &p); ++i)
 428     fprintf (s_file, "  ena[%u] = HAVE_%s;\n", i, p->name);
 429   fprintf (s_file, "}\n\n");
 430
 431   /* Perform a binary search on a pre-encoded optab+mode*2.  */
 432   /* ??? Perhaps even better to generate a minimal perfect hash.
 433      Using gperf directly is awkward since it's so geared to working
 434      with strings.  Plus we have no visibility into the ordering of
 435      the hash entries, which complicates the pat_enable array.  */
 436   fprintf (s_file,
 437            "static int\n"
 438            "lookup_handler (unsigned scode)\n"
 439            "{\n"
 440            "  int l = 0, h = ARRAY_SIZE (pats), m;\n"
 441            "  while (h > l)\n"
 442            "    {\n"
 443            "      m = (h + l) / 2;\n"
 444            "      if (scode == pats[m].scode)\n"
 445            "        return m;\n"
 446            "      else if (scode < pats[m].scode)\n"
 447            "        h = m;\n"
 448            "      else\n"
 449            "        l = m + 1;\n"
 450            "    }\n"
 451            "  return -1;\n"
 452            "}\n\n");
 453
 454   fprintf (s_file,
 455            "enum insn_code\n"
 456            "raw_optab_handler (unsigned scode)\n"
 457            "{\n"
 458            "  int i = lookup_handler (scode);\n"
 459            "  return (i >= 0 && this_target_optabs->pat_enable[i]\n"
 460            "          ? pats[i].icode : CODE_FOR_nothing);\n"
 461            "}\n\n");
 462
 463   fprintf (s_file,
 464            "bool\n"
 465            "swap_optab_enable (optab op, enum machine_mode m, bool set)\n"
 466            "{\n"
 467            "  unsigned scode = (op << 16) | m;\n"
 468            "  int i = lookup_handler (scode);\n"
 469            "  if (i >= 0)\n"
 470            "    {\n"
 471            "      bool ret = this_target_optabs->pat_enable[i];\n"
 472            "      this_target_optabs->pat_enable[i] = set;\n"
 473            "      return ret;\n"
 474            "    }\n"
 475            "  else\n"
 476            "    {\n"
 477            "      gcc_assert (!set);\n"
 478            "      return false;\n"
 479            "    }\n"
 480            "}\n\n");
 481
 482   /* C++ (even G++) does not support (non-trivial) designated initializers.
 483      To work around that, generate these arrays programatically rather than
 484      by our traditional multiple inclusion of def files.  */
 485
 486   fprintf (s_file,
 487            "const struct convert_optab_libcall_d "
 488            "convlib_def[NUM_CONVLIB_OPTABS] = {\n");
 489   for (i = last_kind[0] + 1; i <= last_kind[1]; ++i)
 490     fprintf (s_file, "  { %s, %s },\n", optabs[i].base, optabs[i].libcall);
 491   fprintf (s_file, "};\n\n");
 492
 493   fprintf (s_file,
 494            "const struct optab_libcall_d "
 495            "normlib_def[NUM_NORMLIB_OPTABS] = {\n");
 496   for (i = last_kind[2] + 1; i <= last_kind[3]; ++i)
 497     fprintf (s_file, "  { %s, %s, %s },\n",
 498              optabs[i].suffix, optabs[i].base, optabs[i].libcall);
 499   fprintf (s_file, "};\n\n");
 500
 501   fprintf (s_file, "enum rtx_code const optab_to_code_[NUM_OPTABS] = {\n");
 502   for (i = 0; i < n; ++i)
 503     fprintf (s_file, "  %s,\n", rtx_upname[optabs[i].fcode]);
 504   fprintf (s_file, "};\n\n");
 505
 506   qsort (optabs, n, sizeof (optab_def), optab_rcode_cmp);
 507
 508   fprintf (s_file, "const optab code_to_optab_[NUM_RTX_CODE] = {\n");
 509   for (j = 0; optabs[j].rcode == UNKNOWN; ++j)
 510     continue;
 511   for (i = 0; i < NON_GENERATOR_NUM_RTX_CODE; ++i)
 512     {
 513       if (j < n && optabs[j].rcode == i)
 514         fprintf (s_file, "  %s,\n", optabs[j++].name);
 515       else
 516         fprintf (s_file, "  unknown_optab,\n");
 517     }
 518   fprintf (s_file, "};\n\n");
 519
 520   return (fclose (h_file) == 0 && fclose (s_file) == 0
 521           ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE);
 522 }