gcc/optc-gen.awk

   1 #  Copyright (C) 2003-2014 Free Software Foundation, Inc.
   2 #  Contributed by Kelley Cook, June 2004.
   3 #  Original code from Neil Booth, May 2003.
   4 #
   5 # This program is free software; you can redistribute it and/or modify it
   6 # under the terms of the GNU General Public License as published by the
   7 # Free Software Foundation; either version 3, or (at your option) any
   8 # later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; see the file COPYING3.  If not see
  17 # <http://www.gnu.org/licenses/>.
  18
  19 # This Awk script reads in the option records generated from
  20 # opt-gather.awk, combines the flags of duplicate options and generates a
  21 # C file.
  22 #
  23
  24 # This program uses functions from opt-functions.awk and code from
  25 # opt-read.awk.
  26 #
  27 # Usage: awk -f opt-functions.awk -f opt-read.awk -f optc-gen.awk \
  28 #            [-v header_name=header.h] < inputfile > options.c
  29
  30 # Dump that array of options into a C file.
  31 END {
  32
  33 # Record first EnabledBy and LangEnabledBy uses.
  34 n_enabledby = 0;
  35 for (i = 0; i < n_langs; i++) {
  36     n_enabledby_lang[i] = 0;
  37 }
  38 for (i = 0; i < n_opts; i++) {
  39     enabledby_arg = opt_args("EnabledBy", flags[i]);
  40     if (enabledby_arg != "") {
  41         n_enabledby_names = split(enabledby_arg, enabledby_names, " && ");
  42         if (n_enabledby_names > 2) {
  43             print "#error EnabledBy (Wfoo && Wbar && Wbaz) not currently supported"
  44         }
  45         for (j = 1; j <= n_enabledby_names; j++) {
  46             enabledby_name = enabledby_names[j];
  47             enabledby_index = opt_numbers[enabledby_name];
  48             if (enabledby_index == "") {
  49                 print "#error Enabledby: " enabledby_name
  50             } else {
  51                 condition = "";
  52                 if (n_enabledby_names == 2) {
  53                     opt_var_name_1 = search_var_name(enabledby_names[1], opt_numbers, opts, flags, n_opts);
  54                     opt_var_name_2 = search_var_name(enabledby_names[2], opt_numbers, opts, flags, n_opts);
  55                     if (opt_var_name_1 == "") {
  56                         print "#error " enabledby_names[1] " does not have a Var() flag"
  57                     }
  58                     if (opt_var_name_2 == "") {
  59                         print "#error " enabledby_names[2] " does not have a Var() flag"
  60                     }
  61                     condition = "opts->x_" opt_var_name_1 " && opts->x_" opt_var_name_2;
  62                 }
  63                 if (enables[enabledby_name] == "") {
  64                     enabledby[n_enabledby] = enabledby_name;
  65                     n_enabledby++;
  66                 }
  67                 enables[enabledby_name] = enables[enabledby_name] opts[i] ";";
  68                 enablesif[enabledby_name] = enablesif[enabledby_name] condition ";";
  69             }
  70         }
  71     }
  72
  73     enabledby_arg = opt_args("LangEnabledBy", flags[i]);
  74     if (enabledby_arg != "") {
  75         enabledby_langs = nth_arg(0, enabledby_arg);
  76         enabledby_name = nth_arg(1, enabledby_arg);
  77         enabledby_posarg = nth_arg(2, enabledby_arg);
  78         enabledby_negarg = nth_arg(3, enabledby_arg);
  79         lang_enabled_by(enabledby_langs, enabledby_name, enabledby_posarg, enabledby_negarg);
  80     }
  81 }
  82
  83
  84 print "/* This file is auto-generated by optc-gen.awk.  */"
  85 print ""
  86 n_headers = split(header_name, headers, " ")
  87 for (i = 1; i <= n_headers; i++)
  88         print "#include " quote headers[i] quote
  89 print "#include " quote "opts.h" quote
  90 print "#include " quote "intl.h" quote
  91 print "#include " quote "insn-attr-common.h" quote
  92 print ""
  93
  94 if (n_extra_c_includes > 0) {
  95         for (i = 0; i < n_extra_c_includes; i++) {
  96                 print "#include " quote extra_c_includes[i] quote
  97         }
  98         print ""
  99 }
 100
 101 for (i = 0; i < n_enums; i++) {
 102         name = enum_names[i]
 103         type = enum_type[name]
 104         print "static const struct cl_enum_arg cl_enum_" name \
 105             "_data[] = "
 106         print "{"
 107         print enum_data[name] "  { NULL, 0, 0 }"
 108         print "};"
 109         print ""
 110         print "static void"
 111         print "cl_enum_" name "_set (void *var, int value)"
 112         print "{"
 113         print "  *((" type " *) var) = (" type ") value;"
 114         print "}"
 115         print ""
 116         print "static int"
 117         print "cl_enum_" name "_get (const void *var)"
 118         print "{"
 119         print "  return (int) *((const " type " *) var);"
 120         print "}"
 121         print ""
 122 }
 123
 124 print "const struct cl_enum cl_enums[] ="
 125 print "{"
 126 for (i = 0; i < n_enums; i++) {
 127         name = enum_names[i]
 128         ehelp = enum_help[name]
 129         if (ehelp == "")
 130                 ehelp = "NULL"
 131         else
 132                 ehelp = quote ehelp quote
 133         unknown_error = enum_unknown_error[name]
 134         if (unknown_error == "")
 135                 unknown_error = "NULL"
 136         else
 137                 unknown_error = quote unknown_error quote
 138         print "  {"
 139         print "    " ehelp ","
 140         print "    " unknown_error ","
 141         print "    cl_enum_" name "_data,"
 142         print "    sizeof (" enum_type[name] "),"
 143         print "    cl_enum_" name "_set,"
 144         print "    cl_enum_" name "_get"
 145         print "  },"
 146 }
 147 print "};"
 148 print "const unsigned int cl_enums_count = " n_enums ";"
 149 print ""
 150
 151 print "const struct gcc_options global_options_init =\n{"
 152 for (i = 0; i < n_extra_vars; i++) {
 153         var = extra_vars[i]
 154         init = extra_vars[i]
 155         if (var ~ "=" ) {
 156                 sub(".*= *", "", init)
 157         } else {
 158                 init = "0"
 159         }
 160         sub(" *=.*", "", var)
 161         name = var
 162         sub("^.*[ *]", "", name)
 163         sub("\\[.*\\]$", "", name)
 164         var_seen[name] = 1
 165         print "  " init ", /* " name " */"
 166 }
 167 for (i = 0; i < n_opts; i++) {
 168         name = var_name(flags[i]);
 169         if (name == "")
 170                 continue;
 171
 172         init = opt_args("Init", flags[i])
 173         if (init != "") {
 174                 if (name in var_init && var_init[name] != init)
 175                         print "#error multiple initializers for " name
 176                 var_init[name] = init
 177         }
 178 }
 179 for (i = 0; i < n_opts; i++) {
 180         name = var_name(flags[i]);
 181         if (name == "")
 182                 continue;
 183
 184         if (name in var_seen)
 185                 continue;
 186
 187         if (name in var_init)
 188                 init = var_init[name]
 189         else
 190                 init = "0"
 191
 192         print "  " init ", /* " name " */"
 193
 194         var_seen[name] = 1;
 195 }
 196 for (i = 0; i < n_opts; i++) {
 197         name = static_var(opts[i], flags[i]);
 198         if (name != "") {
 199                 print "  0, /* " name " (private state) */"
 200                 print "#undef x_" name
 201         }
 202 }
 203 for (i = 0; i < n_opts; i++) {
 204         if (flag_set_p("SetByCombined", flags[i]))
 205                 print "  false, /* frontend_set_" var_name(flags[i]) " */"
 206 }
 207 print "};"
 208 print ""
 209 print "struct gcc_options global_options;"
 210 print "struct gcc_options global_options_set;"
 211 print ""
 212
 213 print "const char * const lang_names[] =\n{"
 214 for (i = 0; i < n_langs; i++) {
 215         macros[i] = "CL_" lang_sanitized_name(langs[i])
 216         s = substr("         ", length (macros[i]))
 217         print "  " quote langs[i] quote ","
 218     }
 219
 220 print "  0\n};\n"
 221 print "const unsigned int cl_options_count = N_OPTS;\n"
 222 print "#if (1U << " n_langs ") > CL_MIN_OPTION_CLASS"
 223 print "  #error the number of languages exceeds the implementation limit"
 224 print "#endif"
 225 print "const unsigned int cl_lang_count = " n_langs ";\n"
 226
 227 print "const struct cl_option cl_options[] =\n{"
 228
 229 j = 0
 230 for (i = 0; i < n_opts; i++) {
 231         back_chain[i] = "N_OPTS";
 232         indices[opts[i]] = j;
 233         # Combine the flags of identical switches.  Switches
 234         # appear many times if they are handled by many front
 235         # ends, for example.
 236         while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
 237                 flags[i + 1] = flags[i] " " flags[i + 1];
 238                 if (help[i + 1] == "")
 239                         help[i + 1] = help[i]
 240                 else if (help[i] != "" && help[i + 1] != help[i])
 241                         print "#error Multiple different help strings for " \
 242                                 opts[i] ":\n\t" help[i] "\n\t" help[i + 1]
 243
 244                 i++;
 245                 back_chain[i] = "N_OPTS";
 246                 indices[opts[i]] = j;
 247         }
 248         j++;
 249 }
 250
 251 for (i = 0; i < n_opts; i++) {
 252         # With identical flags, pick only the last one.  The
 253         # earlier loop ensured that it has all flags merged,
 254         # and a nonempty help text if one of the texts was nonempty.
 255         while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
 256                 i++;
 257         }
 258
 259         len = length (opts[i]);
 260         enum = opt_enum(opts[i])
 261
 262         # If this switch takes joined arguments, back-chain all
 263         # subsequent switches to it for which it is a prefix.  If
 264         # a later switch S is a longer prefix of a switch T, T
 265         # will be back-chained to S in a later iteration of this
 266         # for() loop, which is what we want.
 267         if (flag_set_p("Joined.*", flags[i])) {
 268                 for (j = i + 1; j < n_opts; j++) {
 269                         if (substr (opts[j], 1, len) != opts[i])
 270                                 break;
 271                         back_chain[j] = enum;
 272                 }
 273         }
 274
 275         s = substr("                                  ", length (opts[i]))
 276         if (i + 1 == n_opts)
 277                 comma = ""
 278
 279         if (help[i] == "")
 280                 hlp = "0"
 281         else
 282                 hlp = quote help[i] quote;
 283
 284         missing_arg_error = opt_args("MissingArgError", flags[i])
 285         if (missing_arg_error == "")
 286                 missing_arg_error = "0"
 287         else
 288                 missing_arg_error = quote missing_arg_error quote
 289
 290
 291         warn_message = opt_args("Warn", flags[i])
 292         if (warn_message == "")
 293                 warn_message = "0"
 294         else
 295                 warn_message = quote warn_message quote
 296
 297         alias_arg = opt_args("Alias", flags[i])
 298         if (alias_arg == "") {
 299                 if (flag_set_p("Ignore", flags[i]))
 300                         alias_data = "NULL, NULL, OPT_SPECIAL_ignore"
 301                 else
 302                         alias_data = "NULL, NULL, N_OPTS"
 303         } else {
 304                 alias_opt = nth_arg(0, alias_arg)
 305                 alias_posarg = nth_arg(1, alias_arg)
 306                 alias_negarg = nth_arg(2, alias_arg)
 307
 308                 if (var_ref(opts[i], flags[i]) != "-1")
 309                         print "#error Alias setting variable"
 310
 311                 if (alias_posarg != "" && alias_negarg == "") {
 312                         if (!flag_set_p("RejectNegative", flags[i]) \
 313                             && opts[i] ~ "^[Wfm]")
 314                                 print "#error Alias with single argument " \
 315                                         "allowing negative form"
 316                 }
 317                 if (alias_posarg != "" \
 318                     && flag_set_p("NegativeAlias", flags[i])) {
 319                         print "#error Alias with multiple arguments " \
 320                                 "used with NegativeAlias"
 321                 }
 322
 323                 alias_opt = opt_enum(alias_opt)
 324                 if (alias_posarg == "")
 325                         alias_posarg = "NULL"
 326                 else
 327                         alias_posarg = quote alias_posarg quote
 328                 if (alias_negarg == "")
 329                         alias_negarg = "NULL"
 330                 else
 331                         alias_negarg = quote alias_negarg quote
 332                 alias_data = alias_posarg ", " alias_negarg ", " alias_opt
 333         }
 334
 335         neg = opt_args("Negative", flags[i]);
 336         if (neg != "")
 337                 idx = indices[neg]
 338         else {
 339                 if (flag_set_p("RejectNegative", flags[i]))
 340                         idx = -1;
 341                 else {
 342                         if (opts[i] ~ "^[Wfm]")
 343                                 idx = indices[opts[i]];
 344                         else
 345                                 idx = -1;
 346                 }
 347         }
 348         # Split the printf after %u to work around an ia64-hp-hpux11.23
 349         # awk bug.
 350         printf("  { %c-%s%c,\n    %s,\n    %s,\n    %s,\n    %s, %s, %u,",
 351                quote, opts[i], quote, hlp, missing_arg_error, warn_message,
 352                alias_data, back_chain[i], len)
 353         printf(" %d,\n", idx)
 354         condition = opt_args("Condition", flags[i])
 355         cl_flags = switch_flags(flags[i])
 356         cl_bit_fields = switch_bit_fields(flags[i])
 357         cl_zero_bit_fields = switch_bit_fields("")
 358         if (condition != "")
 359                 printf("#if %s\n" \
 360                        "    %s,\n" \
 361                        "    0, %s,\n" \
 362                        "#else\n" \
 363                        "    0,\n" \
 364                        "    1 /* Disabled.  */, %s,\n" \
 365                        "#endif\n",
 366                        condition, cl_flags, cl_bit_fields, cl_zero_bit_fields)
 367         else
 368                 printf("    %s,\n" \
 369                        "    0, %s,\n",
 370                        cl_flags, cl_bit_fields)
 371         printf("    %s, %s }%s\n", var_ref(opts[i], flags[i]),
 372                var_set(flags[i]), comma)
 373 }
 374
 375 print "};"
 376
 377 print "\n\n"
 378 print "bool                                                                  "
 379 print "common_handle_option_auto (struct gcc_options *opts,                  "
 380 print "                           struct gcc_options *opts_set,              "
 381 print "                           const struct cl_decoded_option *decoded,   "
 382 print "                           unsigned int lang_mask, int kind,          "
 383 print "                           location_t loc,                            "
 384 print "                           const struct cl_option_handlers *handlers, "
 385 print "                           diagnostic_context *dc)                    "
 386 print "{                                                                     "
 387 print "  size_t scode = decoded->opt_index;                                  "
 388 print "  int value = decoded->value;                                         "
 389 print "  enum opt_code code = (enum opt_code) scode;                         "
 390 print "                                                                      "
 391 print "  gcc_assert (decoded->canonical_option_num_elements <= 2);           "
 392 print "                                                                      "
 393 print "  switch (code)                                                       "
 394 print "    {                                                                 "
 395 # Handle EnabledBy
 396 for (i = 0; i < n_enabledby; i++) {
 397     enabledby_name = enabledby[i];
 398     print "    case " opt_enum(enabledby_name) ":"
 399     n_enables = split(enables[enabledby_name], thisenable, ";");
 400     n_enablesif = split(enablesif[enabledby_name], thisenableif, ";");
 401     if (n_enables != n_enablesif) {
 402         print "#error n_enables != n_enablesif: Something went wrong!"
 403     }
 404     for (j = 1; j < n_enables; j++) {
 405         opt_var_name = var_name(flags[opt_numbers[thisenable[j]]]);
 406         if (opt_var_name != "") {
 407             condition = "!opts_set->x_" opt_var_name
 408             if (thisenableif[j] != "") {
 409                 value = "(" thisenableif[j] ")"
 410             } else {
 411                 value = "value"
 412             }
 413             print "      if (" condition ")"
 414             print "        handle_generated_option (opts, opts_set,"
 415             print "                                 " opt_enum(thisenable[j]) ", NULL, " value ","
 416             print "                                 lang_mask, kind, loc, handlers, dc);"
 417         } else {
 418             print "#error " thisenable[j] " does not have a Var() flag"
 419         }
 420     }
 421     print "      break;\n"
 422 }
 423 print "    default:    "
 424 print "      break;    "
 425 print "    }           "
 426 print "  return true;  "
 427 print "}               "
 428
 429 # Handle LangEnabledBy
 430 for (i = 0; i < n_langs; i++) {
 431     lang_name = lang_sanitized_name(langs[i]);
 432     mark_unused = " ATTRIBUTE_UNUSED";
 433
 434     print "\n\n"
 435     print "bool                                                                  "
 436     print lang_name "_handle_option_auto (struct gcc_options *opts" mark_unused ",              "
 437     print "                           struct gcc_options *opts_set" mark_unused ",              "
 438     print "                           size_t scode" mark_unused ", const char *arg" mark_unused ", int value" mark_unused ",  "
 439     print "                           unsigned int lang_mask" mark_unused ", int kind" mark_unused ",          "
 440     print "                           location_t loc" mark_unused ",                            "
 441     print "                           const struct cl_option_handlers *handlers" mark_unused ", "
 442     print "                           diagnostic_context *dc" mark_unused ")                    "
 443     print "{                                                                     "
 444     print "  enum opt_code code = (enum opt_code) scode;                         "
 445     print "                                                                      "
 446     print "  switch (code)                                                       "
 447     print "    {                                                                 "
 448
 449     for (k = 0; k < n_enabledby_lang[i]; k++) {
 450         enabledby_name = enabledby[lang_name,k];
 451         print "    case " opt_enum(enabledby_name) ":"
 452         n_thisenable = split(enables[lang_name,enabledby_name], thisenable, ";");
 453         for (j = 1; j < n_thisenable; j++) {
 454             n_thisenable_args = split(thisenable[j], thisenable_args, ",");
 455             if (n_thisenable_args == 1) {
 456                 thisenable_opt = thisenable[j];
 457                 value = "value";
 458             } else {
 459                 thisenable_opt = thisenable_args[1];
 460                 with_posarg = thisenable_args[2];
 461                 with_negarg = thisenable_args[3];
 462                 value = "value ? " with_posarg " : " with_negarg;
 463             }
 464             opt_var_name = var_name(flags[opt_numbers[thisenable_opt]]);
 465             if (opt_var_name != "") {
 466                 print "      if (!opts_set->x_" opt_var_name ")"
 467                 print "        handle_generated_option (opts, opts_set,"
 468                 print "                                 " opt_enum(thisenable_opt) ", NULL, " value ","
 469                 print "                                 lang_mask, kind, loc, handlers, dc);"
 470             } else {
 471                 print "#error " thisenable_opt " does not have a Var() flag"
 472             }
 473         }
 474         print "      break;\n"
 475     }
 476     print "    default:    "
 477     print "      break;    "
 478     print "    }           "
 479     print "  return true;  "
 480     print "}               "
 481 }
 482
 483 #Handle CPP()
 484 print "\n"
 485 print "#include " quote "cpplib.h" quote;
 486 print "void"
 487 print "cpp_handle_option_auto (const struct gcc_options * opts,                   "
 488 print "                        size_t scode, struct cpp_options * cpp_opts)"
 489 print "{                                                                     "
 490 print "  enum opt_code code = (enum opt_code) scode;                         "
 491 print "                                                                      "
 492 print "  switch (code)                                                       "
 493 print "    {                                                                 "
 494 for (i = 0; i < n_opts; i++) {
 495     # With identical flags, pick only the last one.  The
 496     # earlier loop ensured that it has all flags merged,
 497     # and a nonempty help text if one of the texts was nonempty.
 498     while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
 499         i++;
 500     }
 501
 502     cpp_option = nth_arg(0, opt_args("CPP", flags[i]));
 503     if (cpp_option != "") {
 504         opt_var_name = var_name(flags[i]);
 505         init = opt_args("Init", flags[i])
 506         if (opt_var_name != "" && init != "") {
 507             print "    case " opt_enum(opts[i]) ":"
 508             print "      cpp_opts->" cpp_option " = opts->x_" opt_var_name ";"
 509             print "      break;"
 510         } else if (opt_var_name == "" && init == "") {
 511             print "#error CPP() requires setting Init() and Var() for " opts[i]
 512         } else if (opt_var_name != "") {
 513             print "#error CPP() requires setting Init() for " opts[i]
 514         } else {
 515             print "#error CPP() requires setting Var() for " opts[i]
 516         }
 517     }
 518 }
 519 print "    default:    "
 520 print "      break;    "
 521 print "    }           "
 522 print "}\n"
 523 print "void"
 524 print "init_global_opts_from_cpp(struct gcc_options * opts,                   "
 525 print "                         const struct cpp_options * cpp_opts)"
 526 print "{                                                                     "
 527 for (i = 0; i < n_opts; i++) {
 528     # With identical flags, pick only the last one.  The
 529     # earlier loop ensured that it has all flags merged,
 530     # and a nonempty help text if one of the texts was nonempty.
 531     while( i + 1 != n_opts && opts[i] == opts[i + 1] ) {
 532         i++;
 533     }
 534     cpp_option = nth_arg(0, opt_args("CPP", flags[i]));
 535     opt_var_name = var_name(flags[i]);
 536     if (cpp_option != "" && opt_var_name != "") {
 537         print "  opts->x_" opt_var_name " = cpp_opts->" cpp_option ";"
 538     }
 539 }
 540 print "}               "
 541
 542 }
 543