Mercurial > hg > CbC > CbC_gcc

comparison gcc/c-family/c-opts.c @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents 561a7518be6b
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* C/ObjC/C++ command line option handling. 1 /* C/ObjC/C++ command line option handling.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
3 Free Software Foundation, Inc.
4 Contributed by Neil Booth. 3 Contributed by Neil Booth.
5 4
6 This file is part of GCC. 5 This file is part of GCC.
7 6
8 GCC is free software; you can redistribute it and/or modify it under 7 GCC is free software; you can redistribute it and/or modify it under
20 <http://www.gnu.org/licenses/>. */ 19 <http://www.gnu.org/licenses/>. */
21 20
22 #include "config.h" 21 #include "config.h"
23 #include "system.h" 22 #include "system.h"
24 #include "coretypes.h" 23 #include "coretypes.h"
25 #include "tree.h" 24 #include "tm.h"
25 #include "c-target.h"
26 #include "c-common.h" 26 #include "c-common.h"
27 #include "memmodel.h"
28 #include "tm_p.h" /* For C_COMMON_OVERRIDE_OPTIONS. */
29 #include "diagnostic.h"
27 #include "c-pragma.h" 30 #include "c-pragma.h"
28 #include "flags.h" 31 #include "flags.h"
29 #include "toplev.h" 32 #include "toplev.h"
30 #include "langhooks.h" 33 #include "langhooks.h"
31 #include "diagnostic.h" 34 #include "tree-diagnostic.h" /* for virt_loc_aware_diagnostic_finalizer */
32 #include "intl.h" 35 #include "intl.h"
33 #include "cppdefault.h" 36 #include "cppdefault.h"
34 #include "incpath.h" 37 #include "incpath.h"
35 #include "debug.h" /* For debug_hooks. */ 38 #include "debug.h" /* For debug_hooks. */
36 #include "opts.h" 39 #include "opts.h"
37 #include "options.h" 40 #include "plugin.h" /* For PLUGIN_INCLUDE_FILE event. */
38 #include "mkdeps.h" 41 #include "mkdeps.h"
39 #include "target.h" /* For gcc_targetcm. */ 42 #include "dumpfile.h"
40 #include "tm_p.h" /* For C_COMMON_OVERRIDE_OPTIONS. */
41 43
42 #ifndef DOLLARS_IN_IDENTIFIERS 44 #ifndef DOLLARS_IN_IDENTIFIERS
43 # define DOLLARS_IN_IDENTIFIERS true 45 # define DOLLARS_IN_IDENTIFIERS true
44 #endif 46 #endif
45 47
89 static bool std_cxx_inc = true; 91 static bool std_cxx_inc = true;
90 92
91 /* If the quote chain has been split by -I-. */ 93 /* If the quote chain has been split by -I-. */
92 static bool quote_chain_split; 94 static bool quote_chain_split;
93 95
94 /* If -Wunused-macros. */
95 static bool warn_unused_macros;
96
97 /* If -Wvariadic-macros. */
98 static bool warn_variadic_macros = true;
99
100 /* Number of deferred options. */ 96 /* Number of deferred options. */
101 static size_t deferred_count; 97 static size_t deferred_count;
102 98
103 /* Number of deferred options scanned for -include. */ 99 /* Number of deferred options scanned for -include. */
104 static size_t include_cursor; 100 static size_t include_cursor;
105 101
102 /* Dump files/flags to use during parsing. */
103 static FILE *original_dump_file = NULL;
104 static dump_flags_t original_dump_flags;
105
106 /* Whether any standard preincluded header has been preincluded. */
107 static bool done_preinclude;
108
106 static void handle_OPT_d (const char *); 109 static void handle_OPT_d (const char *);
107 static void set_std_cxx98 (int); 110 static void set_std_cxx98 (int);
108 static void set_std_cxx0x (int); 111 static void set_std_cxx11 (int);
112 static void set_std_cxx14 (int);
113 static void set_std_cxx17 (int);
114 static void set_std_cxx2a (int);
109 static void set_std_c89 (int, int); 115 static void set_std_c89 (int, int);
110 static void set_std_c99 (int); 116 static void set_std_c99 (int);
111 static void set_std_c1x (int); 117 static void set_std_c11 (int);
112 static void check_deps_environment_vars (void); 118 static void check_deps_environment_vars (void);
113 static void handle_deferred_opts (void); 119 static void handle_deferred_opts (void);
114 static void sanitize_cpp_opts (void); 120 static void sanitize_cpp_opts (void);
115 static void add_prefixed_path (const char *, size_t); 121 static void add_prefixed_path (const char *, incpath_kind);
116 static void push_command_line_include (void); 122 static void push_command_line_include (void);
117 static void cb_file_change (cpp_reader *, const struct line_map *); 123 static void cb_file_change (cpp_reader *, const line_map_ordinary *);
118 static void cb_dir_change (cpp_reader *, const char *); 124 static void cb_dir_change (cpp_reader *, const char *);
119 static void c_finish_options (void); 125 static void c_finish_options (void);
120 126
121 #ifndef STDC_0_IN_SYSTEM_HEADERS 127 #ifndef STDC_0_IN_SYSTEM_HEADERS
122 #define STDC_0_IN_SYSTEM_HEADERS 0 128 #define STDC_0_IN_SYSTEM_HEADERS 0
151 static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX}; 157 static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
152 158
153 return lang_flags[c_language]; 159 return lang_flags[c_language];
154 } 160 }
155 161
156 /* Common diagnostics initialization. */ 162 /* Diagnostic finalizer for C/C++/Objective-C/Objective-C++. */
163 static void
164 c_diagnostic_finalizer (diagnostic_context *context,
165 diagnostic_info *diagnostic)
166 {
167 diagnostic_show_locus (context, diagnostic->richloc, diagnostic->kind);
168 /* By default print macro expansion contexts in the diagnostic
169 finalizer -- for tokens resulting from macro expansion. */
170 virt_loc_aware_diagnostic_finalizer (context, diagnostic);
171 pp_destroy_prefix (context->printer);
172 pp_flush (context->printer);
173 }
174
175 /* Common default settings for diagnostics. */
157 void 176 void
158 c_common_initialize_diagnostics (diagnostic_context *context) 177 c_common_diagnostics_set_defaults (diagnostic_context *context)
159 { 178 {
160 /* This is conditionalized only because that is the way the front 179 diagnostic_finalizer (context) = c_diagnostic_finalizer;
161 ends used to do it. Maybe this should be unconditional? */
162 if (c_dialect_cxx ())
163 {
164 /* By default wrap lines at 80 characters. Is getenv
165 ("COLUMNS") preferable? */
166 diagnostic_line_cutoff (context) = 80;
167 /* By default, emit location information once for every
168 diagnostic message. */
169 diagnostic_prefixing_rule (context) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
170 }
171
172 context->opt_permissive = OPT_fpermissive; 180 context->opt_permissive = OPT_fpermissive;
173 } 181 }
174 182
175 /* Whether options from all C-family languages should be accepted 183 /* Whether options from all C-family languages should be accepted
176 quietly. */ 184 quietly. */
206 struct cl_decoded_option *decoded_options) 214 struct cl_decoded_option *decoded_options)
207 { 215 {
208 unsigned int i; 216 unsigned int i;
209 struct cpp_callbacks *cb; 217 struct cpp_callbacks *cb;
210 218
219 g_string_concat_db
220 = new (ggc_alloc <string_concat_db> ()) string_concat_db ();
221
211 parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89, 222 parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
212 ident_hash, line_table); 223 ident_hash, line_table);
213 cb = cpp_get_callbacks (parse_in); 224 cb = cpp_get_callbacks (parse_in);
214 cb->error = c_cpp_error; 225 cb->error = c_cpp_error;
215 226
223 234
224 deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count); 235 deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count);
225 236
226 if (c_language == clk_c) 237 if (c_language == clk_c)
227 { 238 {
239 /* The default for C is gnu11. */
240 set_std_c11 (false /* ISO */);
241
228 /* If preprocessing assembly language, accept any of the C-family 242 /* If preprocessing assembly language, accept any of the C-family
229 front end options since the driver may pass them through. */ 243 front end options since the driver may pass them through. */
230 for (i = 1; i < decoded_options_count; i++) 244 for (i = 1; i < decoded_options_count; i++)
231 if (decoded_options[i].opt_index == OPT_lang_asm) 245 if (decoded_options[i].opt_index == OPT_lang_asm)
232 { 246 {
233 accept_all_c_family_options = true; 247 accept_all_c_family_options = true;
234 break; 248 break;
235 } 249 }
236 } 250 }
251
252 /* Set C++ standard to C++14 if not specified on the command line. */
253 if (c_dialect_cxx ())
254 set_std_cxx14 (/*ISO*/false);
255
256 global_dc->colorize_source_p = true;
237 } 257 }
238 258
239 /* Handle switch SCODE with argument ARG. VALUE is true, unless no- 259 /* Handle switch SCODE with argument ARG. VALUE is true, unless no-
240 form of an -f or -W option was given. Returns false if the switch was 260 form of an -f or -W option was given. Returns false if the switch was
241 invalid, true if valid. Use HANDLERS in recursive handle_option calls. */ 261 invalid, true if valid. Use HANDLERS in recursive handle_option calls. */
294 TARGET_OPTF (xstrdup (arg)); 314 TARGET_OPTF (xstrdup (arg));
295 break; 315 break;
296 316
297 case OPT_I: 317 case OPT_I:
298 if (strcmp (arg, "-")) 318 if (strcmp (arg, "-"))
299 add_path (xstrdup (arg), BRACKET, 0, true); 319 add_path (xstrdup (arg), INC_BRACKET, 0, true);
300 else 320 else
301 { 321 {
302 if (quote_chain_split) 322 if (quote_chain_split)
303 error ("-I- specified twice"); 323 error ("-I- specified twice");
304 quote_chain_split = true; 324 quote_chain_split = true;
352 case OPT_U: 372 case OPT_U:
353 defer_opt (code, arg); 373 defer_opt (code, arg);
354 break; 374 break;
355 375
356 case OPT_Wall: 376 case OPT_Wall:
357 warn_unused = value; 377 /* ??? Don't add new options here. Use LangEnabledBy in c.opt. */
358 set_Wformat (value); 378
359 handle_generated_option (&global_options, &global_options_set,
360 OPT_Wimplicit, NULL, value,
361 c_family_lang_mask, kind, loc,
362 handlers, global_dc);
363 warn_char_subscripts = value;
364 warn_missing_braces = value;
365 warn_parentheses = value;
366 warn_return_type = value;
367 warn_sequence_point = value; /* Was C only. */
368 warn_switch = value;
369 if (warn_strict_aliasing == -1)
370 set_Wstrict_aliasing (&global_options, value);
371 warn_address = value;
372 if (warn_strict_overflow == -1)
373 warn_strict_overflow = value;
374 warn_array_bounds = value;
375 warn_volatile_register_var = value;
376
377 /* Only warn about unknown pragmas that are not in system
378 headers. */
379 warn_unknown_pragmas = value;
380
381 warn_uninitialized = value;
382
383 if (!c_dialect_cxx ())
384 {
385 /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding
386 can turn it off only if it's not explicit. */
387 if (warn_main == -1)
388 warn_main = (value ? 2 : 0);
389
390 /* In C, -Wall turns on -Wenum-compare, which we do here.
391 In C++ it is on by default, which is done in
392 c_common_post_options. */
393 if (warn_enum_compare == -1)
394 warn_enum_compare = value;
395 }
396 else
397 {
398 /* C++-specific warnings. */
399 warn_sign_compare = value;
400 warn_reorder = value;
401 warn_cxx0x_compat = value;
402 }
403
404 cpp_opts->warn_trigraphs = value;
405 cpp_opts->warn_comments = value;
406 cpp_opts->warn_num_sign_change = value; 379 cpp_opts->warn_num_sign_change = value;
407 380 break;
408 if (warn_pointer_sign == -1) 381
409 warn_pointer_sign = value; 382 case OPT_Walloca_larger_than_:
410 break; 383 if (!value)
411 384 inform (loc, "-Walloca-larger-than=0 is meaningless");
412 case OPT_Wbuiltin_macro_redefined: 385 break;
413 cpp_opts->warn_builtin_macro_redefined = value; 386
414 break; 387 case OPT_Wvla_larger_than_:
415 388 if (!value)
416 case OPT_Wcomment: 389 inform (loc, "-Wvla-larger-than=0 is meaningless");
417 cpp_opts->warn_comments = value;
418 break;
419
420 case OPT_Wc___compat:
421 /* Because -Wenum-compare is the default in C++, -Wc++-compat
422 implies -Wenum-compare. */
423 if (warn_enum_compare == -1 && value)
424 warn_enum_compare = value;
425 /* Because C++ always warns about a goto which misses an
426 initialization, -Wc++-compat turns on -Wjump-misses-init. */
427 if (warn_jump_misses_init == -1 && value)
428 warn_jump_misses_init = value;
429 cpp_opts->warn_cxx_operator_names = value;
430 break;
431
432 case OPT_Wdeprecated:
433 cpp_opts->cpp_warn_deprecated = value;
434 break;
435
436 case OPT_Wendif_labels:
437 cpp_opts->warn_endif_labels = value;
438 break;
439
440 case OPT_Werror:
441 global_dc->warning_as_error_requested = value;
442 break;
443
444 case OPT_Wformat:
445 set_Wformat (value);
446 break;
447
448 case OPT_Wformat_:
449 set_Wformat (atoi (arg));
450 break;
451
452 case OPT_Wimplicit:
453 gcc_assert (value == 0 || value == 1);
454 if (warn_implicit_int == -1)
455 handle_generated_option (&global_options, &global_options_set,
456 OPT_Wimplicit_int, NULL, value,
457 c_family_lang_mask, kind, loc, handlers,
458 global_dc);
459 if (warn_implicit_function_declaration == -1)
460 handle_generated_option (&global_options, &global_options_set,
461 OPT_Wimplicit_function_declaration, NULL,
462 value, c_family_lang_mask, kind, loc,
463 handlers, global_dc);
464 break;
465
466 case OPT_Winvalid_pch:
467 cpp_opts->warn_invalid_pch = value;
468 break;
469
470 case OPT_Wlong_long:
471 cpp_opts->cpp_warn_long_long = value;
472 break;
473
474 case OPT_Wmissing_include_dirs:
475 cpp_opts->warn_missing_include_dirs = value;
476 break;
477
478 case OPT_Wmultichar:
479 cpp_opts->warn_multichar = value;
480 break;
481
482 case OPT_Wnormalized_:
483 if (kind == DK_ERROR)
484 {
485 gcc_assert (!arg);
486 inform (input_location, "-Werror=normalized=: set -Wnormalized=nfc");
487 cpp_opts->warn_normalize = normalized_C;
488 }
489 else
490 {
491 if (!value || (arg && strcasecmp (arg, "none") == 0))
492 cpp_opts->warn_normalize = normalized_none;
493 else if (!arg || strcasecmp (arg, "nfkc") == 0)
494 cpp_opts->warn_normalize = normalized_KC;
495 else if (strcasecmp (arg, "id") == 0)
496 cpp_opts->warn_normalize = normalized_identifier_C;
497 else if (strcasecmp (arg, "nfc") == 0)
498 cpp_opts->warn_normalize = normalized_C;
499 else
500 error ("argument %qs to %<-Wnormalized%> not recognized", arg);
501 break;
502 }
503
504 case OPT_Wreturn_type:
505 warn_return_type = value;
506 break;
507
508 case OPT_Wtraditional:
509 cpp_opts->cpp_warn_traditional = value;
510 break;
511
512 case OPT_Wtrigraphs:
513 cpp_opts->warn_trigraphs = value;
514 break;
515
516 case OPT_Wundef:
517 cpp_opts->warn_undef = value;
518 break; 390 break;
519 391
520 case OPT_Wunknown_pragmas: 392 case OPT_Wunknown_pragmas:
521 /* Set to greater than 1, so that even unknown pragmas in 393 /* Set to greater than 1, so that even unknown pragmas in
522 system headers will be warned about. */ 394 system headers will be warned about. */
395 /* ??? There is no way to handle this automatically for now. */
523 warn_unknown_pragmas = value * 2; 396 warn_unknown_pragmas = value * 2;
524 break;
525
526 case OPT_Wunused_macros:
527 warn_unused_macros = value;
528 break;
529
530 case OPT_Wvariadic_macros:
531 warn_variadic_macros = value;
532 break;
533
534 case OPT_Wwrite_strings:
535 warn_write_strings = value;
536 break;
537
538 case OPT_Weffc__:
539 warn_ecpp = value;
540 if (value)
541 warn_nonvdtor = true;
542 break; 397 break;
543 398
544 case OPT_ansi: 399 case OPT_ansi:
545 if (!c_dialect_cxx ()) 400 if (!c_dialect_cxx ())
546 set_std_c89 (false, true); 401 set_std_c89 (false, true);
548 set_std_cxx98 (true); 403 set_std_cxx98 (true);
549 break; 404 break;
550 405
551 case OPT_d: 406 case OPT_d:
552 handle_OPT_d (arg); 407 handle_OPT_d (arg);
408 break;
409
410 case OPT_Wabi_:
411 warn_abi = true;
412 if (value == 1)
413 {
414 warning (0, "%<-Wabi=1%> is not supported, using =2");
415 value = 2;
416 }
417 warn_abi_version = value;
418 if (flag_abi_compat_version == -1)
419 flag_abi_compat_version = value;
420 break;
421
422 case OPT_fcanonical_system_headers:
423 cpp_opts->canonical_system_headers = value;
553 break; 424 break;
554 425
555 case OPT_fcond_mismatch: 426 case OPT_fcond_mismatch:
556 if (!c_dialect_cxx ()) 427 if (!c_dialect_cxx ())
557 { 428 {
576 cpp_opts->dollars_in_ident = value; 447 cpp_opts->dollars_in_ident = value;
577 break; 448 break;
578 449
579 case OPT_ffreestanding: 450 case OPT_ffreestanding:
580 value = !value; 451 value = !value;
581 /* Fall through.... */ 452 /* Fall through. */
582 case OPT_fhosted: 453 case OPT_fhosted:
583 flag_hosted = value; 454 flag_hosted = value;
584 flag_no_builtin = !value; 455 flag_no_builtin = !value;
585 break; 456 break;
586 457
590 461
591 case OPT_fextended_identifiers: 462 case OPT_fextended_identifiers:
592 cpp_opts->extended_identifiers = value; 463 cpp_opts->extended_identifiers = value;
593 break; 464 break;
594 465
595 case OPT_fgnu_runtime:
596 flag_next_runtime = !value;
597 break;
598
599 case OPT_fnext_runtime:
600 flag_next_runtime = value;
601 break;
602
603 case OPT_foperator_names: 466 case OPT_foperator_names:
604 cpp_opts->operator_names = value; 467 cpp_opts->operator_names = value;
605 break; 468 break;
606 469
607 case OPT_fpch_deps: 470 case OPT_fpch_deps:
617 global_dc->permissive = value; 480 global_dc->permissive = value;
618 break; 481 break;
619 482
620 case OPT_fpreprocessed: 483 case OPT_fpreprocessed:
621 cpp_opts->preprocessed = value; 484 cpp_opts->preprocessed = value;
485 break;
486
487 case OPT_fdebug_cpp:
488 cpp_opts->debug = 1;
489 break;
490
491 case OPT_ftrack_macro_expansion:
492 if (value)
493 value = 2;
494 /* Fall Through. */
495
496 case OPT_ftrack_macro_expansion_:
497 if (arg && *arg != '\0')
498 cpp_opts->track_macro_expansion = value;
499 else
500 cpp_opts->track_macro_expansion = 2;
622 break; 501 break;
623 502
624 case OPT_frepo: 503 case OPT_frepo:
625 flag_use_repository = value; 504 flag_use_repository = value;
626 if (value) 505 if (value)
664 543
665 case OPT_femit_struct_debug_detailed_: 544 case OPT_femit_struct_debug_detailed_:
666 set_struct_debug_option (&global_options, loc, arg); 545 set_struct_debug_option (&global_options, loc, arg);
667 break; 546 break;
668 547
548 case OPT_fext_numeric_literals:
549 cpp_opts->ext_numeric_literals = value;
550 break;
551
669 case OPT_idirafter: 552 case OPT_idirafter:
670 add_path (xstrdup (arg), AFTER, 0, true); 553 add_path (xstrdup (arg), INC_AFTER, 0, true);
671 break; 554 break;
672 555
673 case OPT_imacros: 556 case OPT_imacros:
674 case OPT_include: 557 case OPT_include:
675 defer_opt (code, arg); 558 defer_opt (code, arg);
682 case OPT_iprefix: 565 case OPT_iprefix:
683 iprefix = arg; 566 iprefix = arg;
684 break; 567 break;
685 568
686 case OPT_iquote: 569 case OPT_iquote:
687 add_path (xstrdup (arg), QUOTE, 0, true); 570 add_path (xstrdup (arg), INC_QUOTE, 0, true);
688 break; 571 break;
689 572
690 case OPT_isysroot: 573 case OPT_isysroot:
691 sysroot = arg; 574 sysroot = arg;
692 break; 575 break;
693 576
694 case OPT_isystem: 577 case OPT_isystem:
695 add_path (xstrdup (arg), SYSTEM, 0, true); 578 add_path (xstrdup (arg), INC_SYSTEM, 0, true);
696 break; 579 break;
697 580
698 case OPT_iwithprefix: 581 case OPT_iwithprefix:
699 add_prefixed_path (arg, SYSTEM); 582 add_prefixed_path (arg, INC_SYSTEM);
700 break; 583 break;
701 584
702 case OPT_iwithprefixbefore: 585 case OPT_iwithprefixbefore:
703 add_prefixed_path (arg, BRACKET); 586 add_prefixed_path (arg, INC_BRACKET);
704 break; 587 break;
705 588
706 case OPT_lang_asm: 589 case OPT_lang_asm:
707 cpp_set_lang (parse_in, CLK_ASM); 590 cpp_set_lang (parse_in, CLK_ASM);
708 cpp_opts->dollars_in_ident = false; 591 cpp_opts->dollars_in_ident = false;
721 out_fname = arg; 604 out_fname = arg;
722 else 605 else
723 error ("output filename specified twice"); 606 error ("output filename specified twice");
724 break; 607 break;
725 608
726 /* We need to handle the -pedantic switches here, rather than in
727 c_common_post_options, so that a subsequent -Wno-endif-labels
728 is not overridden. */
729 case OPT_pedantic_errors:
730 case OPT_pedantic:
731 cpp_opts->cpp_pedantic = 1;
732 cpp_opts->warn_endif_labels = 1;
733 if (warn_pointer_sign == -1)
734 warn_pointer_sign = 1;
735 if (warn_overlength_strings == -1)
736 warn_overlength_strings = 1;
737 if (warn_main == -1)
738 warn_main = 2;
739 break;
740
741 case OPT_print_objc_runtime_info: 609 case OPT_print_objc_runtime_info:
742 print_struct_values = 1; 610 print_struct_values = 1;
743 break; 611 break;
744 612
745 case OPT_remap: 613 case OPT_remap:
750 case OPT_std_gnu__98: 618 case OPT_std_gnu__98:
751 if (!preprocessing_asm_p) 619 if (!preprocessing_asm_p)
752 set_std_cxx98 (code == OPT_std_c__98 /* ISO */); 620 set_std_cxx98 (code == OPT_std_c__98 /* ISO */);
753 break; 621 break;
754 622
755 case OPT_std_c__0x: 623 case OPT_std_c__11:
756 case OPT_std_gnu__0x: 624 case OPT_std_gnu__11:
757 if (!preprocessing_asm_p) 625 if (!preprocessing_asm_p)
758 set_std_cxx0x (code == OPT_std_c__0x /* ISO */); 626 set_std_cxx11 (code == OPT_std_c__11 /* ISO */);
627 break;
628
629 case OPT_std_c__14:
630 case OPT_std_gnu__14:
631 if (!preprocessing_asm_p)
632 set_std_cxx14 (code == OPT_std_c__14 /* ISO */);
633 break;
634
635 case OPT_std_c__17:
636 case OPT_std_gnu__17:
637 if (!preprocessing_asm_p)
638 set_std_cxx17 (code == OPT_std_c__17 /* ISO */);
639 break;
640
641 case OPT_std_c__2a:
642 case OPT_std_gnu__2a:
643 if (!preprocessing_asm_p)
644 set_std_cxx2a (code == OPT_std_c__2a /* ISO */);
759 break; 645 break;
760 646
761 case OPT_std_c90: 647 case OPT_std_c90:
762 case OPT_std_iso9899_199409: 648 case OPT_std_iso9899_199409:
763 if (!preprocessing_asm_p) 649 if (!preprocessing_asm_p)
777 case OPT_std_gnu99: 663 case OPT_std_gnu99:
778 if (!preprocessing_asm_p) 664 if (!preprocessing_asm_p)
779 set_std_c99 (false /* ISO */); 665 set_std_c99 (false /* ISO */);
780 break; 666 break;
781 667
782 case OPT_std_c1x: 668 case OPT_std_c11:
783 if (!preprocessing_asm_p) 669 if (!preprocessing_asm_p)
784 set_std_c1x (true /* ISO */); 670 set_std_c11 (true /* ISO */);
785 break; 671 break;
786 672
787 case OPT_std_gnu1x: 673 case OPT_std_gnu11:
788 if (!preprocessing_asm_p) 674 if (!preprocessing_asm_p)
789 set_std_c1x (false /* ISO */); 675 set_std_c11 (false /* ISO */);
790 break; 676 break;
791 677
792 case OPT_trigraphs: 678 case OPT_trigraphs:
793 cpp_opts->trigraphs = 1; 679 cpp_opts->trigraphs = 1;
794 break; 680 break;
798 break; 684 break;
799 685
800 case OPT_v: 686 case OPT_v:
801 verbose = true; 687 verbose = true;
802 break; 688 break;
803 689 }
804 case OPT_Wabi: 690
805 warn_psabi = value; 691 switch (c_language)
806 break; 692 {
807 } 693 case clk_c:
808 694 C_handle_option_auto (&global_options, &global_options_set,
695 scode, arg, value,
696 c_family_lang_mask, kind,
697 loc, handlers, global_dc);
698 break;
699
700 case clk_objc:
701 ObjC_handle_option_auto (&global_options, &global_options_set,
702 scode, arg, value,
703 c_family_lang_mask, kind,
704 loc, handlers, global_dc);
705 break;
706
707 case clk_cxx:
708 CXX_handle_option_auto (&global_options, &global_options_set,
709 scode, arg, value,
710 c_family_lang_mask, kind,
711 loc, handlers, global_dc);
712 break;
713
714 case clk_objcxx:
715 ObjCXX_handle_option_auto (&global_options, &global_options_set,
716 scode, arg, value,
717 c_family_lang_mask, kind,
718 loc, handlers, global_dc);
719 break;
720
721 default:
722 gcc_unreachable ();
723 }
724
725 cpp_handle_option_auto (&global_options, scode, cpp_opts);
809 return result; 726 return result;
727 }
728
729 /* Default implementation of TARGET_HANDLE_C_OPTION. */
730
731 bool
732 default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
733 const char *arg ATTRIBUTE_UNUSED,
734 int value ATTRIBUTE_UNUSED)
735 {
736 return false;
810 } 737 }
811 738
812 /* Post-switch processing. */ 739 /* Post-switch processing. */
813 bool 740 bool
814 c_common_post_options (const char **pfilename) 741 c_common_post_options (const char **pfilename)
820 { 747 {
821 in_fnames = XNEWVEC (const char *, 1); 748 in_fnames = XNEWVEC (const char *, 1);
822 in_fnames[0] = ""; 749 in_fnames[0] = "";
823 } 750 }
824 else if (strcmp (in_fnames[0], "-") == 0) 751 else if (strcmp (in_fnames[0], "-") == 0)
825 in_fnames[0] = ""; 752 {
753 if (pch_file)
754 error ("cannot use %<-%> as input filename for a precompiled header");
755
756 in_fnames[0] = "";
757 }
826 758
827 if (out_fname == NULL || !strcmp (out_fname, "-")) 759 if (out_fname == NULL || !strcmp (out_fname, "-"))
828 out_fname = ""; 760 out_fname = "";
829 761
830 if (cpp_opts->deps.style == DEPS_NONE) 762 if (cpp_opts->deps.style == DEPS_NONE)
845 777
846 /* Excess precision other than "fast" requires front-end 778 /* Excess precision other than "fast" requires front-end
847 support. */ 779 support. */
848 if (c_dialect_cxx ()) 780 if (c_dialect_cxx ())
849 { 781 {
850 if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD 782 if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD)
851 && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
852 sorry ("-fexcess-precision=standard for C++"); 783 sorry ("-fexcess-precision=standard for C++");
853 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; 784 flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
854 } 785 }
855 else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT) 786 else if (flag_excess_precision_cmdline == EXCESS_PRECISION_DEFAULT)
856 flag_excess_precision_cmdline = (flag_iso 787 flag_excess_precision_cmdline = (flag_iso
857 ? EXCESS_PRECISION_STANDARD 788 ? EXCESS_PRECISION_STANDARD
858 : EXCESS_PRECISION_FAST); 789 : EXCESS_PRECISION_FAST);
790
791 /* ISO C restricts floating-point expression contraction to within
792 source-language expressions (-ffp-contract=on, currently an alias
793 for -ffp-contract=off). */
794 if (flag_iso
795 && !c_dialect_cxx ()
796 && (global_options_set.x_flag_fp_contract_mode
797 == (enum fp_contract_mode) 0)
798 && flag_unsafe_math_optimizations == 0)
799 flag_fp_contract_mode = FP_CONTRACT_OFF;
800
801 /* If we are compiling C, and we are outside of a standards mode,
802 we can permit the new values from ISO/IEC TS 18661-3 for
803 FLT_EVAL_METHOD. Otherwise, we must restrict the possible values to
804 the set specified in ISO C99/C11. */
805 if (!flag_iso
806 && !c_dialect_cxx ()
807 && (global_options_set.x_flag_permitted_flt_eval_methods
808 == PERMITTED_FLT_EVAL_METHODS_DEFAULT))
809 flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_TS_18661;
810 else
811 flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_C11;
859 812
860 /* By default we use C99 inline semantics in GNU99 or C99 mode. C99 813 /* By default we use C99 inline semantics in GNU99 or C99 mode. C99
861 inline semantics are not supported in GNU89 or C89 mode. */ 814 inline semantics are not supported in GNU89 or C89 mode. */
862 if (flag_gnu89_inline == -1) 815 if (flag_gnu89_inline == -1)
863 flag_gnu89_inline = !flag_isoc99; 816 flag_gnu89_inline = !flag_isoc99;
868 if (flag_objc_sjlj_exceptions < 0) 821 if (flag_objc_sjlj_exceptions < 0)
869 flag_objc_sjlj_exceptions = flag_next_runtime; 822 flag_objc_sjlj_exceptions = flag_next_runtime;
870 if (flag_objc_exceptions && !flag_objc_sjlj_exceptions) 823 if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
871 flag_exceptions = 1; 824 flag_exceptions = 1;
872 825
873 /* -Wextra implies the following flags 826 /* If -ffreestanding, -fno-hosted or -fno-builtin then disable
874 unless explicitly overridden. */ 827 pattern recognition. */
875 if (warn_type_limits == -1) 828 if (!global_options_set.x_flag_tree_loop_distribute_patterns
876 warn_type_limits = extra_warnings; 829 && flag_no_builtin)
877 if (warn_clobbered == -1) 830 flag_tree_loop_distribute_patterns = 0;
878 warn_clobbered = extra_warnings; 831
879 if (warn_empty_body == -1) 832 /* -Woverlength-strings is off by default, but is enabled by -Wpedantic.
880 warn_empty_body = extra_warnings;
881 if (warn_sign_compare == -1)
882 warn_sign_compare = extra_warnings;
883 if (warn_missing_field_initializers == -1)
884 warn_missing_field_initializers = extra_warnings;
885 if (warn_missing_parameter_type == -1)
886 warn_missing_parameter_type = extra_warnings;
887 if (warn_old_style_declaration == -1)
888 warn_old_style_declaration = extra_warnings;
889 if (warn_override_init == -1)
890 warn_override_init = extra_warnings;
891 if (warn_ignored_qualifiers == -1)
892 warn_ignored_qualifiers = extra_warnings;
893
894 /* -Wpointer-sign is disabled by default, but it is enabled if any
895 of -Wall or -pedantic are given. */
896 if (warn_pointer_sign == -1)
897 warn_pointer_sign = 0;
898
899 if (warn_strict_aliasing == -1)
900 warn_strict_aliasing = 0;
901 if (warn_strict_overflow == -1)
902 warn_strict_overflow = 0;
903 if (warn_jump_misses_init == -1)
904 warn_jump_misses_init = 0;
905
906 /* -Woverlength-strings is off by default, but is enabled by -pedantic.
907 It is never enabled in C++, as the minimum limit is not normative 833 It is never enabled in C++, as the minimum limit is not normative
908 in that standard. */ 834 in that standard. */
909 if (warn_overlength_strings == -1 || c_dialect_cxx ()) 835 if (c_dialect_cxx ())
910 warn_overlength_strings = 0; 836 warn_overlength_strings = 0;
911 837
912 /* Wmain is enabled by default in C++ but not in C. */ 838 /* Wmain is enabled by default in C++ but not in C. */
913 /* Wmain is disabled by default for -ffreestanding (!flag_hosted), 839 /* Wmain is disabled by default for -ffreestanding (!flag_hosted),
914 even if -Wall was given (warn_main will be 2 if set by -Wall, 1 840 even if -Wall or -Wpedantic was given (warn_main will be 2 if set
915 if set by -Wmain). */ 841 by -Wall, 1 if set by -Wmain). */
916 if (warn_main == -1) 842 if (warn_main == -1)
917 warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0; 843 warn_main = (c_dialect_cxx () && flag_hosted) ? 1 : 0;
918 else if (warn_main == 2) 844 else if (warn_main == 2)
919 warn_main = flag_hosted ? 1 : 0; 845 warn_main = flag_hosted ? 1 : 0;
920 846
921 /* In C, -Wconversion enables -Wsign-conversion (unless disabled 847 /* In C, -Wall and -Wc++-compat enable -Wenum-compare; if it has not
922 through -Wno-sign-conversion). While in C++, 848 yet been set, it is disabled by default. In C++, it is enabled
923 -Wsign-conversion needs to be requested explicitly. */ 849 by default. */
924 if (warn_sign_conversion == -1)
925 warn_sign_conversion = (c_dialect_cxx ()) ? 0 : warn_conversion;
926
927 /* In C, -Wall and -Wc++-compat enable -Wenum-compare, which we do
928 in c_common_handle_option; if it has not yet been set, it is
929 disabled by default. In C++, it is enabled by default. */
930 if (warn_enum_compare == -1) 850 if (warn_enum_compare == -1)
931 warn_enum_compare = c_dialect_cxx () ? 1 : 0; 851 warn_enum_compare = c_dialect_cxx () ? 1 : 0;
932 852
933 /* -Wpacked-bitfield-compat is on by default for the C languages. The 853 /* -Wpacked-bitfield-compat is on by default for the C languages. The
934 warning is issued in stor-layout.c which is not part of the front-end so 854 warning is issued in stor-layout.c which is not part of the front-end so
952 "-Wformat-contains-nul ignored without -Wformat"); 872 "-Wformat-contains-nul ignored without -Wformat");
953 warning (OPT_Wformat_security, 873 warning (OPT_Wformat_security,
954 "-Wformat-security ignored without -Wformat"); 874 "-Wformat-security ignored without -Wformat");
955 } 875 }
956 876
957 if (warn_implicit == -1)
958 warn_implicit = 0;
959
960 if (warn_implicit_int == -1)
961 warn_implicit_int = 0;
962
963 /* -Wimplicit-function-declaration is enabled by default for C99. */ 877 /* -Wimplicit-function-declaration is enabled by default for C99. */
964 if (warn_implicit_function_declaration == -1) 878 if (warn_implicit_function_declaration == -1)
965 warn_implicit_function_declaration = flag_isoc99; 879 warn_implicit_function_declaration = flag_isoc99;
966 880
967 /* If we're allowing C++0x constructs, don't warn about C++0x 881 /* -Wimplicit-int is enabled by default for C99. */
968 compatibility problems. */ 882 if (warn_implicit_int == -1)
969 if (cxx_dialect == cxx0x) 883 warn_implicit_int = flag_isoc99;
970 warn_cxx0x_compat = 0; 884
885 /* -Wshift-overflow is enabled by default in C99 and C++11 modes. */
886 if (warn_shift_overflow == -1)
887 warn_shift_overflow = cxx_dialect >= cxx11 || flag_isoc99;
888
889 /* -Wshift-negative-value is enabled by -Wextra in C99 and C++11 modes. */
890 if (warn_shift_negative_value == -1)
891 warn_shift_negative_value = (extra_warnings
892 && (cxx_dialect >= cxx11 || flag_isoc99));
893
894 /* -Wregister is enabled by default in C++17. */
895 if (!global_options_set.x_warn_register)
896 warn_register = cxx_dialect >= cxx17;
897
898 /* Declone C++ 'structors if -Os. */
899 if (flag_declone_ctor_dtor == -1)
900 flag_declone_ctor_dtor = optimize_size;
901
902 if (warn_abi_version == -1)
903 {
904 if (flag_abi_compat_version != -1)
905 warn_abi_version = flag_abi_compat_version;
906 else
907 warn_abi_version = 0;
908 }
909
910 if (flag_abi_compat_version == 1)
911 {
912 warning (0, "%<-fabi-compat-version=1%> is not supported, using =2");
913 flag_abi_compat_version = 2;
914 }
915 else if (flag_abi_compat_version == -1)
916 {
917 /* Generate compatibility aliases for ABI v11 (7.1) by default. */
918 flag_abi_compat_version
919 = (flag_abi_version == 0 ? 11 : 0);
920 }
921
922 /* Change flag_abi_version to be the actual current ABI level for the
923 benefit of c_cpp_builtins. */
924 if (flag_abi_version == 0)
925 flag_abi_version = 12;
926
927 /* By default, enable the new inheriting constructor semantics along with ABI
928 11. New and old should coexist fine, but it is a change in what
929 artificial symbols are generated. */
930 if (!global_options_set.x_flag_new_inheriting_ctors)
931 flag_new_inheriting_ctors = abi_version_at_least (11);
932
933 /* For GCC 7, only enable DR150 resolution by default if -std=c++17. */
934 if (!global_options_set.x_flag_new_ttp)
935 flag_new_ttp = (cxx_dialect >= cxx17);
936
937 if (cxx_dialect >= cxx11)
938 {
939 /* If we're allowing C++0x constructs, don't warn about C++98
940 identifiers which are keywords in C++0x. */
941 warn_cxx11_compat = 0;
942 cpp_opts->cpp_warn_cxx11_compat = 0;
943
944 if (warn_narrowing == -1)
945 warn_narrowing = 1;
946
947 /* Unless -f{,no-}ext-numeric-literals has been used explicitly,
948 for -std=c++{11,14,17,2a} default to -fno-ext-numeric-literals. */
949 if (flag_iso && !global_options_set.x_flag_ext_numeric_literals)
950 cpp_opts->ext_numeric_literals = 0;
951 }
952 else if (warn_narrowing == -1)
953 warn_narrowing = 0;
954
955 /* C++17 has stricter evaluation order requirements; let's use some of them
956 for earlier C++ as well, so chaining works as expected. */
957 if (c_dialect_cxx ()
958 && flag_strong_eval_order == -1)
959 flag_strong_eval_order = (cxx_dialect >= cxx17 ? 2 : 1);
960
961 /* Global sized deallocation is new in C++14. */
962 if (flag_sized_deallocation == -1)
963 flag_sized_deallocation = (cxx_dialect >= cxx14);
964
965 if (flag_extern_tls_init)
966 {
967 if (!TARGET_SUPPORTS_ALIASES || !SUPPORTS_WEAK)
968 {
969 /* Lazy TLS initialization for a variable in another TU requires
970 alias and weak reference support. */
971 if (flag_extern_tls_init > 0)
972 sorry ("external TLS initialization functions not supported "
973 "on this target");
974
975 flag_extern_tls_init = 0;
976 }
977 else
978 flag_extern_tls_init = 1;
979 }
980
981 if (num_in_fnames > 1)
982 error ("too many filenames given. Type %s --help for usage",
983 progname);
971 984
972 if (flag_preprocess_only) 985 if (flag_preprocess_only)
973 { 986 {
974 /* Open the output now. We must do so even if flag_no_output is 987 /* Open the output now. We must do so even if flag_no_output is
975 on, because there may be other output than from the actual 988 on, because there may be other output than from the actual
979 else 992 else
980 out_stream = fopen (out_fname, "w"); 993 out_stream = fopen (out_fname, "w");
981 994
982 if (out_stream == NULL) 995 if (out_stream == NULL)
983 { 996 {
984 fatal_error ("opening output file %s: %m", out_fname); 997 fatal_error (input_location, "opening output file %s: %m", out_fname);
985 return false; 998 return false;
986 } 999 }
987
988 if (num_in_fnames > 1)
989 error ("too many filenames given. Type %s --help for usage",
990 progname);
991 1000
992 init_pp_output (out_stream); 1001 init_pp_output (out_stream);
993 } 1002 }
994 else 1003 else
995 { 1004 {
997 1006
998 /* When writing a PCH file, avoid reading some other PCH file, 1007 /* When writing a PCH file, avoid reading some other PCH file,
999 because the default address space slot then can't be used 1008 because the default address space slot then can't be used
1000 for the output PCH file. */ 1009 for the output PCH file. */
1001 if (pch_file) 1010 if (pch_file)
1011 {
1012 c_common_no_more_pch ();
1013 /* Only -g0 and -gdwarf* are supported with PCH, for other
1014 debug formats we warn here and refuse to load any PCH files. */
1015 if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
1016 warning (OPT_Wdeprecated,
1017 "the \"%s\" debug format cannot be used with "
1018 "pre-compiled headers", debug_type_names[write_symbols]);
1019 }
1020 else if (write_symbols != NO_DEBUG && write_symbols != DWARF2_DEBUG)
1002 c_common_no_more_pch (); 1021 c_common_no_more_pch ();
1003 1022
1004 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */ 1023 /* Yuk. WTF is this? I do know ObjC relies on it somewhere. */
1005 input_location = UNKNOWN_LOCATION; 1024 input_location = UNKNOWN_LOCATION;
1006 } 1025 }
1007 1026
1008 cb = cpp_get_callbacks (parse_in); 1027 cb = cpp_get_callbacks (parse_in);
1009 cb->file_change = cb_file_change; 1028 cb->file_change = cb_file_change;
1010 cb->dir_change = cb_dir_change; 1029 cb->dir_change = cb_dir_change;
1011 cpp_post_options (parse_in); 1030 cpp_post_options (parse_in);
1031 init_global_opts_from_cpp (&global_options, cpp_get_options (parse_in));
1012 1032
1013 input_location = UNKNOWN_LOCATION; 1033 input_location = UNKNOWN_LOCATION;
1014 1034
1015 *pfilename = this_input_filename 1035 *pfilename = this_input_filename
1016 = cpp_read_main_file (parse_in, in_fnames[0]); 1036 = cpp_read_main_file (parse_in, in_fnames[0]);
1022 } 1042 }
1023 1043
1024 if (flag_working_directory 1044 if (flag_working_directory
1025 && flag_preprocess_only && !flag_no_line_commands) 1045 && flag_preprocess_only && !flag_no_line_commands)
1026 pp_dir_change (parse_in, get_src_pwd ()); 1046 pp_dir_change (parse_in, get_src_pwd ());
1047
1048 /* Disable LTO output when outputting a precompiled header. */
1049 if (pch_file && flag_lto)
1050 {
1051 flag_lto = 0;
1052 flag_generate_lto = 0;
1053 }
1027 1054
1028 return flag_preprocess_only; 1055 return flag_preprocess_only;
1029 } 1056 }
1030 1057
1031 /* Front end initialization common to C, ObjC and C++. */ 1058 /* Front end initialization common to C, ObjC and C++. */
1044 /* This can't happen until after wchar_precision and bytes_big_endian 1071 /* This can't happen until after wchar_precision and bytes_big_endian
1045 are known. */ 1072 are known. */
1046 cpp_init_iconv (parse_in); 1073 cpp_init_iconv (parse_in);
1047 1074
1048 if (version_flag) 1075 if (version_flag)
1049 c_common_print_pch_checksum (stderr); 1076 {
1077 int i;
1078 fputs ("Compiler executable checksum: ", stderr);
1079 for (i = 0; i < 16; i++)
1080 fprintf (stderr, "%02x", executable_checksum[i]);
1081 putc ('\n', stderr);
1082 }
1050 1083
1051 /* Has to wait until now so that cpplib has its hash table. */ 1084 /* Has to wait until now so that cpplib has its hash table. */
1052 init_pragma (); 1085 init_pragma ();
1053 1086
1054 if (flag_preprocess_only) 1087 if (flag_preprocess_only)
1070 1103
1071 i = 0; 1104 i = 0;
1072 for (;;) 1105 for (;;)
1073 { 1106 {
1074 c_finish_options (); 1107 c_finish_options ();
1108 /* Open the dump file to use for the original dump output
1109 here, to be used during parsing for the current file. */
1110 original_dump_file = dump_begin (TDI_original, &original_dump_flags);
1075 pch_init (); 1111 pch_init ();
1076 push_file_scope (); 1112 push_file_scope ();
1077 c_parse_file (); 1113 c_parse_file ();
1078 pop_file_scope (); 1114 pop_file_scope ();
1079 /* And end the main input file, if the debug writer wants it */ 1115 /* And end the main input file, if the debug writer wants it */
1083 break; 1119 break;
1084 cpp_undef_all (parse_in); 1120 cpp_undef_all (parse_in);
1085 cpp_clear_file_cache (parse_in); 1121 cpp_clear_file_cache (parse_in);
1086 this_input_filename 1122 this_input_filename
1087 = cpp_read_main_file (parse_in, in_fnames[i]); 1123 = cpp_read_main_file (parse_in, in_fnames[i]);
1124 if (original_dump_file)
1125 {
1126 dump_end (TDI_original, original_dump_file);
1127 original_dump_file = NULL;
1128 }
1088 /* If an input file is missing, abandon further compilation. 1129 /* If an input file is missing, abandon further compilation.
1089 cpplib has issued a diagnostic. */ 1130 cpplib has issued a diagnostic. */
1090 if (!this_input_filename) 1131 if (!this_input_filename)
1091 break; 1132 break;
1092 } 1133 }
1134
1135 c_parse_final_cleanups ();
1136 }
1137
1138 /* Returns the appropriate dump file for PHASE to dump with FLAGS. */
1139
1140 FILE *
1141 get_dump_info (int phase, dump_flags_t *flags)
1142 {
1143 gcc_assert (phase == TDI_original);
1144
1145 *flags = original_dump_flags;
1146 return original_dump_file;
1093 } 1147 }
1094 1148
1095 /* Common finish hook for the C, ObjC and C++ front ends. */ 1149 /* Common finish hook for the C, ObjC and C++ front ends. */
1096 void 1150 void
1097 c_common_finish (void) 1151 c_common_finish (void)
1098 { 1152 {
1099 FILE *deps_stream = NULL; 1153 FILE *deps_stream = NULL;
1100 1154
1101 /* Don't write the deps file if there are errors. */ 1155 /* Note that we write the dependencies even if there are errors. This is
1102 if (cpp_opts->deps.style != DEPS_NONE && !seen_error ()) 1156 useful for handling outdated generated headers that now trigger errors
1157 (for example, with #error) which would be resolved by re-generating
1158 them. In a sense, this complements -MG. */
1159 if (cpp_opts->deps.style != DEPS_NONE)
1103 { 1160 {
1104 /* If -M or -MM was seen without -MF, default output to the 1161 /* If -M or -MM was seen without -MF, default output to the
1105 output stream. */ 1162 output stream. */
1106 if (!deps_file) 1163 if (!deps_file)
1107 deps_stream = out_stream; 1164 deps_stream = out_stream;
1165 else if (deps_file[0] == '-' && deps_file[1] == '\0')
1166 deps_stream = stdout;
1108 else 1167 else
1109 { 1168 {
1110 deps_stream = fopen (deps_file, deps_append ? "a": "w"); 1169 deps_stream = fopen (deps_file, deps_append ? "a": "w");
1111 if (!deps_stream) 1170 if (!deps_stream)
1112 fatal_error ("opening dependency file %s: %m", deps_file); 1171 fatal_error (input_location, "opening dependency file %s: %m",
1172 deps_file);
1113 } 1173 }
1114 } 1174 }
1115 1175
1116 /* For performance, avoid tearing down cpplib's internal structures 1176 /* For performance, avoid tearing down cpplib's internal structures
1117 with cpp_destroy (). */ 1177 with cpp_destroy (). */
1118 cpp_finish (parse_in, deps_stream); 1178 cpp_finish (parse_in, deps_stream);
1119 1179
1120 if (deps_stream && deps_stream != out_stream 1180 if (deps_stream && deps_stream != out_stream && deps_stream != stdout
1121 && (ferror (deps_stream) || fclose (deps_stream))) 1181 && (ferror (deps_stream) || fclose (deps_stream)))
1122 fatal_error ("closing dependency file %s: %m", deps_file); 1182 fatal_error (input_location, "closing dependency file %s: %m", deps_file);
1123 1183
1124 if (out_stream && (ferror (out_stream) || fclose (out_stream))) 1184 if (out_stream && (ferror (out_stream) || fclose (out_stream)))
1125 fatal_error ("when writing output to %s: %m", out_fname); 1185 fatal_error (input_location, "when writing output to %s: %m", out_fname);
1126 } 1186 }
1127 1187
1128 /* Either of two environment variables can specify output of 1188 /* Either of two environment variables can specify output of
1129 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE 1189 dependencies. Their value is either "OUTPUT_FILE" or "OUTPUT_FILE
1130 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to 1190 DEPS_TARGET", where OUTPUT_FILE is the file to write deps info to
1229 1289
1230 cpp_opts->unsigned_char = !flag_signed_char; 1290 cpp_opts->unsigned_char = !flag_signed_char;
1231 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS; 1291 cpp_opts->stdc_0_in_system_headers = STDC_0_IN_SYSTEM_HEADERS;
1232 1292
1233 /* Wlong-long is disabled by default. It is enabled by: 1293 /* Wlong-long is disabled by default. It is enabled by:
1234 [-pedantic | -Wtraditional] -std=[gnu|c]++98 ; or 1294 [-Wpedantic | -Wtraditional] -std=[gnu|c]++98 ; or
1235 [-pedantic | -Wtraditional] -std=non-c99 . 1295 [-Wpedantic | -Wtraditional] -std=non-c99
1236 1296
1237 Either -Wlong-long or -Wno-long-long override any other settings. */ 1297 Either -Wlong-long or -Wno-long-long override any other settings.
1298 ??? These conditions should be handled in c.opt. */
1238 if (warn_long_long == -1) 1299 if (warn_long_long == -1)
1239 warn_long_long = ((pedantic || warn_traditional) 1300 {
1240 && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)); 1301 warn_long_long = ((pedantic || warn_traditional)
1241 cpp_opts->cpp_warn_long_long = warn_long_long; 1302 && (c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99));
1242 1303 cpp_opts->cpp_warn_long_long = warn_long_long;
1243 /* Similarly with -Wno-variadic-macros. No check for c99 here, since 1304 }
1244 this also turns off warnings about GCCs extension. */
1245 cpp_opts->warn_variadic_macros
1246 = warn_variadic_macros && (pedantic || warn_traditional);
1247 1305
1248 /* If we're generating preprocessor output, emit current directory 1306 /* If we're generating preprocessor output, emit current directory
1249 if explicitly requested or if debugging information is enabled. 1307 if explicitly requested or if debugging information is enabled.
1250 ??? Maybe we should only do it for debugging formats that 1308 ??? Maybe we should only do it for debugging formats that
1251 actually output the current directory? */ 1309 actually output the current directory? */
1252 if (flag_working_directory == -1) 1310 if (flag_working_directory == -1)
1253 flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE); 1311 flag_working_directory = (debug_info_level != DINFO_LEVEL_NONE);
1254 1312
1313 if (warn_implicit_fallthrough < 5)
1314 cpp_opts->cpp_warn_implicit_fallthrough = warn_implicit_fallthrough;
1315 else
1316 cpp_opts->cpp_warn_implicit_fallthrough = 0;
1317
1255 if (cpp_opts->directives_only) 1318 if (cpp_opts->directives_only)
1256 { 1319 {
1257 if (warn_unused_macros) 1320 if (cpp_warn_unused_macros)
1258 error ("-fdirectives-only is incompatible with -Wunused_macros"); 1321 error ("-fdirectives-only is incompatible with -Wunused_macros");
1259 if (cpp_opts->traditional) 1322 if (cpp_opts->traditional)
1260 error ("-fdirectives-only is incompatible with -traditional"); 1323 error ("-fdirectives-only is incompatible with -traditional");
1261 } 1324 }
1262 } 1325 }
1263 1326
1264 /* Add include path with a prefix at the front of its name. */ 1327 /* Add include path with a prefix at the front of its name. */
1265 static void 1328 static void
1266 add_prefixed_path (const char *suffix, size_t chain) 1329 add_prefixed_path (const char *suffix, incpath_kind chain)
1267 { 1330 {
1268 char *path; 1331 char *path;
1269 const char *prefix; 1332 const char *prefix;
1270 size_t prefix_len, suffix_len; 1333 size_t prefix_len, suffix_len;
1271 1334
1288 if (!cpp_opts->preprocessed) 1351 if (!cpp_opts->preprocessed)
1289 { 1352 {
1290 size_t i; 1353 size_t i;
1291 1354
1292 cb_file_change (parse_in, 1355 cb_file_change (parse_in,
1293 linemap_add (line_table, LC_RENAME, 0, 1356 linemap_check_ordinary (linemap_add (line_table,
1294 _("<built-in>"), 0)); 1357 LC_RENAME, 0,
1358 _("<built-in>"),
1359 0)));
1360 /* Make sure all of the builtins about to be declared have
1361 BUILTINS_LOCATION has their source_location. */
1362 source_location builtins_loc = BUILTINS_LOCATION;
1363 cpp_force_token_locations (parse_in, &builtins_loc);
1295 1364
1296 cpp_init_builtins (parse_in, flag_hosted); 1365 cpp_init_builtins (parse_in, flag_hosted);
1297 c_cpp_builtins (parse_in); 1366 c_cpp_builtins (parse_in);
1367
1368 cpp_stop_forcing_token_locations (parse_in);
1298 1369
1299 /* We're about to send user input to cpplib, so make it warn for 1370 /* We're about to send user input to cpplib, so make it warn for
1300 things that we previously (when we sent it internal definitions) 1371 things that we previously (when we sent it internal definitions)
1301 told it to not warn. 1372 told it to not warn.
1302 1373
1306 conforming program cannot contain a '$', we do not condition 1377 conforming program cannot contain a '$', we do not condition
1307 their acceptance on the -std= setting. */ 1378 their acceptance on the -std= setting. */
1308 cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99); 1379 cpp_opts->warn_dollars = (cpp_opts->cpp_pedantic && !cpp_opts->c99);
1309 1380
1310 cb_file_change (parse_in, 1381 cb_file_change (parse_in,
1311 linemap_add (line_table, LC_RENAME, 0, 1382 linemap_check_ordinary (linemap_add (line_table, LC_RENAME, 0,
1312 _("<command-line>"), 0)); 1383 _("<command-line>"), 0)));
1313 1384
1314 for (i = 0; i < deferred_count; i++) 1385 for (i = 0; i < deferred_count; i++)
1315 { 1386 {
1316 struct deferred_opt *opt = &deferred_opts[i]; 1387 struct deferred_opt *opt = &deferred_opts[i];
1317 1388
1364 1435
1365 /* Give CPP the next file given by -include, if any. */ 1436 /* Give CPP the next file given by -include, if any. */
1366 static void 1437 static void
1367 push_command_line_include (void) 1438 push_command_line_include (void)
1368 { 1439 {
1440 /* This can happen if disabled by -imacros for example.
1441 Punt so that we don't set "<command-line>" as the filename for
1442 the header. */
1443 if (include_cursor > deferred_count)
1444 return;
1445
1446 if (!done_preinclude)
1447 {
1448 done_preinclude = true;
1449 if (flag_hosted && std_inc && !cpp_opts->preprocessed)
1450 {
1451 const char *preinc = targetcm.c_preinclude ();
1452 if (preinc && cpp_push_default_include (parse_in, preinc))
1453 return;
1454 }
1455 }
1456
1457 pch_cpp_save_state ();
1458
1369 while (include_cursor < deferred_count) 1459 while (include_cursor < deferred_count)
1370 { 1460 {
1371 struct deferred_opt *opt = &deferred_opts[include_cursor++]; 1461 struct deferred_opt *opt = &deferred_opts[include_cursor++];
1372 1462
1373 if (!cpp_opts->preprocessed && opt->code == OPT_include 1463 if (!cpp_opts->preprocessed && opt->code == OPT_include
1377 1467
1378 if (include_cursor == deferred_count) 1468 if (include_cursor == deferred_count)
1379 { 1469 {
1380 include_cursor++; 1470 include_cursor++;
1381 /* -Wunused-macros should only warn about macros defined hereafter. */ 1471 /* -Wunused-macros should only warn about macros defined hereafter. */
1382 cpp_opts->warn_unused_macros = warn_unused_macros; 1472 cpp_opts->warn_unused_macros = cpp_warn_unused_macros;
1383 /* Restore the line map from <command line>. */ 1473 /* Restore the line map from <command line>. */
1384 if (!cpp_opts->preprocessed) 1474 if (!cpp_opts->preprocessed)
1385 cpp_change_file (parse_in, LC_RENAME, this_input_filename); 1475 cpp_change_file (parse_in, LC_RENAME, this_input_filename);
1386 1476
1387 /* Set this here so the client can change the option if it wishes, 1477 /* Set this here so the client can change the option if it wishes,
1391 } 1481 }
1392 1482
1393 /* File change callback. Has to handle -include files. */ 1483 /* File change callback. Has to handle -include files. */
1394 static void 1484 static void
1395 cb_file_change (cpp_reader * ARG_UNUSED (pfile), 1485 cb_file_change (cpp_reader * ARG_UNUSED (pfile),
1396 const struct line_map *new_map) 1486 const line_map_ordinary *new_map)
1397 { 1487 {
1398 if (flag_preprocess_only) 1488 if (flag_preprocess_only)
1399 pp_file_change (new_map); 1489 pp_file_change (new_map);
1400 else 1490 else
1401 fe_file_change (new_map); 1491 fe_file_change (new_map);
1402 1492
1493 if (new_map
1494 && (new_map->reason == LC_ENTER || new_map->reason == LC_RENAME))
1495 {
1496 /* Signal to plugins that a file is included. This could happen
1497 several times with the same file path, e.g. because of
1498 several '#include' or '#line' directives... */
1499 invoke_plugin_callbacks
1500 (PLUGIN_INCLUDE_FILE,
1501 const_cast<char*> (ORDINARY_MAP_FILE_NAME (new_map)));
1502 }
1503
1403 if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map))) 1504 if (new_map == 0 || (new_map->reason == LC_LEAVE && MAIN_FILE_P (new_map)))
1404 push_command_line_include (); 1505 {
1506 pch_cpp_save_state ();
1507 push_command_line_include ();
1508 }
1405 } 1509 }
1406 1510
1407 void 1511 void
1408 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir) 1512 cb_dir_change (cpp_reader * ARG_UNUSED (pfile), const char *dir)
1409 { 1513 {
1421 flag_no_asm = iso; 1525 flag_no_asm = iso;
1422 flag_no_gnu_keywords = iso; 1526 flag_no_gnu_keywords = iso;
1423 flag_no_nonansi_builtin = iso; 1527 flag_no_nonansi_builtin = iso;
1424 flag_isoc94 = c94; 1528 flag_isoc94 = c94;
1425 flag_isoc99 = 0; 1529 flag_isoc99 = 0;
1426 flag_isoc1x = 0; 1530 flag_isoc11 = 0;
1531 lang_hooks.name = "GNU C89";
1427 } 1532 }
1428 1533
1429 /* Set the C 99 standard (without GNU extensions if ISO). */ 1534 /* Set the C 99 standard (without GNU extensions if ISO). */
1430 static void 1535 static void
1431 set_std_c99 (int iso) 1536 set_std_c99 (int iso)
1432 { 1537 {
1433 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99); 1538 cpp_set_lang (parse_in, iso ? CLK_STDC99: CLK_GNUC99);
1434 flag_no_asm = iso; 1539 flag_no_asm = iso;
1435 flag_no_nonansi_builtin = iso; 1540 flag_no_nonansi_builtin = iso;
1436 flag_iso = iso; 1541 flag_iso = iso;
1437 flag_isoc1x = 0; 1542 flag_isoc11 = 0;
1438 flag_isoc99 = 1; 1543 flag_isoc99 = 1;
1439 flag_isoc94 = 1; 1544 flag_isoc94 = 1;
1440 } 1545 lang_hooks.name = "GNU C99";
1441 1546 }
1442 /* Set the C 1X standard draft (without GNU extensions if ISO). */ 1547
1443 static void 1548 /* Set the C 11 standard (without GNU extensions if ISO). */
1444 set_std_c1x (int iso) 1549 static void
1445 { 1550 set_std_c11 (int iso)
1446 cpp_set_lang (parse_in, iso ? CLK_STDC1X: CLK_GNUC1X); 1551 {
1552 cpp_set_lang (parse_in, iso ? CLK_STDC11: CLK_GNUC11);
1447 flag_no_asm = iso; 1553 flag_no_asm = iso;
1448 flag_no_nonansi_builtin = iso; 1554 flag_no_nonansi_builtin = iso;
1449 flag_iso = iso; 1555 flag_iso = iso;
1450 flag_isoc1x = 1; 1556 flag_isoc11 = 1;
1451 flag_isoc99 = 1; 1557 flag_isoc99 = 1;
1452 flag_isoc94 = 1; 1558 flag_isoc94 = 1;
1559 lang_hooks.name = "GNU C11";
1453 } 1560 }
1454 1561
1455 /* Set the C++ 98 standard (without GNU extensions if ISO). */ 1562 /* Set the C++ 98 standard (without GNU extensions if ISO). */
1456 static void 1563 static void
1457 set_std_cxx98 (int iso) 1564 set_std_cxx98 (int iso)
1458 { 1565 {
1459 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX); 1566 cpp_set_lang (parse_in, iso ? CLK_CXX98: CLK_GNUCXX);
1460 flag_no_gnu_keywords = iso; 1567 flag_no_gnu_keywords = iso;
1461 flag_no_nonansi_builtin = iso; 1568 flag_no_nonansi_builtin = iso;
1462 flag_iso = iso; 1569 flag_iso = iso;
1570 flag_isoc94 = 0;
1571 flag_isoc99 = 0;
1463 cxx_dialect = cxx98; 1572 cxx_dialect = cxx98;
1464 } 1573 lang_hooks.name = "GNU C++98";
1465 1574 }
1466 /* Set the C++ 0x working draft "standard" (without GNU extensions if ISO). */ 1575
1467 static void 1576 /* Set the C++ 2011 standard (without GNU extensions if ISO). */
1468 set_std_cxx0x (int iso) 1577 static void
1469 { 1578 set_std_cxx11 (int iso)
1470 cpp_set_lang (parse_in, iso ? CLK_CXX0X: CLK_GNUCXX0X); 1579 {
1580 cpp_set_lang (parse_in, iso ? CLK_CXX11: CLK_GNUCXX11);
1471 flag_no_gnu_keywords = iso; 1581 flag_no_gnu_keywords = iso;
1472 flag_no_nonansi_builtin = iso; 1582 flag_no_nonansi_builtin = iso;
1473 flag_iso = iso; 1583 flag_iso = iso;
1474 cxx_dialect = cxx0x; 1584 /* C++11 includes the C99 standard library. */
1585 flag_isoc94 = 1;
1586 flag_isoc99 = 1;
1587 cxx_dialect = cxx11;
1588 lang_hooks.name = "GNU C++11";
1589 }
1590
1591 /* Set the C++ 2014 standard (without GNU extensions if ISO). */
1592 static void
1593 set_std_cxx14 (int iso)
1594 {
1595 cpp_set_lang (parse_in, iso ? CLK_CXX14: CLK_GNUCXX14);
1596 flag_no_gnu_keywords = iso;
1597 flag_no_nonansi_builtin = iso;
1598 flag_iso = iso;
1599 /* C++14 includes the C99 standard library. */
1600 flag_isoc94 = 1;
1601 flag_isoc99 = 1;
1602 cxx_dialect = cxx14;
1603 lang_hooks.name = "GNU C++14";
1604 }
1605
1606 /* Set the C++ 2017 standard (without GNU extensions if ISO). */
1607 static void
1608 set_std_cxx17 (int iso)
1609 {
1610 cpp_set_lang (parse_in, iso ? CLK_CXX17: CLK_GNUCXX17);
1611 flag_no_gnu_keywords = iso;
1612 flag_no_nonansi_builtin = iso;
1613 flag_iso = iso;
1614 /* C++17 includes the C11 standard library. */
1615 flag_isoc94 = 1;
1616 flag_isoc99 = 1;
1617 flag_isoc11 = 1;
1618 cxx_dialect = cxx17;
1619 lang_hooks.name = "GNU C++17";
1620 }
1621
1622 /* Set the C++ 202a draft standard (without GNU extensions if ISO). */
1623 static void
1624 set_std_cxx2a (int iso)
1625 {
1626 cpp_set_lang (parse_in, iso ? CLK_CXX2A: CLK_GNUCXX2A);
1627 flag_no_gnu_keywords = iso;
1628 flag_no_nonansi_builtin = iso;
1629 flag_iso = iso;
1630 /* C++17 includes the C11 standard library. */
1631 flag_isoc94 = 1;
1632 flag_isoc99 = 1;
1633 flag_isoc11 = 1;
1634 cxx_dialect = cxx2a;
1635 lang_hooks.name = "GNU C++17"; /* Pretend C++17 until standardization. */
1475 } 1636 }
1476 1637
1477 /* Args to -d specify what to dump. Silently ignore 1638 /* Args to -d specify what to dump. Silently ignore
1478 unrecognized options; they may be aimed at toplev.c. */ 1639 unrecognized options; they may be aimed at toplev.c. */
1479 static void 1640 static void