options.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * 'sparse' library helper routines.
   4  *
   5  * Copyright (C) 2003 Transmeta Corp.
   6  *               2003-2004 Linus Torvalds
   7  *               2017-2020 Luc Van Oostenryck
   8  */
   9
  10 #include "options.h"
  11 #include "lib.h"
  12 #include "machine.h"
  13 #include "target.h"
  14 #include "version.h"
  15 #include <ctype.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20
  21 #ifndef __GNUC__
  22 # define __GNUC__ 2
  23 # define __GNUC_MINOR__ 95
  24 # define __GNUC_PATCHLEVEL__ 0
  25 #endif
  26
  27 enum flag_type {
  28         FLAG_OFF,
  29         FLAG_ON,
  30         FLAG_FORCE_OFF
  31 };
  32
  33 int die_if_error = 0;
  34 int do_output = 1;
  35 int gcc_major = __GNUC__;
  36 int gcc_minor = __GNUC_MINOR__;
  37 int gcc_patchlevel = __GNUC_PATCHLEVEL__;
  38 int has_error = 0;
  39 int optimize_level;
  40 int optimize_size;
  41 int preprocess_only;
  42 int preprocessing;
  43 int verbose;
  44
  45 #define CMDLINE_INCLUDE 20
  46 int cmdline_include_nr = 0;
  47 char *cmdline_include[CMDLINE_INCLUDE];
  48
  49 const char *base_filename;
  50 const char *diag_prefix = "";
  51 const char *gcc_base_dir = GCC_BASE;
  52 const char *multiarch_dir = MULTIARCH_TRIPLET;
  53 const char *outfile = NULL;
  54
  55 enum standard standard = STANDARD_GNU89;
  56
  57 int arch_big_endian = ARCH_BIG_ENDIAN;
  58 int arch_cmodel = CMODEL_UNKNOWN;
  59 int arch_fp_abi = FP_ABI_NATIVE;
  60 int arch_m64 = ARCH_M64_DEFAULT;
  61 int arch_msize_long = 0;
  62 int arch_os = OS_NATIVE;
  63
  64 int dbg_compound = 0;
  65 int dbg_dead = 0;
  66 int dbg_domtree = 0;
  67 int dbg_entry = 0;
  68 int dbg_ir = 0;
  69 int dbg_postorder = 0;
  70
  71 int dump_macro_defs = 0;
  72 int dump_macros_only = 0;
  73
  74 unsigned long fdump_ir;
  75 int fhosted = 1;
  76 unsigned int fmax_errors = 100;
  77 unsigned int fmax_warnings = 100;
  78 int fmem_report = 0;
  79 unsigned long long fmemcpy_max_count = 100000;
  80 unsigned long fpasses = ~0UL;
  81 int fpic = 0;
  82 int fpie = 0;
  83 int fshort_wchar = 0;
  84 int funsigned_char = 0;
  85
  86 int Waddress = 0;
  87 int Waddress_space = 1;
  88 int Wbitwise = 1;
  89 int Wbitwise_pointer = 0;
  90 int Wcast_from_as = 0;
  91 int Wcast_to_as = 0;
  92 int Wcast_truncate = 1;
  93 int Wconstant_suffix = 0;
  94 int Wconstexpr_not_const = 0;
  95 int Wcontext = 1;
  96 int Wdecl = 1;
  97 int Wdeclarationafterstatement = -1;
  98 int Wdefault_bitfield_sign = 0;
  99 int Wdesignated_init = 1;
 100 int Wdo_while = 0;
 101 int Wenum_mismatch = 1;
 102 int Wexternal_function_has_definition = 1;
 103 int Wimplicit_int = 1;
 104 int Winit_cstring = 0;
 105 int Wint_to_pointer_cast = 1;
 106 int Wmemcpy_max_count = 1;
 107 int Wnewline_eof = 1;
 108 int Wnon_pointer_null = 1;
 109 int Wold_initializer = 1;
 110 int Wold_style_definition = 1;
 111 int Wone_bit_signed_bitfield = 1;
 112 int Woverride_init = 1;
 113 int Woverride_init_all = 0;
 114 int Woverride_init_whole_range = 0;
 115 int Wparen_string = 0;
 116 int Wpast_deep_designator = 0;
 117 int Wpedantic = 0;
 118 int Wpointer_arith = 0;
 119 int Wpointer_to_int_cast = 1;
 120 int Wptr_subtraction_blows = 0;
 121 int Wreturn_void = 0;
 122 int Wshadow = 0;
 123 int Wshift_count_negative = 1;
 124 int Wshift_count_overflow = 1;
 125 int Wsizeof_bool = 0;
 126 int Wsparse_error = FLAG_FORCE_OFF;
 127 int Wstrict_prototypes = 1;
 128 int Wtautological_compare = 0;
 129 int Wtransparent_union = 0;
 130 int Wtypesign = 0;
 131 int Wundef = 0;
 132 int Wuninitialized = 1;
 133 int Wunion_cast = 0;
 134 int Wuniversal_initializer = 0;
 135 int Wunknown_attribute = 0;
 136 int Wvla = 1;
 137
 138 ////////////////////////////////////////////////////////////////////////////////
 139 // Helpers for option parsing
 140
 141 static const char *match_option(const char *arg, const char *prefix)
 142 {
 143         unsigned int n = strlen(prefix);
 144         if (strncmp(arg, prefix, n) == 0)
 145                 return arg + n;
 146         return NULL;
 147 }
 148
 149
 150 struct val_map {
 151         const char *name;
 152         int val;
 153 };
 154
 155 static int handle_subopt_val(const char *opt, const char *arg, const struct val_map *map, int *flag)
 156 {
 157         const char *name;
 158
 159         if (*arg++ != '=')
 160                 die("missing argument for option '%s'", opt);
 161         for (;(name = map->name); map++) {
 162                 if (strcmp(name, arg) == 0 || strcmp(name, "*") == 0) {
 163                         *flag = map->val;
 164                         return 1;
 165                 }
 166                 if (strcmp(name, "?") == 0)
 167                         die("invalid argument '%s' in option '%s'", arg, opt);
 168         }
 169         return 0;
 170 }
 171
 172
 173 struct mask_map {
 174         const char *name;
 175         unsigned long mask;
 176 };
 177
 178 static int apply_mask(unsigned long *val, const char *str, unsigned len, const struct mask_map *map, int neg)
 179 {
 180         const char *name;
 181
 182         for (;(name = map->name); map++) {
 183                 if (!strncmp(name, str, len) && !name[len]) {
 184                         if (neg == 0)
 185                                 *val |= map->mask;
 186                         else
 187                                 *val &= ~map->mask;
 188                         return 0;
 189                 }
 190         }
 191         return 1;
 192 }
 193
 194 static int handle_suboption_mask(const char *arg, const char *opt, const struct mask_map *map, unsigned long *flag)
 195 {
 196         if (*opt == '\0') {
 197                 apply_mask(flag, "", 0, map, 0);
 198                 return 1;
 199         }
 200         if (*opt++ != '=')
 201                 return 0;
 202         while (1) {
 203                 unsigned int len = strcspn(opt, ",+");
 204                 int neg = 0;
 205                 if (len == 0)
 206                         goto end;
 207                 if (!strncmp(opt, "no-", 3)) {
 208                         opt += 3;
 209                         len -= 3;
 210                         neg = 1;
 211                 }
 212                 if (apply_mask(flag, opt, len, map, neg))
 213                         die("error: wrong option '%.*s' for \'%s\'", len, opt, arg);
 214
 215 end:
 216                 opt += len;
 217                 if (*opt++ == '\0')
 218                         break;
 219         }
 220         return 1;
 221 }
 222
 223
 224 #define OPT_INVERSE     1
 225 #define OPT_VAL         2
 226 struct flag {
 227         const char *name;
 228         int *flag;
 229         int (*fun)(const char *arg, const char *opt, const struct flag *, int options);
 230         unsigned long mask;
 231         int val;
 232 };
 233
 234 static int handle_switches(const char *ori, const char *opt, const struct flag *flags)
 235 {
 236         const char *arg = opt;
 237         int val = 1;
 238
 239         // Prefixe "no-" mean to turn flag off.
 240         if (strncmp(arg, "no-", 3) == 0) {
 241                 arg += 3;
 242                 val = 0;
 243         }
 244
 245         for (; flags->name; flags++) {
 246                 const char *opt = match_option(arg, flags->name);
 247                 int rc;
 248
 249                 if (!opt)
 250                         continue;
 251
 252                 if (flags->fun) {
 253                         int options = 0;
 254                         if (!val)
 255                                 options |= OPT_INVERSE;
 256                         if ((rc = flags->fun(ori, opt, flags, options)))
 257                                 return rc;
 258                 }
 259
 260                 // boolean flag
 261                 if (opt[0] == '\0' && flags->flag) {
 262                         if (flags->mask & OPT_VAL)
 263                                 val = flags->val;
 264                         if (flags->mask & OPT_INVERSE)
 265                                 val = !val;
 266                         *flags->flag = val;
 267                         return 1;
 268                 }
 269         }
 270
 271         // not handled
 272         return 0;
 273 }
 274
 275 static char **handle_onoff_switch(char *arg, char **next, const struct flag flags[])
 276 {
 277         int flag = FLAG_ON;
 278         char *p = arg + 1;
 279         unsigned i;
 280
 281         // Prefixes "no" and "no-" mean to turn warning off.
 282         if (p[0] == 'n' && p[1] == 'o') {
 283                 p += 2;
 284                 if (p[0] == '-')
 285                         p++;
 286                 flag = FLAG_FORCE_OFF;
 287         }
 288
 289         for (i = 0; flags[i].name; i++) {
 290                 if (!strcmp(p,flags[i].name)) {
 291                         *flags[i].flag = flag;
 292                         return next;
 293                 }
 294         }
 295
 296         // Unknown.
 297         return NULL;
 298 }
 299
 300 static void handle_onoff_switch_finalize(const struct flag flags[])
 301 {
 302         unsigned i;
 303
 304         for (i = 0; flags[i].name; i++) {
 305                 if (*flags[i].flag == FLAG_FORCE_OFF)
 306                         *flags[i].flag = FLAG_OFF;
 307         }
 308 }
 309
 310 static int handle_switch_setval(const char *arg, const char *opt, const struct flag *flag, int options)
 311 {
 312         *(flag->flag) = flag->mask;
 313         return 1;
 314 }
 315
 316
 317 #define OPTNUM_ZERO_IS_INF              1
 318 #define OPTNUM_UNLIMITED                2
 319
 320 #define OPT_NUMERIC(NAME, TYPE, FUNCTION)       \
 321 static int opt_##NAME(const char *arg, const char *opt, TYPE *ptr, int flag)    \
 322 {                                                                       \
 323         char *end;                                                      \
 324         TYPE val;                                                       \
 325                                                                         \
 326         val = FUNCTION(opt, &end, 0);                                   \
 327         if (*end != '\0' || end == opt) {                               \
 328                 if ((flag & OPTNUM_UNLIMITED) && !strcmp(opt, "unlimited"))     \
 329                         val = ~val;                                     \
 330                 else                                                    \
 331                         die("error: wrong argument to \'%s\'", arg);    \
 332         }                                                               \
 333         if ((flag & OPTNUM_ZERO_IS_INF) && val == 0)                    \
 334                 val = ~val;                                             \
 335         *ptr = val;                                                     \
 336         return 1;                                                       \
 337 }
 338
 339 OPT_NUMERIC(ullong, unsigned long long, strtoull)
 340 OPT_NUMERIC(uint, unsigned int, strtoul)
 341
 342 ////////////////////////////////////////////////////////////////////////////////
 343 // Option parsing
 344
 345 static char **handle_switch_a(char *arg, char **next)
 346 {
 347         if (!strcmp(arg, "ansi"))
 348                 standard = STANDARD_C89;
 349
 350         return next;
 351 }
 352
 353 static char **handle_switch_D(char *arg, char **next)
 354 {
 355         const char *name = arg + 1;
 356         const char *value = "1";
 357
 358         if (!*name) {
 359                 arg = *++next;
 360                 if (!arg)
 361                         die("argument to `-D' is missing");
 362                 name = arg;
 363         }
 364
 365         for (;;arg++) {
 366                 char c;
 367                 c = *arg;
 368                 if (!c)
 369                         break;
 370                 if (c == '=') {
 371                         *arg = '\0';
 372                         value = arg + 1;
 373                         break;
 374                 }
 375         }
 376         add_pre_buffer("#define %s %s\n", name, value);
 377         return next;
 378 }
 379
 380 static char **handle_switch_d(char *arg, char **next)
 381 {
 382         char *arg_char = arg + 1;
 383
 384         /*
 385          * -d<CHARS>, where <CHARS> is a sequence of characters, not preceded
 386          * by a space. If you specify characters whose behaviour conflicts,
 387          * the result is undefined.
 388          */
 389         while (*arg_char) {
 390                 switch (*arg_char) {
 391                 case 'M': /* dump just the macro definitions */
 392                         dump_macros_only = 1;
 393                         dump_macro_defs = 0;
 394                         break;
 395                 case 'D': /* like 'M', but also output pre-processed text */
 396                         dump_macro_defs = 1;
 397                         dump_macros_only = 0;
 398                         break;
 399                 case 'N': /* like 'D', but only output macro names not bodies */
 400                         break;
 401                 case 'I': /* like 'D', but also output #include directives */
 402                         break;
 403                 case 'U': /* like 'D', but only output expanded macros */
 404                         break;
 405                 }
 406                 arg_char++;
 407         }
 408         return next;
 409 }
 410
 411 static char **handle_switch_E(char *arg, char **next)
 412 {
 413         if (arg[1] == '\0')
 414                 preprocess_only = 1;
 415         return next;
 416 }
 417
 418 static int handle_ftabstop(const char *arg, const char *opt, const struct flag *flag, int options)
 419 {
 420         unsigned long val;
 421         char *end;
 422
 423         if (*opt == '\0')
 424                 die("error: missing argument to \"%s\"", arg);
 425
 426         /* we silently ignore silly values */
 427         val = strtoul(opt, &end, 10);
 428         if (*end == '\0' && 1 <= val && val <= 100)
 429                 tabstop = val;
 430
 431         return 1;
 432 }
 433
 434 static int handle_fpasses(const char *arg, const char *opt, const struct flag *flag, int options)
 435 {
 436         unsigned long mask;
 437
 438         mask = flag->mask;
 439         if (*opt == '\0') {
 440                 if (options & OPT_INVERSE)
 441                         fpasses &= ~mask;
 442                 else
 443                         fpasses |=  mask;
 444                 return 1;
 445         }
 446         if (options & OPT_INVERSE)
 447                 return 0;
 448         if (!strcmp(opt, "-enable")) {
 449                 fpasses |= mask;
 450                 return 1;
 451         }
 452         if (!strcmp(opt, "-disable")) {
 453                 fpasses &= ~mask;
 454                 return 1;
 455         }
 456         if (!strcmp(opt, "=last")) {
 457                 // clear everything above
 458                 mask |= mask - 1;
 459                 fpasses &= mask;
 460                 return 1;
 461         }
 462         return 0;
 463 }
 464
 465 static int handle_fdiagnostic_prefix(const char *arg, const char *opt, const struct flag *flag, int options)
 466 {
 467         switch (*opt) {
 468         case '\0':
 469                 diag_prefix = "sparse: ";
 470                 return 1;
 471         case '=':
 472                 diag_prefix = xasprintf("%s: ", opt+1);
 473                 return 1;
 474         default:
 475                 return 0;
 476         }
 477 }
 478
 479 static int handle_fdump_ir(const char *arg, const char *opt, const struct flag *flag, int options)
 480 {
 481         static const struct mask_map dump_ir_options[] = {
 482                 { "",                   PASS_LINEARIZE },
 483                 { "linearize",          PASS_LINEARIZE },
 484                 { "mem2reg",            PASS_MEM2REG },
 485                 { "final",              PASS_FINAL },
 486                 { },
 487         };
 488
 489         return handle_suboption_mask(arg, opt, dump_ir_options, &fdump_ir);
 490 }
 491
 492 static int handle_fmemcpy_max_count(const char *arg, const char *opt, const struct flag *flag, int options)
 493 {
 494         opt_ullong(arg, opt, &fmemcpy_max_count, OPTNUM_ZERO_IS_INF|OPTNUM_UNLIMITED);
 495         return 1;
 496 }
 497
 498 static int handle_fmax_errors(const char *arg, const char *opt, const struct flag *flag, int options)
 499 {
 500         opt_uint(arg, opt, &fmax_errors, OPTNUM_UNLIMITED);
 501         return 1;
 502 }
 503
 504 static int handle_fmax_warnings(const char *arg, const char *opt, const struct flag *flag, int options)
 505 {
 506         opt_uint(arg, opt, &fmax_warnings, OPTNUM_UNLIMITED);
 507         return 1;
 508 }
 509
 510 static struct flag fflags[] = {
 511         { "diagnostic-prefix",  NULL,   handle_fdiagnostic_prefix },
 512         { "dump-ir",            NULL,   handle_fdump_ir },
 513         { "freestanding",       &fhosted, NULL, OPT_INVERSE },
 514         { "hosted",             &fhosted },
 515         { "linearize",          NULL,   handle_fpasses, PASS_LINEARIZE },
 516         { "max-errors=",        NULL,   handle_fmax_errors },
 517         { "max-warnings=",      NULL,   handle_fmax_warnings },
 518         { "mem-report",         &fmem_report },
 519         { "memcpy-max-count=",  NULL,   handle_fmemcpy_max_count },
 520         { "tabstop=",           NULL,   handle_ftabstop },
 521         { "mem2reg",            NULL,   handle_fpasses, PASS_MEM2REG },
 522         { "optim",              NULL,   handle_fpasses, PASS_OPTIM },
 523         { "pic",                &fpic,  handle_switch_setval, 1 },
 524         { "PIC",                &fpic,  handle_switch_setval, 2 },
 525         { "pie",                &fpie,  handle_switch_setval, 1 },
 526         { "PIE",                &fpie,  handle_switch_setval, 2 },
 527         { "signed-char",        &funsigned_char, NULL,  OPT_INVERSE },
 528         { "short-wchar",        &fshort_wchar },
 529         { "unsigned-char",      &funsigned_char, NULL, },
 530         { },
 531 };
 532
 533 static char **handle_switch_f(char *arg, char **next)
 534 {
 535         if (handle_switches(arg-1, arg+1, fflags))
 536                 return next;
 537
 538         return next;
 539 }
 540
 541 static char **handle_switch_G(char *arg, char **next)
 542 {
 543         if (!strcmp(arg, "G") && *next)
 544                 return next + 1; // "-G 0"
 545         else
 546                 return next;     // "-G0" or (bogus) terminal "-G"
 547 }
 548
 549 static char **handle_base_dir(char *arg, char **next)
 550 {
 551         gcc_base_dir = *++next;
 552         if (!gcc_base_dir)
 553                 die("missing argument for -gcc-base-dir option");
 554         return next;
 555 }
 556
 557 static char **handle_switch_g(char *arg, char **next)
 558 {
 559         if (!strcmp(arg, "gcc-base-dir"))
 560                 return handle_base_dir(arg, next);
 561
 562         return next;
 563 }
 564
 565 static char **handle_switch_I(char *arg, char **next)
 566 {
 567         char *path = arg+1;
 568
 569         switch (arg[1]) {
 570         case '-':
 571                 add_pre_buffer("#split_include\n");
 572                 break;
 573
 574         case '\0':      /* Plain "-I" */
 575                 path = *++next;
 576                 if (!path)
 577                         die("missing argument for -I option");
 578                 /* Fall through */
 579         default:
 580                 add_pre_buffer("#add_include \"%s/\"\n", path);
 581         }
 582         return next;
 583 }
 584
 585 static void add_cmdline_include(char *filename)
 586 {
 587         if (cmdline_include_nr >= CMDLINE_INCLUDE)
 588                 die("too many include files for %s\n", filename);
 589         cmdline_include[cmdline_include_nr++] = filename;
 590 }
 591
 592 static char **handle_switch_i(char *arg, char **next)
 593 {
 594         if (*next && !strcmp(arg, "include"))
 595                 add_cmdline_include(*++next);
 596         else if (*next && !strcmp(arg, "imacros"))
 597                 add_cmdline_include(*++next);
 598         else if (*next && !strcmp(arg, "isystem")) {
 599                 char *path = *++next;
 600                 if (!path)
 601                         die("missing argument for -isystem option");
 602                 add_pre_buffer("#add_isystem \"%s/\"\n", path);
 603         } else if (*next && !strcmp(arg, "idirafter")) {
 604                 char *path = *++next;
 605                 if (!path)
 606                         die("missing argument for -idirafter option");
 607                 add_pre_buffer("#add_dirafter \"%s/\"\n", path);
 608         }
 609         return next;
 610 }
 611
 612 static char **handle_switch_M(char *arg, char **next)
 613 {
 614         if (!strcmp(arg, "MF") || !strcmp(arg,"MQ") || !strcmp(arg,"MT")) {
 615                 if (!*next)
 616                         die("missing argument for -%s option", arg);
 617                 return next + 1;
 618         }
 619         return next;
 620 }
 621
 622 static int handle_march(const char *opt, const char *arg, const struct flag *flag, int options)
 623 {
 624         if (arch_target->parse_march)
 625                 arch_target->parse_march(arg);
 626         return 1;
 627 }
 628
 629 static int handle_mcmodel(const char *opt, const char *arg, const struct flag *flag, int options)
 630 {
 631         static const struct val_map cmodels[] = {
 632                 { "kernel",     CMODEL_KERNEL },
 633                 { "large",      CMODEL_LARGE },
 634                 { "medany",     CMODEL_MEDANY },
 635                 { "medium",     CMODEL_MEDIUM },
 636                 { "medlow",     CMODEL_MEDLOW },
 637                 { "small",      CMODEL_SMALL },
 638                 { "tiny",       CMODEL_TINY },
 639                 { },
 640         };
 641         return handle_subopt_val(opt, arg, cmodels, flag->flag);
 642 }
 643
 644 static int handle_mfloat_abi(const char *opt, const char *arg, const struct flag *flag, int options) {
 645         static const struct val_map fp_abis[] = {
 646                 { "hard",               FP_ABI_HARD },
 647                 { "soft",               FP_ABI_SOFT },
 648                 { "softfp",             FP_ABI_HYBRID },
 649                 { "?" },
 650         };
 651         return handle_subopt_val(opt, arg, fp_abis, flag->flag);
 652 }
 653
 654 static char **handle_multiarch_dir(char *arg, char **next)
 655 {
 656         multiarch_dir = *++next;
 657         if (!multiarch_dir)
 658                 die("missing argument for -multiarch-dir option");
 659         return next;
 660 }
 661
 662 static const struct flag mflags[] = {
 663         { "64", &arch_m64, NULL, OPT_VAL, ARCH_LP64 },
 664         { "32", &arch_m64, NULL, OPT_VAL, ARCH_LP32 },
 665         { "31", &arch_m64, NULL, OPT_VAL, ARCH_LP32 },
 666         { "16", &arch_m64, NULL, OPT_VAL, ARCH_LP32 },
 667         { "x32",&arch_m64, NULL, OPT_VAL, ARCH_X32 },
 668         { "size-llp64", &arch_m64, NULL, OPT_VAL, ARCH_LLP64 },
 669         { "size-long", &arch_msize_long },
 670         { "arch=", NULL, handle_march },
 671         { "big-endian", &arch_big_endian, NULL },
 672         { "little-endian", &arch_big_endian, NULL, OPT_INVERSE },
 673         { "cmodel", &arch_cmodel, handle_mcmodel },
 674         { "float-abi", &arch_fp_abi, handle_mfloat_abi },
 675         { "hard-float", &arch_fp_abi, NULL, OPT_VAL, FP_ABI_HARD },
 676         { "soft-float", &arch_fp_abi, NULL, OPT_VAL, FP_ABI_SOFT },
 677         { }
 678 };
 679
 680 static char **handle_switch_m(char *arg, char **next)
 681 {
 682         if (!strcmp(arg, "multiarch-dir")) {
 683                 return handle_multiarch_dir(arg, next);
 684         } else {
 685                 handle_switches(arg-1, arg+1, mflags);
 686         }
 687
 688         return next;
 689 }
 690
 691 static char **handle_nostdinc(char *arg, char **next)
 692 {
 693         add_pre_buffer("#nostdinc\n");
 694         return next;
 695 }
 696
 697 static char **handle_switch_n(char *arg, char **next)
 698 {
 699         if (!strcmp(arg, "nostdinc"))
 700                 return handle_nostdinc(arg, next);
 701
 702         return next;
 703 }
 704
 705 static char **handle_switch_O(char *arg, char **next)
 706 {
 707         int level = 1;
 708         if (arg[1] >= '0' && arg[1] <= '9')
 709                 level = arg[1] - '0';
 710         optimize_level = level;
 711         optimize_size = arg[1] == 's';
 712         return next;
 713 }
 714
 715 static char **handle_switch_o(char *arg, char **next)
 716 {
 717         if (!strcmp(arg, "o")) {        // "-o foo"
 718                 if (!*++next)
 719                         die("argument to '-o' is missing");
 720                 outfile = *next;
 721         }
 722         // else "-ofoo"
 723
 724         return next;
 725 }
 726
 727 static const struct flag pflags[] = {
 728         { "pedantic", &Wpedantic, NULL, OPT_VAL, FLAG_ON },
 729         { }
 730 };
 731
 732 static char **handle_switch_p(char *arg, char **next)
 733 {
 734         handle_switches(arg-1, arg, pflags);
 735         return next;
 736 }
 737
 738 static char **handle_switch_s(const char *arg, char **next)
 739 {
 740         if ((arg = match_option(arg, "std="))) {
 741                 if (!strcmp(arg, "c89") ||
 742                     !strcmp(arg, "iso9899:1990"))
 743                         standard = STANDARD_C89;
 744
 745                 else if (!strcmp(arg, "iso9899:199409"))
 746                         standard = STANDARD_C94;
 747
 748                 else if (!strcmp(arg, "c99") ||
 749                          !strcmp(arg, "c9x") ||
 750                          !strcmp(arg, "iso9899:1999") ||
 751                          !strcmp(arg, "iso9899:199x"))
 752                         standard = STANDARD_C99;
 753
 754                 else if (!strcmp(arg, "gnu89"))
 755                         standard = STANDARD_GNU89;
 756
 757                 else if (!strcmp(arg, "gnu99") || !strcmp(arg, "gnu9x"))
 758                         standard = STANDARD_GNU99;
 759
 760                 else if (!strcmp(arg, "c11") ||
 761                          !strcmp(arg, "c1x") ||
 762                          !strcmp(arg, "iso9899:2011"))
 763                         standard = STANDARD_C11;
 764
 765                 else if (!strcmp(arg, "gnu11"))
 766                         standard = STANDARD_GNU11;
 767
 768                 else if (!strcmp(arg, "c17") ||
 769                          !strcmp(arg, "c18") ||
 770                          !strcmp(arg, "iso9899:2017") ||
 771                          !strcmp(arg, "iso9899:2018"))
 772                         standard = STANDARD_C17;
 773                 else if (!strcmp(arg, "gnu17") ||
 774                          !strcmp(arg, "gnu18"))
 775                         standard = STANDARD_GNU17;
 776
 777                 else
 778                         die("Unsupported C dialect");
 779         }
 780
 781         return next;
 782 }
 783
 784 static char **handle_switch_U(char *arg, char **next)
 785 {
 786         const char *name = arg + 1;
 787
 788         if (*name == '\0') {
 789                 name = *++next;
 790                 if (!name)
 791                         die("argument to `-U' is missing");
 792         }
 793         add_pre_buffer("#undef %s\n", name);
 794         return next;
 795 }
 796
 797 static struct flag debugs[] = {
 798         { "compound", &dbg_compound},
 799         { "dead", &dbg_dead},
 800         { "domtree", &dbg_domtree},
 801         { "entry", &dbg_entry},
 802         { "ir", &dbg_ir},
 803         { "postorder", &dbg_postorder},
 804         { }
 805 };
 806
 807 static char **handle_switch_v(char *arg, char **next)
 808 {
 809         char ** ret = handle_onoff_switch(arg, next, debugs);
 810         if (ret)
 811                 return ret;
 812
 813         // Unknown.
 814         do {
 815                 verbose++;
 816         } while (*++arg == 'v');
 817         return next;
 818 }
 819
 820 static void handle_switch_v_finalize(void)
 821 {
 822         handle_onoff_switch_finalize(debugs);
 823 }
 824
 825 static const struct flag warnings[] = {
 826         { "address", &Waddress },
 827         { "address-space", &Waddress_space },
 828         { "bitwise", &Wbitwise },
 829         { "bitwise-pointer", &Wbitwise_pointer},
 830         { "cast-from-as", &Wcast_from_as },
 831         { "cast-to-as", &Wcast_to_as },
 832         { "cast-truncate", &Wcast_truncate },
 833         { "constant-suffix", &Wconstant_suffix },
 834         { "constexpr-not-const", &Wconstexpr_not_const},
 835         { "context", &Wcontext },
 836         { "decl", &Wdecl },
 837         { "declaration-after-statement", &Wdeclarationafterstatement },
 838         { "default-bitfield-sign", &Wdefault_bitfield_sign },
 839         { "designated-init", &Wdesignated_init },
 840         { "do-while", &Wdo_while },
 841         { "enum-mismatch", &Wenum_mismatch },
 842         { "external-function-has-definition", &Wexternal_function_has_definition },
 843         { "implicit-int", &Wimplicit_int },
 844         { "init-cstring", &Winit_cstring },
 845         { "int-to-pointer-cast", &Wint_to_pointer_cast },
 846         { "memcpy-max-count", &Wmemcpy_max_count },
 847         { "non-pointer-null", &Wnon_pointer_null },
 848         { "newline-eof", &Wnewline_eof },
 849         { "old-initializer", &Wold_initializer },
 850         { "old-style-definition", &Wold_style_definition },
 851         { "one-bit-signed-bitfield", &Wone_bit_signed_bitfield },
 852         { "override-init", &Woverride_init },
 853         { "override-init-all", &Woverride_init_all },
 854         { "paren-string", &Wparen_string },
 855         { "past-deep-designator", &Wpast_deep_designator },
 856         { "pedantic", &Wpedantic },
 857         { "pointer-to-int-cast", &Wpointer_to_int_cast },
 858         { "ptr-subtraction-blows", &Wptr_subtraction_blows },
 859         { "return-void", &Wreturn_void },
 860         { "shadow", &Wshadow },
 861         { "shift-count-negative", &Wshift_count_negative },
 862         { "shift-count-overflow", &Wshift_count_overflow },
 863         { "sizeof-bool", &Wsizeof_bool },
 864         { "strict-prototypes", &Wstrict_prototypes },
 865         { "pointer-arith", &Wpointer_arith },
 866         { "sparse-error", &Wsparse_error },
 867         { "tautological-compare", &Wtautological_compare },
 868         { "transparent-union", &Wtransparent_union },
 869         { "typesign", &Wtypesign },
 870         { "undef", &Wundef },
 871         { "uninitialized", &Wuninitialized },
 872         { "union-cast", &Wunion_cast },
 873         { "universal-initializer", &Wuniversal_initializer },
 874         { "unknown-attribute", &Wunknown_attribute },
 875         { "vla", &Wvla },
 876         { }
 877 };
 878
 879 static char **handle_switch_W(char *arg, char **next)
 880 {
 881         char ** ret = handle_onoff_switch(arg, next, warnings);
 882         if (ret)
 883                 return ret;
 884
 885         if (!strcmp(arg, "Wsparse-all")) {
 886                 int i;
 887                 for (i = 0; warnings[i].name; i++) {
 888                         if (*warnings[i].flag != FLAG_FORCE_OFF)
 889                                 *warnings[i].flag = FLAG_ON;
 890                 }
 891         }
 892
 893         // Unknown.
 894         return next;
 895 }
 896
 897 static void handle_switch_W_finalize(void)
 898 {
 899         handle_onoff_switch_finalize(warnings);
 900
 901         /* default Wdeclarationafterstatement based on the C dialect */
 902         if (-1 == Wdeclarationafterstatement) {
 903                 switch (standard) {
 904                         case STANDARD_C89:
 905                         case STANDARD_C94:
 906                                 Wdeclarationafterstatement = 1;
 907                                 break;
 908                         default:
 909                                 Wdeclarationafterstatement = 0;
 910                                 break;
 911                 }
 912         }
 913 }
 914
 915 static char **handle_switch_x(char *arg, char **next)
 916 {
 917         if (!*++next)
 918                 die("missing argument for -x option");
 919         return next;
 920 }
 921
 922
 923 static char **handle_arch(char *arg, char **next)
 924 {
 925         enum machine mach;
 926
 927         if (*arg++ != '=')
 928                 die("missing argument for --arch option");
 929
 930         mach = target_parse(arg);
 931         if (mach != MACH_UNKNOWN)
 932                 target_config(mach);
 933
 934         return next;
 935 }
 936
 937 static char **handle_param(char *arg, char **next)
 938 {
 939         char *value = NULL;
 940
 941         /* For now just skip any '--param=*' or '--param *' */
 942         if (*arg == '\0') {
 943                 value = *++next;
 944         } else if (isspace((unsigned char)*arg) || *arg == '=') {
 945                 value = ++arg;
 946         }
 947
 948         if (!value)
 949                 die("missing argument for --param option");
 950
 951         return next;
 952 }
 953
 954 static char **handle_os(char *arg, char **next)
 955 {
 956         if (*arg++ != '=')
 957                 die("missing argument for --os option");
 958
 959         target_os(arg);
 960
 961         return next;
 962 }
 963
 964 static char **handle_version(char *arg, char **next)
 965 {
 966         printf("%s\n", SPARSE_VERSION);
 967         exit(0);
 968 }
 969
 970 struct switches {
 971         const char *name;
 972         char **(*fn)(char *, char **);
 973         unsigned int prefix:1;
 974 };
 975
 976 static char **handle_long_options(char *arg, char **next)
 977 {
 978         static struct switches cmd[] = {
 979                 { "arch", handle_arch, 1 },
 980                 { "os",   handle_os, 1 },
 981                 { "param", handle_param, 1 },
 982                 { "version", handle_version },
 983                 { NULL, NULL }
 984         };
 985         struct switches *s = cmd;
 986
 987         while (s->name) {
 988                 int optlen = strlen(s->name);
 989                 if (!strncmp(s->name, arg, optlen + !s->prefix))
 990                         return s->fn(arg + optlen, next);
 991                 s++;
 992         }
 993         return next;
 994 }
 995
 996 char **handle_switch(char *arg, char **next)
 997 {
 998         switch (*arg) {
 999         case 'a': return handle_switch_a(arg, next);
1000         case 'D': return handle_switch_D(arg, next);
1001         case 'd': return handle_switch_d(arg, next);
1002         case 'E': return handle_switch_E(arg, next);
1003         case 'f': return handle_switch_f(arg, next);
1004         case 'g': return handle_switch_g(arg, next);
1005         case 'G': return handle_switch_G(arg, next);
1006         case 'I': return handle_switch_I(arg, next);
1007         case 'i': return handle_switch_i(arg, next);
1008         case 'M': return handle_switch_M(arg, next);
1009         case 'm': return handle_switch_m(arg, next);
1010         case 'n': return handle_switch_n(arg, next);
1011         case 'o': return handle_switch_o(arg, next);
1012         case 'O': return handle_switch_O(arg, next);
1013         case 'p': return handle_switch_p(arg, next);
1014         case 's': return handle_switch_s(arg, next);
1015         case 'U': return handle_switch_U(arg, next);
1016         case 'v': return handle_switch_v(arg, next);
1017         case 'W': return handle_switch_W(arg, next);
1018         case 'x': return handle_switch_x(arg, next);
1019         case '-': return handle_long_options(arg + 1, next);
1020         default:
1021                 break;
1022         }
1023
1024         /*
1025          * Ignore unknown command line options:
1026          * they're probably gcc switches
1027          */
1028         return next;
1029 }
1030
1031 void handle_switch_finalize(void)
1032 {
1033         handle_switch_v_finalize();
1034         handle_switch_W_finalize();
1035 }