1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2019 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This is the top level of cc1/c++.
21 It parses command args, opens files, invokes the various passes
22 in the proper order, and counts the time used by each.
23 Error messages and low-level interface to malloc also handled here. */
27 #include "coretypes.h"
33 #include "alloc-pool.h"
37 #include "optabs-libfuncs.h"
38 #include "insn-config.h"
43 #include "diagnostic.h"
45 #include "tree-inline.h"
46 #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */
49 #include "insn-attr.h"
54 #include "tree-diagnostic.h"
58 #include "dwarf2asm.h"
60 #include "common/common-target.h"
61 #include "langhooks.h"
62 #include "cfgloop.h" /* for init_set_costs */
63 #include "hosthooks.h"
65 #include "opts-diagnostic.h"
66 #include "stringpool.h"
72 #include "pass_manager.h"
73 #include "auto-profile.h"
74 #include "dwarf2out.h"
75 #include "ipa-reference.h"
76 #include "symbol-summary.h"
80 #include "omp-offload.h"
81 #include "hsa-common.h"
82 #include "edit-context.h"
83 #include "tree-pass.h"
85 #include "ipa-fnsummary.h"
86 #include "dump-context.h"
87 #include "print-tree.h"
88 #include "optinfo-emit-json.h"
90 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
94 #ifdef XCOFF_DEBUGGING_INFO
95 #include "xcoffout.h" /* Needed for external data declarations. */
101 #include <isl/version.h>
104 static void general_init (const char *, bool);
105 static void do_compile ();
106 static void process_options (void);
107 static void backend_init (void);
108 static int lang_dependent_init (const char *);
109 static void init_asm_output (const char *);
110 static void finalize (bool);
112 static void crash_signal (int) ATTRIBUTE_NORETURN
;
113 static void compile_file (void);
115 /* True if we don't need a backend (e.g. preprocessing only). */
116 static bool no_backend
;
118 /* Length of line when printing switch values. */
121 /* Decoded options, and number of such options. */
122 struct cl_decoded_option
*save_decoded_options
;
123 unsigned int save_decoded_options_count
;
125 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
126 to optimize in process_options (). */
127 #define AUTODETECT_VALUE 2
129 /* Debug hooks - dependent upon command line options. */
131 const struct gcc_debug_hooks
*debug_hooks
;
133 /* The FUNCTION_DECL for the function currently being compiled,
134 or 0 if between functions. */
135 tree current_function_decl
;
137 /* Set to the FUNC_BEGIN label of the current function, or NULL
139 const char * current_function_func_begin_label
;
141 /* A random sequence of characters, unless overridden by user. */
142 static const char *flag_random_seed
;
144 /* A local time stamp derived from the time of compilation. It will be
145 zero if the system cannot provide a time. It will be -1u, if the
146 user has specified a particular random seed. */
149 /* Random number for this compilation */
150 HOST_WIDE_INT random_seed
;
154 /* When non-NULL, indicates that whenever space is allocated on the
155 stack, the resulting stack pointer must not pass this
156 address---that is, for stacks that grow downward, the stack pointer
157 must always be greater than or equal to this address; for stacks
158 that grow upward, the stack pointer must be less than this address.
159 At present, the rtx may be either a REG or a SYMBOL_REF, although
160 the support provided depends on the backend. */
163 class target_flag_state default_target_flag_state
;
164 #if SWITCHABLE_TARGET
165 class target_flag_state
*this_target_flag_state
= &default_target_flag_state
;
167 #define this_target_flag_state (&default_target_flag_state)
170 /* The user symbol prefix after having resolved same. */
171 const char *user_label_prefix
;
173 /* Output files for assembler code (real compiler output)
174 and debugging dumps. */
178 FILE *callgraph_info_file
= NULL
;
179 static bitmap callgraph_info_external_printed
;
180 FILE *stack_usage_file
= NULL
;
182 /* The current working directory of a translation. It's generally the
183 directory from which compilation was initiated, but a preprocessed
184 file may specify the original directory in which it was
187 static const char *src_pwd
;
189 /* Initialize src_pwd with the given string, and return true. If it
190 was already initialized, return false. As a special case, it may
191 be called with a NULL argument to test whether src_pwd has NOT been
195 set_src_pwd (const char *pwd
)
199 if (strcmp (src_pwd
, pwd
) == 0)
205 src_pwd
= xstrdup (pwd
);
209 /* Return the directory from which the translation unit was initiated,
210 in case set_src_pwd() was not called before to assign it a
226 /* Called when the start of a function definition is parsed,
227 this function prints on stderr the name of the function. */
229 announce_function (tree decl
)
233 if (rtl_dump_and_exit
)
234 fprintf (stderr
, "%s ",
235 identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
))));
237 fprintf (stderr
, " %s",
238 identifier_to_locale (lang_hooks
.decl_printable_name (decl
, 2)));
240 pp_needs_newline (global_dc
->printer
) = true;
241 diagnostic_set_last_function (global_dc
, (diagnostic_info
*) NULL
);
245 /* Initialize local_tick with the time of day, or -1 if
246 flag_random_seed is set. */
249 init_local_tick (void)
251 if (!flag_random_seed
)
253 #ifdef HAVE_GETTIMEOFDAY
257 gettimeofday (&tv
, NULL
);
258 local_tick
= (unsigned) tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
262 time_t now
= time (NULL
);
264 if (now
!= (time_t)-1)
265 local_tick
= (unsigned) now
;
273 /* Obtain the random_seed. Unless NOINIT, initialize it if
274 it's not provided in the command line. */
277 get_random_seed (bool noinit
)
279 if (!random_seed
&& !noinit
)
281 int fd
= open ("/dev/urandom", O_RDONLY
);
284 if (read (fd
, &random_seed
, sizeof (random_seed
))
285 != sizeof (random_seed
))
290 random_seed
= local_tick
^ getpid ();
295 /* Set flag_random_seed to VAL, and if non-null, reinitialize random_seed. */
298 set_random_seed (const char *val
)
300 flag_random_seed
= val
;
301 if (flag_random_seed
)
305 /* When the driver passed in a hex number don't crc it again */
306 random_seed
= strtoul (flag_random_seed
, &endp
, 0);
307 if (!(endp
> flag_random_seed
&& *endp
== 0))
308 random_seed
= crc32_string (0, flag_random_seed
);
312 /* Handler for fatal signals, such as SIGSEGV. These are transformed
313 into ICE messages, which is much more user friendly. In case the
314 error printer crashes, reset the signal to prevent infinite recursion. */
317 crash_signal (int signo
)
319 signal (signo
, SIG_DFL
);
321 /* If we crashed while processing an ASM statement, then be a little more
322 graceful. It's most likely the user's fault. */
323 if (this_is_asm_operands
)
325 output_operand_lossage ("unrecoverable error");
326 exit (FATAL_EXIT_CODE
);
329 internal_error ("%s", strsignal (signo
));
332 /* A subroutine of wrapup_global_declarations. We've come to the end of
333 the compilation unit. All deferred variables should be undeferred,
334 and all incomplete decls should be finalized. */
337 wrapup_global_declaration_1 (tree decl
)
339 /* We're not deferring this any longer. Assignment is conditional to
340 avoid needlessly dirtying PCH pages. */
341 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_WITH_VIS
)
342 && DECL_DEFER_OUTPUT (decl
) != 0)
343 DECL_DEFER_OUTPUT (decl
) = 0;
345 if (VAR_P (decl
) && DECL_SIZE (decl
) == 0)
346 lang_hooks
.finish_incomplete_decl (decl
);
349 /* A subroutine of wrapup_global_declarations. Decide whether or not DECL
350 needs to be output. Return true if it is output. */
353 wrapup_global_declaration_2 (tree decl
)
355 if (TREE_ASM_WRITTEN (decl
) || DECL_EXTERNAL (decl
)
356 || (VAR_P (decl
) && DECL_HAS_VALUE_EXPR_P (decl
)))
359 /* Don't write out static consts, unless we still need them.
361 We also keep static consts if not optimizing (for debugging),
362 unless the user specified -fno-keep-static-consts.
363 ??? They might be better written into the debug information.
364 This is possible when using DWARF.
366 A language processor that wants static constants to be always
367 written out (even if it is not used) is responsible for
368 calling rest_of_decl_compilation itself. E.g. the C front-end
369 calls rest_of_decl_compilation from finish_decl.
370 One motivation for this is that is conventional in some
371 environments to write things like:
372 static const char rcsid[] = "... version string ...";
373 intending to force the string to be in the executable.
375 A language processor that would prefer to have unneeded
376 static constants "optimized away" would just defer writing
377 them out until here. E.g. C++ does this, because static
378 constants are often defined in header files.
380 ??? A tempting alternative (for both C and C++) would be
381 to force a constant to be written if and only if it is
382 defined in a main file, as opposed to an include file. */
384 if (VAR_P (decl
) && TREE_STATIC (decl
))
388 node
= varpool_node::get (decl
);
390 if (!node
&& flag_ltrans
)
392 else if (node
&& node
->definition
)
394 else if (node
&& node
->alias
)
396 else if (!symtab
->global_info_ready
398 || TREE_USED (DECL_ASSEMBLER_NAME (decl
))))
400 else if (node
&& node
->analyzed
)
402 else if (DECL_COMDAT (decl
))
404 else if (TREE_READONLY (decl
) && !TREE_PUBLIC (decl
)
405 && (optimize
|| !flag_keep_static_consts
406 || DECL_ARTIFICIAL (decl
)))
411 rest_of_decl_compilation (decl
, 1, 1);
419 /* Do any final processing required for the declarations in VEC, of
420 which there are LEN. We write out inline functions and variables
421 that have been deferred until this point, but which are required.
422 Returns nonzero if anything was put out. */
425 wrapup_global_declarations (tree
*vec
, int len
)
427 bool reconsider
, output_something
= false;
430 for (i
= 0; i
< len
; i
++)
431 wrapup_global_declaration_1 (vec
[i
]);
433 /* Now emit any global variables or functions that we have been
434 putting off. We need to loop in case one of the things emitted
435 here references another one which comes earlier in the list. */
439 for (i
= 0; i
< len
; i
++)
440 reconsider
|= wrapup_global_declaration_2 (vec
[i
]);
442 output_something
= true;
446 return output_something
;
449 /* Compile an entire translation unit. Write a file of assembly
450 output and various debugging dumps. */
455 timevar_start (TV_PHASE_PARSING
);
456 timevar_push (TV_PARSE_GLOBAL
);
458 /* Parse entire file and generate initial debug information. */
459 lang_hooks
.parse_file ();
461 timevar_pop (TV_PARSE_GLOBAL
);
462 timevar_stop (TV_PHASE_PARSING
);
464 if (flag_dump_locations
)
465 dump_location_info (stderr
);
467 /* Compilation is now finished except for writing
468 what's left of the symbol table output. */
470 if (flag_syntax_only
|| flag_wpa
)
473 /* Reset maximum_field_alignment, it can be adjusted by #pragma pack
474 and this shouldn't influence any types built by the middle-end
475 from now on (like gcov_info_type). */
476 maximum_field_alignment
= initial_max_fld_align
* BITS_PER_UNIT
;
478 ggc_protect_identifiers
= false;
480 /* Run the actual compilation process. */
483 timevar_start (TV_PHASE_OPT_GEN
);
484 symtab
->finalize_compilation_unit ();
485 timevar_stop (TV_PHASE_OPT_GEN
);
488 /* Perform any post compilation-proper parser cleanups and
489 processing. This is currently only needed for the C++ parser,
490 which can be hopefully cleaned up so this hook is no longer
492 if (lang_hooks
.decls
.post_compilation_parsing_cleanups
)
493 lang_hooks
.decls
.post_compilation_parsing_cleanups ();
495 dump_context::get ().finish_any_json_writer ();
500 timevar_start (TV_PHASE_LATE_ASM
);
502 /* Compilation unit is finalized. When producing non-fat LTO object, we are
503 basically finished. */
504 if ((in_lto_p
&& flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
505 || !flag_lto
|| flag_fat_lto_objects
)
507 /* File-scope initialization for AddressSanitizer. */
508 if (flag_sanitize
& SANITIZE_ADDRESS
)
511 if (flag_sanitize
& SANITIZE_THREAD
)
518 output_shared_constant_pool ();
519 output_object_blocks ();
520 finish_tm_clone_pairs ();
522 /* Write out any pending weak symbol declarations. */
525 /* This must be at the end before unwind and debug info.
526 Some target ports emit PIC setup thunks here. */
527 targetm
.asm_out
.code_end ();
529 /* Do dbx symbols. */
530 timevar_push (TV_SYMOUT
);
532 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
533 dwarf2out_frame_finish ();
537 (*debug_hooks
->finish
) (main_input_filename
);
539 timevar_pop (TV_SYMOUT
);
541 /* Output some stuff at end of file if nec. */
543 dw2_output_indirect_constants ();
545 /* Flush any pending external directives. */
546 process_pending_assemble_externals ();
549 /* Let linker plugin know that this is a slim object and must be LTOed
550 even when user did not ask for it. */
551 if (flag_generate_lto
&& !flag_fat_lto_objects
)
553 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
554 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, NULL_TREE
, "__gnu_lto_slim",
555 HOST_WIDE_INT_1U
, 8);
556 #elif defined ASM_OUTPUT_ALIGNED_COMMON
557 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, "__gnu_lto_slim",
558 HOST_WIDE_INT_1U
, 8);
560 ASM_OUTPUT_COMMON (asm_out_file
, "__gnu_lto_slim",
566 /* Attach a special .ident directive to the end of the file to identify
567 the version of GCC which compiled this code. The format of the .ident
568 string is patterned after the ones produced by native SVR4 compilers. */
571 const char *pkg_version
= "(GNU) ";
574 if (strcmp ("(GCC) ", pkgversion_string
))
575 pkg_version
= pkgversion_string
;
577 ident_str
= ACONCAT (("GCC: ", pkg_version
, version_string
, NULL
));
578 targetm
.asm_out
.output_ident (ident_str
);
581 /* Auto profile finalization. */
582 if (flag_auto_profile
)
585 /* Invoke registered plugin callbacks. */
586 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT
, NULL
);
588 /* This must be at the end. Some target ports emit end of file directives
589 into the assembly file here, and hence we cannot output anything to the
590 assembly file after this point. */
591 targetm
.asm_out
.file_end ();
593 timevar_stop (TV_PHASE_LATE_ASM
);
596 /* Print version information to FILE.
597 Each line begins with INDENT (for the case where FILE is the
598 assembler output file).
600 If SHOW_GLOBAL_STATE is true (for cc1 etc), we are within the compiler
601 proper and can print pertinent state (e.g. params and plugins).
603 If SHOW_GLOBAL_STATE is false (for use by libgccjit), we are outside the
604 compiler, and we don't hold the mutex on the compiler's global state:
605 we can't print params and plugins, since they might not be initialized,
606 or might be being manipulated by a compile running in another
610 print_version (FILE *file
, const char *indent
, bool show_global_state
)
612 static const char fmt1
[] =
614 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
616 N_("%s%s%s %sversion %s (%s) compiled by CC, ")
619 static const char fmt2
[] =
620 N_("GMP version %s, MPFR version %s, MPC version %s, isl version %s\n");
621 static const char fmt3
[] =
622 N_("%s%swarning: %s header version %s differs from library version %s.\n");
623 static const char fmt4
[] =
624 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
626 #define __VERSION__ "[?]"
629 file
== stderr
? _(fmt1
) : fmt1
,
630 indent
, *indent
!= 0 ? " " : "",
631 lang_hooks
.name
, pkgversion_string
, version_string
, TARGET_NAME
,
632 indent
, __VERSION__
);
634 /* We need to stringify the GMP macro values. Ugh, gmp_version has
635 two string formats, "i.j.k" and "i.j" when k is zero. As of
636 gmp-4.3.0, GMP always uses the 3 number format. */
637 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
638 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X)
639 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
640 #define GCC_GMP_VERSION \
641 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
642 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
643 #define GCC_GMP_STRINGIFY_VERSION \
644 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
645 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR)
647 #define GCC_GMP_STRINGIFY_VERSION \
648 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
649 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \
650 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL)
653 file
== stderr
? _(fmt2
) : fmt2
,
654 GCC_GMP_STRINGIFY_VERSION
, MPFR_VERSION_STRING
, MPC_VERSION_STRING
,
661 if (strcmp (GCC_GMP_STRINGIFY_VERSION
, gmp_version
))
663 file
== stderr
? _(fmt3
) : fmt3
,
664 indent
, *indent
!= 0 ? " " : "",
665 "GMP", GCC_GMP_STRINGIFY_VERSION
, gmp_version
);
666 if (strcmp (MPFR_VERSION_STRING
, mpfr_get_version ()))
668 file
== stderr
? _(fmt3
) : fmt3
,
669 indent
, *indent
!= 0 ? " " : "",
670 "MPFR", MPFR_VERSION_STRING
, mpfr_get_version ());
671 if (strcmp (MPC_VERSION_STRING
, mpc_get_version ()))
673 file
== stderr
? _(fmt3
) : fmt3
,
674 indent
, *indent
!= 0 ? " " : "",
675 "MPC", MPC_VERSION_STRING
, mpc_get_version ());
677 if (show_global_state
)
680 file
== stderr
? _(fmt4
) : fmt4
,
681 indent
, *indent
!= 0 ? " " : "",
682 PARAM_VALUE (GGC_MIN_EXPAND
), PARAM_VALUE (GGC_MIN_HEAPSIZE
));
684 print_plugins_versions (file
, indent
);
689 print_to_asm_out_file (print_switch_type type
, const char * text
)
691 bool prepend_sep
= true;
695 case SWITCH_TYPE_LINE_END
:
696 putc ('\n', asm_out_file
);
699 case SWITCH_TYPE_LINE_START
:
700 fputs (ASM_COMMENT_START
, asm_out_file
);
701 return strlen (ASM_COMMENT_START
);
703 case SWITCH_TYPE_DESCRIPTIVE
:
704 if (ASM_COMMENT_START
[0] == 0)
707 case SWITCH_TYPE_PASSED
:
708 case SWITCH_TYPE_ENABLED
:
710 fputc (' ', asm_out_file
);
711 fputs (text
, asm_out_file
);
712 /* No need to return the length here as
713 print_single_switch has already done it. */
722 print_to_stderr (print_switch_type type
, const char * text
)
726 case SWITCH_TYPE_LINE_END
:
730 case SWITCH_TYPE_LINE_START
:
733 case SWITCH_TYPE_PASSED
:
734 case SWITCH_TYPE_ENABLED
:
738 case SWITCH_TYPE_DESCRIPTIVE
:
739 fputs (text
, stderr
);
740 /* No need to return the length here as
741 print_single_switch has already done it. */
749 /* Print an option value and return the adjusted position in the line.
750 ??? print_fn doesn't handle errors, eg disk full; presumably other
751 code will catch a disk full though. */
754 print_single_switch (print_switch_fn_type print_fn
,
756 print_switch_type type
,
759 /* The ultrix fprintf returns 0 on success, so compute the result
760 we want here since we need it for the following test. The +1
761 is for the separator character that will probably be emitted. */
762 int len
= strlen (text
) + 1;
765 && pos
+ len
> MAX_LINE
)
767 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
772 pos
+= print_fn (SWITCH_TYPE_LINE_START
, NULL
);
774 print_fn (type
, text
);
778 /* Print active target switches using PRINT_FN.
779 POS is the current cursor position and MAX is the size of a "line".
780 Each line begins with INDENT and ends with TERM.
781 Each switch is separated from the next by SEP. */
784 print_switch_values (print_switch_fn_type print_fn
)
789 /* Print the options as passed. */
790 pos
= print_single_switch (print_fn
, pos
,
791 SWITCH_TYPE_DESCRIPTIVE
, _("options passed: "));
793 for (j
= 1; j
< save_decoded_options_count
; j
++)
795 switch (save_decoded_options
[j
].opt_index
)
808 pos
= print_single_switch (print_fn
, pos
, SWITCH_TYPE_PASSED
,
809 save_decoded_options
[j
].orig_option_with_args_text
);
813 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
815 /* Print the -f and -m options that have been enabled.
816 We don't handle language specific options but printing argv
818 pos
= print_single_switch (print_fn
, 0,
819 SWITCH_TYPE_DESCRIPTIVE
, _("options enabled: "));
821 unsigned lang_mask
= lang_hooks
.option_lang_mask ();
822 for (j
= 0; j
< cl_options_count
; j
++)
823 if (cl_options
[j
].cl_report
824 && option_enabled (j
, lang_mask
, &global_options
) > 0)
825 pos
= print_single_switch (print_fn
, pos
,
826 SWITCH_TYPE_ENABLED
, cl_options
[j
].opt_text
);
828 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
831 /* Open assembly code output file. Do this even if -fsyntax-only is
832 on, because then the driver will have provided the name of a
833 temporary file or bit bucket for us. NAME is the file specified on
834 the command line, possibly NULL. */
836 init_asm_output (const char *name
)
838 if (name
== NULL
&& asm_file_name
== 0)
839 asm_out_file
= stdout
;
842 if (asm_file_name
== 0)
844 int len
= strlen (dump_base_name
);
845 char *dumpname
= XNEWVEC (char, len
+ 6);
847 memcpy (dumpname
, dump_base_name
, len
+ 1);
848 strip_off_ending (dumpname
, len
);
849 strcat (dumpname
, ".s");
850 asm_file_name
= dumpname
;
852 if (!strcmp (asm_file_name
, "-"))
853 asm_out_file
= stdout
;
854 else if (!canonical_filename_eq (asm_file_name
, name
)
855 || !strcmp (asm_file_name
, HOST_BIT_BUCKET
))
856 asm_out_file
= fopen (asm_file_name
, "w");
858 /* Use UNKOWN_LOCATION to prevent gcc from printing the first
859 line in the current file. */
860 fatal_error (UNKNOWN_LOCATION
,
861 "input file %qs is the same as output file",
863 if (asm_out_file
== 0)
864 fatal_error (UNKNOWN_LOCATION
,
865 "cannot open %qs for writing: %m", asm_file_name
);
868 if (!flag_syntax_only
)
870 targetm
.asm_out
.file_start ();
872 if (flag_record_gcc_switches
)
874 if (targetm
.asm_out
.record_gcc_switches
)
876 /* Let the target know that we are about to start recording. */
877 targetm
.asm_out
.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE
,
879 /* Now record the switches. */
880 print_switch_values (targetm
.asm_out
.record_gcc_switches
);
881 /* Let the target know that the recording is over. */
882 targetm
.asm_out
.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE
,
886 inform (UNKNOWN_LOCATION
,
887 "%<-frecord-gcc-switches%> is not supported by "
888 "the current target");
891 if (flag_verbose_asm
)
893 /* Print the list of switches in effect
894 into the assembler file as comments. */
895 print_version (asm_out_file
, ASM_COMMENT_START
, true);
896 print_switch_values (print_to_asm_out_file
);
897 putc ('\n', asm_out_file
);
902 /* A helper function; used as the reallocator function for cpp's line
905 realloc_for_line_map (void *ptr
, size_t len
)
907 return ggc_realloc (ptr
, len
);
910 /* A helper function: used as the allocator function for
911 identifier_to_locale. */
913 alloc_for_identifier_to_locale (size_t len
)
915 return ggc_alloc_atomic (len
);
918 /* Output stack usage information. */
920 output_stack_usage_1 (FILE *cf
)
922 static bool warning_issued
= false;
923 enum stack_usage_kind_type
{ STATIC
= 0, DYNAMIC
, DYNAMIC_BOUNDED
};
924 const char *stack_usage_kind_str
[] = {
929 HOST_WIDE_INT stack_usage
= current_function_static_stack_size
;
930 enum stack_usage_kind_type stack_usage_kind
;
936 warning (0, "stack usage computation not supported for this target");
937 warning_issued
= true;
942 stack_usage_kind
= STATIC
;
944 /* Add the maximum amount of space pushed onto the stack. */
945 if (maybe_ne (current_function_pushed_stack_size
, 0))
948 if (current_function_pushed_stack_size
.is_constant (&extra
))
950 stack_usage
+= extra
;
951 stack_usage_kind
= DYNAMIC_BOUNDED
;
955 extra
= constant_lower_bound (current_function_pushed_stack_size
);
956 stack_usage
+= extra
;
957 stack_usage_kind
= DYNAMIC
;
961 /* Now on to the tricky part: dynamic stack allocation. */
962 if (current_function_allocates_dynamic_stack_space
)
964 if (stack_usage_kind
!= DYNAMIC
)
966 if (current_function_has_unbounded_dynamic_stack_size
)
967 stack_usage_kind
= DYNAMIC
;
969 stack_usage_kind
= DYNAMIC_BOUNDED
;
972 /* Add the size even in the unbounded case, this can't hurt. */
973 stack_usage
+= current_function_dynamic_stack_size
;
976 if (flag_callgraph_info
& CALLGRAPH_INFO_STACK_USAGE
)
977 fprintf (cf
, "\\n" HOST_WIDE_INT_PRINT_DEC
" bytes (%s)",
979 stack_usage_kind_str
[stack_usage_kind
]);
981 if (stack_usage_file
)
983 print_decl_identifier (stack_usage_file
, current_function_decl
,
984 PRINT_DECL_ORIGIN
| PRINT_DECL_NAME
);
985 fprintf (stack_usage_file
, "\t" HOST_WIDE_INT_PRINT_DEC
"\t%s\n",
986 stack_usage
, stack_usage_kind_str
[stack_usage_kind
]);
989 if (warn_stack_usage
>= 0 && warn_stack_usage
< HOST_WIDE_INT_MAX
)
991 const location_t loc
= DECL_SOURCE_LOCATION (current_function_decl
);
993 if (stack_usage_kind
== DYNAMIC
)
994 warning_at (loc
, OPT_Wstack_usage_
, "stack usage might be unbounded");
995 else if (stack_usage
> warn_stack_usage
)
997 if (stack_usage_kind
== DYNAMIC_BOUNDED
)
999 OPT_Wstack_usage_
, "stack usage might be %wu bytes",
1002 warning_at (loc
, OPT_Wstack_usage_
, "stack usage is %wu bytes",
1008 /* Dump placeholder node for indirect calls in VCG format. */
1010 #define INDIRECT_CALL_NAME "__indirect_call"
1013 dump_final_node_vcg_start (FILE *f
, tree decl
)
1015 fputs ("node: { title: \"", f
);
1017 print_decl_identifier (f
, decl
, PRINT_DECL_UNIQUE_NAME
);
1019 fputs (INDIRECT_CALL_NAME
, f
);
1020 fputs ("\" label: \"", f
);
1023 print_decl_identifier (f
, decl
, PRINT_DECL_NAME
);
1025 print_decl_identifier (f
, decl
, PRINT_DECL_ORIGIN
);
1028 fputs ("Indirect Call Placeholder", f
);
1031 /* Dump final cgraph edge in VCG format. */
1034 dump_final_callee_vcg (FILE *f
, location_t location
, tree callee
)
1036 if ((!callee
|| DECL_EXTERNAL (callee
))
1037 && bitmap_set_bit (callgraph_info_external_printed
,
1038 callee
? DECL_UID (callee
) + 1 : 0))
1040 dump_final_node_vcg_start (f
, callee
);
1041 fputs ("\" shape : ellipse }\n", f
);
1044 fputs ("edge: { sourcename: \"", f
);
1045 print_decl_identifier (f
, current_function_decl
, PRINT_DECL_UNIQUE_NAME
);
1046 fputs ("\" targetname: \"", f
);
1048 print_decl_identifier (f
, callee
, PRINT_DECL_UNIQUE_NAME
);
1050 fputs (INDIRECT_CALL_NAME
, f
);
1051 if (LOCATION_LOCUS (location
) != UNKNOWN_LOCATION
)
1053 expanded_location loc
;
1054 fputs ("\" label: \"", f
);
1055 loc
= expand_location (location
);
1056 fprintf (f
, "%s:%d:%d", loc
.file
, loc
.line
, loc
.column
);
1058 fputs ("\" }\n", f
);
1061 /* Dump final cgraph node in VCG format. */
1064 dump_final_node_vcg (FILE *f
)
1066 dump_final_node_vcg_start (f
, current_function_decl
);
1068 if (flag_stack_usage_info
1069 || (flag_callgraph_info
& CALLGRAPH_INFO_STACK_USAGE
))
1070 output_stack_usage_1 (f
);
1072 if (flag_callgraph_info
& CALLGRAPH_INFO_DYNAMIC_ALLOC
)
1074 fprintf (f
, "\\n%u dynamic objects", vec_safe_length (cfun
->su
->dallocs
));
1077 callinfo_dalloc
*cda
;
1078 FOR_EACH_VEC_SAFE_ELT (cfun
->su
->dallocs
, i
, cda
)
1080 expanded_location loc
= expand_location (cda
->location
);
1081 fprintf (f
, "\\n %s", cda
->name
);
1082 fprintf (f
, " %s:%d:%d", loc
.file
, loc
.line
, loc
.column
);
1085 vec_free (cfun
->su
->dallocs
);
1086 cfun
->su
->dallocs
= NULL
;
1089 fputs ("\" }\n", f
);
1093 FOR_EACH_VEC_SAFE_ELT (cfun
->su
->callees
, i
, c
)
1094 dump_final_callee_vcg (f
, c
->location
, c
->decl
);
1095 vec_free (cfun
->su
->callees
);
1096 cfun
->su
->callees
= NULL
;
1098 cgraph_node
*cnode
= cgraph_node::get (current_function_decl
);
1099 for (cgraph_edge
*e
= cnode
->callees
; e
; e
= e
->next_callee
)
1100 if (CALLEE_FROM_CGRAPH_P (e
->callee
->decl
))
1101 dump_final_callee_vcg (f
, gimple_location (e
->call_stmt
),
1103 for (cgraph_edge
*e
= cnode
->indirect_calls
; e
; e
= e
->next_callee
)
1104 dump_final_callee_vcg (f
, gimple_location (e
->call_stmt
), NULL
);
1107 /* Output stack usage and callgraph info, as requested. */
1109 output_stack_usage (void)
1111 if (flag_callgraph_info
)
1112 dump_final_node_vcg (callgraph_info_file
);
1114 output_stack_usage_1 (NULL
);
1117 /* Open an auxiliary output file. */
1119 open_auxiliary_file (const char *ext
)
1124 filename
= concat (aux_base_name
, ".", ext
, NULL
);
1125 file
= fopen (filename
, "w");
1127 fatal_error (input_location
, "cannot open %s for writing: %m", filename
);
1132 /* Alternative diagnostics callback for reentered ICE reporting. */
1135 internal_error_reentered (diagnostic_context
*, const char *, va_list *)
1137 /* Flush the dump file if emergency_dump_function itself caused an ICE. */
1142 /* Auxiliary callback for the diagnostics code. */
1145 internal_error_function (diagnostic_context
*, const char *, va_list *)
1147 global_dc
->internal_error
= internal_error_reentered
;
1149 emergency_dump_function ();
1152 /* Initialization of the front end environment, before command line
1153 options are parsed. Signal handlers, internationalization etc.
1154 ARGV0 is main's argv[0]. */
1156 general_init (const char *argv0
, bool init_signals
)
1160 p
= argv0
+ strlen (argv0
);
1161 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
1165 xmalloc_set_program_name (progname
);
1169 /* Unlock the stdio streams. */
1170 unlock_std_streams ();
1172 gcc_init_libintl ();
1174 identifier_to_locale_alloc
= alloc_for_identifier_to_locale
;
1175 identifier_to_locale_free
= ggc_free
;
1177 /* Initialize the diagnostics reporting machinery, so option parsing
1178 can give warnings and errors. */
1179 diagnostic_initialize (global_dc
, N_OPTS
);
1180 global_dc
->lang_mask
= lang_hooks
.option_lang_mask ();
1181 /* Set a default printer. Language specific initializations will
1182 override it later. */
1183 tree_diagnostics_defaults (global_dc
);
1185 global_dc
->show_caret
1186 = global_options_init
.x_flag_diagnostics_show_caret
;
1187 global_dc
->show_labels_p
1188 = global_options_init
.x_flag_diagnostics_show_labels
;
1189 global_dc
->show_line_numbers_p
1190 = global_options_init
.x_flag_diagnostics_show_line_numbers
;
1191 global_dc
->show_option_requested
1192 = global_options_init
.x_flag_diagnostics_show_option
;
1193 global_dc
->min_margin_width
1194 = global_options_init
.x_diagnostics_minimum_margin_width
;
1195 global_dc
->show_column
1196 = global_options_init
.x_flag_show_column
;
1197 global_dc
->internal_error
= internal_error_function
;
1198 global_dc
->option_enabled
= option_enabled
;
1199 global_dc
->option_state
= &global_options
;
1200 global_dc
->option_name
= option_name
;
1201 global_dc
->get_option_url
= get_option_url
;
1205 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1207 signal (SIGSEGV
, crash_signal
);
1210 signal (SIGILL
, crash_signal
);
1213 signal (SIGBUS
, crash_signal
);
1216 signal (SIGABRT
, crash_signal
);
1218 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1219 signal (SIGIOT
, crash_signal
);
1222 signal (SIGFPE
, crash_signal
);
1225 /* Other host-specific signal setup. */
1226 (*host_hooks
.extra_signals
)();
1229 /* Initialize the garbage-collector, string pools and tree type hash
1233 input_location
= UNKNOWN_LOCATION
;
1234 line_table
= ggc_alloc
<line_maps
> ();
1235 linemap_init (line_table
, BUILTINS_LOCATION
);
1236 line_table
->reallocator
= realloc_for_line_map
;
1237 line_table
->round_alloc_size
= ggc_round_alloc_size
;
1238 line_table
->default_range_bits
= 5;
1241 /* Initialize register usage now so switches may override. */
1244 /* Register the language-independent parameters. */
1245 global_init_params ();
1247 /* This must be done after global_init_params but before argument
1249 init_ggc_heuristics ();
1251 /* Create the singleton holder for global state. This creates the
1253 g
= new gcc::context ();
1255 /* Allow languages and middle-end to register their dumps before the
1256 optimization passes. */
1257 g
->get_dumps ()->register_dumps ();
1259 /* Create the passes. */
1260 g
->set_passes (new gcc::pass_manager (g
));
1262 symtab
= new (ggc_alloc
<symbol_table
> ()) symbol_table ();
1264 statistics_early_init ();
1265 debuginfo_early_init ();
1269 /* Return true if the current target supports -fsection-anchors. */
1272 target_supports_section_anchors_p (void)
1274 if (targetm
.min_anchor_offset
== 0 && targetm
.max_anchor_offset
== 0)
1277 if (targetm
.asm_out
.output_anchor
== NULL
)
1283 /* Parse "N[:M][:...]" into struct align_flags A.
1284 VALUES contains parsed values (in reverse order), all processed
1285 values are popped. */
1288 read_log_maxskip (auto_vec
<unsigned> &values
, align_flags_tuple
*a
)
1290 unsigned n
= values
.pop ();
1292 a
->log
= floor_log2 (n
* 2 - 1);
1294 if (values
.is_empty ())
1295 a
->maxskip
= n
? n
- 1 : 0;
1298 unsigned m
= values
.pop ();
1299 /* -falign-foo=N:M means M-1 max bytes of padding, not M. */
1305 /* Normalize the tuple. */
1309 /* Parse "N[:M[:N2[:M2]]]" string FLAG into a pair of struct align_flags. */
1312 parse_N_M (const char *flag
, align_flags
&a
)
1316 static hash_map
<nofree_string_hash
, align_flags
> cache
;
1317 align_flags
*entry
= cache
.get (flag
);
1324 auto_vec
<unsigned> result_values
;
1325 bool r
= parse_and_check_align_values (flag
, NULL
, result_values
, false,
1330 /* Reverse values for easier manipulation. */
1331 result_values
.reverse ();
1333 read_log_maxskip (result_values
, &a
.levels
[0]);
1334 if (!result_values
.is_empty ())
1335 read_log_maxskip (result_values
, &a
.levels
[1]);
1339 /* N2[:M2] is not specified. This arch has a default for N2.
1340 Before -falign-foo=N:M:N2:M2 was introduced, x86 had a tweak.
1341 -falign-functions=N with N > 8 was adding secondary alignment.
1342 -falign-functions=10 was emitting this before every function:
1345 Now this behavior (and more) can be explicitly requested:
1346 -falign-functions=16:10:8
1347 Retain old behavior if N2 is missing: */
1349 int align
= 1 << a
.levels
[0].log
;
1350 int subalign
= 1 << SUBALIGN_LOG
;
1352 if (a
.levels
[0].log
> SUBALIGN_LOG
1353 && a
.levels
[0].maxskip
>= subalign
- 1)
1355 /* Set N2 unless subalign can never have any effect. */
1356 if (align
> a
.levels
[0].maxskip
+ 1)
1358 a
.levels
[1].log
= SUBALIGN_LOG
;
1359 a
.levels
[1].normalize ();
1365 /* Cache seen value. */
1366 cache
.put (flag
, a
);
1370 /* Process -falign-foo=N[:M[:N2[:M2]]] options. */
1373 parse_alignment_opts (void)
1375 parse_N_M (str_align_loops
, align_loops
);
1376 parse_N_M (str_align_jumps
, align_jumps
);
1377 parse_N_M (str_align_labels
, align_labels
);
1378 parse_N_M (str_align_functions
, align_functions
);
1381 /* Process the options that have been parsed. */
1383 process_options (void)
1385 /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1386 This can happen with incorrect pre-processed input. */
1387 debug_hooks
= &do_nothing_debug_hooks
;
1389 maximum_field_alignment
= initial_max_fld_align
* BITS_PER_UNIT
;
1391 /* Allow the front end to perform consistency checks and do further
1392 initialization based on the command line options. This hook also
1393 sets the original filename if appropriate (e.g. foo.i -> foo.c)
1394 so we can correctly initialize debug output. */
1395 no_backend
= lang_hooks
.post_options (&main_input_filename
);
1397 /* Some machines may reject certain combinations of options. */
1398 location_t saved_location
= input_location
;
1399 input_location
= UNKNOWN_LOCATION
;
1400 targetm
.target_option
.override ();
1401 input_location
= saved_location
;
1403 if (flag_diagnostics_generate_patch
)
1404 global_dc
->edit_context_ptr
= new edit_context ();
1406 /* Avoid any informative notes in the second run of -fcompare-debug. */
1407 if (flag_compare_debug
)
1408 diagnostic_inhibit_notes (global_dc
);
1410 if (flag_section_anchors
&& !target_supports_section_anchors_p ())
1412 warning_at (UNKNOWN_LOCATION
, OPT_fsection_anchors
,
1413 "this target does not support %qs",
1414 "-fsection-anchors");
1415 flag_section_anchors
= 0;
1418 if (flag_short_enums
== 2)
1419 flag_short_enums
= targetm
.default_short_enums ();
1421 /* Set aux_base_name if not already set. */
1424 else if (main_input_filename
)
1426 char *name
= xstrdup (lbasename (main_input_filename
));
1428 strip_off_ending (name
, strlen (name
));
1429 aux_base_name
= name
;
1432 aux_base_name
= "gccaux";
1436 || flag_loop_nest_optimize
1437 || flag_graphite_identity
1438 || flag_loop_parallelize_all
)
1439 sorry ("Graphite loop optimizations cannot be used (isl is not available) "
1440 "(%<-fgraphite%>, %<-fgraphite-identity%>, "
1441 "%<-floop-nest-optimize%>, %<-floop-parallelize-all%>)");
1444 if (flag_cf_protection
!= CF_NONE
1445 && !(flag_cf_protection
& CF_SET
))
1447 if (flag_cf_protection
== CF_FULL
)
1449 error_at (UNKNOWN_LOCATION
,
1450 "%<-fcf-protection=full%> is not supported for this "
1452 flag_cf_protection
= CF_NONE
;
1454 if (flag_cf_protection
== CF_BRANCH
)
1456 error_at (UNKNOWN_LOCATION
,
1457 "%<-fcf-protection=branch%> is not supported for this "
1459 flag_cf_protection
= CF_NONE
;
1461 if (flag_cf_protection
== CF_RETURN
)
1463 error_at (UNKNOWN_LOCATION
,
1464 "%<-fcf-protection=return%> is not supported for this "
1466 flag_cf_protection
= CF_NONE
;
1470 /* One region RA really helps to decrease the code size. */
1471 if (flag_ira_region
== IRA_REGION_AUTODETECT
)
1473 = optimize_size
|| !optimize
? IRA_REGION_ONE
: IRA_REGION_MIXED
;
1475 if (!abi_version_at_least (2))
1477 /* -fabi-version=1 support was removed after GCC 4.9. */
1478 error_at (UNKNOWN_LOCATION
,
1479 "%<-fabi-version=1%> is no longer supported");
1480 flag_abi_version
= 2;
1483 /* Unrolling all loops implies that standard loop unrolling must also
1485 if (flag_unroll_all_loops
)
1486 flag_unroll_loops
= 1;
1488 /* web and rename-registers help when run after loop unrolling. */
1489 if (flag_web
== AUTODETECT_VALUE
)
1490 flag_web
= flag_unroll_loops
;
1492 if (flag_rename_registers
== AUTODETECT_VALUE
)
1493 flag_rename_registers
= flag_unroll_loops
;
1495 if (flag_non_call_exceptions
)
1496 flag_asynchronous_unwind_tables
= 1;
1497 if (flag_asynchronous_unwind_tables
)
1498 flag_unwind_tables
= 1;
1500 if (flag_value_profile_transformations
)
1501 flag_profile_values
= 1;
1503 /* Warn about options that are not supported on this machine. */
1504 #ifndef INSN_SCHEDULING
1505 if (flag_schedule_insns
|| flag_schedule_insns_after_reload
)
1506 warning_at (UNKNOWN_LOCATION
, 0,
1507 "instruction scheduling not supported on this target machine");
1509 if (!DELAY_SLOTS
&& flag_delayed_branch
)
1510 warning_at (UNKNOWN_LOCATION
, 0,
1511 "this target machine does not have delayed branches");
1513 user_label_prefix
= USER_LABEL_PREFIX
;
1514 if (flag_leading_underscore
!= -1)
1516 /* If the default prefix is more complicated than "" or "_",
1517 issue a warning and ignore this option. */
1518 if (user_label_prefix
[0] == 0 ||
1519 (user_label_prefix
[0] == '_' && user_label_prefix
[1] == 0))
1521 user_label_prefix
= flag_leading_underscore
? "_" : "";
1524 warning_at (UNKNOWN_LOCATION
, 0,
1525 "%<-f%sleading-underscore%> not supported on this "
1526 "target machine", flag_leading_underscore
? "" : "no-");
1529 /* If we are in verbose mode, write out the version and maybe all the
1530 option flags in use. */
1533 print_version (stderr
, "", true);
1535 print_switch_values (print_to_stderr
);
1538 if (flag_syntax_only
)
1540 write_symbols
= NO_DEBUG
;
1546 if (debug_info_level
== DINFO_LEVEL_NONE
)
1548 debug_info_level
= DINFO_LEVEL_NORMAL
;
1550 if (write_symbols
== NO_DEBUG
)
1551 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1554 debug_info_level
= DINFO_LEVEL_NONE
;
1557 if (flag_dump_final_insns
&& !flag_syntax_only
&& !no_backend
)
1559 FILE *final_output
= fopen (flag_dump_final_insns
, "w");
1562 error_at (UNKNOWN_LOCATION
,
1563 "could not open final insn dump file %qs: %m",
1564 flag_dump_final_insns
);
1565 flag_dump_final_insns
= NULL
;
1567 else if (fclose (final_output
))
1569 error_at (UNKNOWN_LOCATION
,
1570 "could not close zeroed insn dump file %qs: %m",
1571 flag_dump_final_insns
);
1572 flag_dump_final_insns
= NULL
;
1576 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1578 if (debug_info_level
== DINFO_LEVEL_NONE
)
1579 write_symbols
= NO_DEBUG
;
1581 if (write_symbols
== NO_DEBUG
)
1583 #if defined(DBX_DEBUGGING_INFO)
1584 else if (write_symbols
== DBX_DEBUG
)
1585 debug_hooks
= &dbx_debug_hooks
;
1587 #if defined(XCOFF_DEBUGGING_INFO)
1588 else if (write_symbols
== XCOFF_DEBUG
)
1589 debug_hooks
= &xcoff_debug_hooks
;
1591 #ifdef DWARF2_DEBUGGING_INFO
1592 else if (write_symbols
== DWARF2_DEBUG
)
1593 debug_hooks
= &dwarf2_debug_hooks
;
1595 #ifdef VMS_DEBUGGING_INFO
1596 else if (write_symbols
== VMS_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
1597 debug_hooks
= &vmsdbg_debug_hooks
;
1599 #ifdef DWARF2_LINENO_DEBUGGING_INFO
1600 else if (write_symbols
== DWARF2_DEBUG
)
1601 debug_hooks
= &dwarf2_lineno_debug_hooks
;
1604 error_at (UNKNOWN_LOCATION
,
1605 "target system does not support the %qs debug format",
1606 debug_type_names
[write_symbols
]);
1608 /* We know which debug output will be used so we can set flag_var_tracking
1609 and flag_var_tracking_uninit if the user has not specified them. */
1610 if (debug_info_level
< DINFO_LEVEL_NORMAL
1611 || debug_hooks
->var_location
== do_nothing_debug_hooks
.var_location
)
1613 if (flag_var_tracking
== 1
1614 || flag_var_tracking_uninit
== 1)
1616 if (debug_info_level
< DINFO_LEVEL_NORMAL
)
1617 warning_at (UNKNOWN_LOCATION
, 0,
1618 "variable tracking requested, but useless unless "
1619 "producing debug info");
1621 warning_at (UNKNOWN_LOCATION
, 0,
1622 "variable tracking requested, but not supported "
1623 "by this debug format");
1625 flag_var_tracking
= 0;
1626 flag_var_tracking_uninit
= 0;
1629 /* The debug hooks are used to implement -fdump-go-spec because it
1630 gives a simple and stable API for all the information we need to
1632 if (flag_dump_go_spec
!= NULL
)
1633 debug_hooks
= dump_go_spec_init (flag_dump_go_spec
, debug_hooks
);
1635 /* If the user specifically requested variable tracking with tagging
1636 uninitialized variables, we need to turn on variable tracking.
1637 (We already determined above that variable tracking is feasible.) */
1638 if (flag_var_tracking_uninit
== 1)
1639 flag_var_tracking
= 1;
1641 if (flag_var_tracking
== AUTODETECT_VALUE
)
1642 flag_var_tracking
= optimize
>= 1;
1644 if (flag_var_tracking_uninit
== AUTODETECT_VALUE
)
1645 flag_var_tracking_uninit
= flag_var_tracking
;
1647 if (flag_var_tracking_assignments
== AUTODETECT_VALUE
)
1648 flag_var_tracking_assignments
1649 = (flag_var_tracking
1650 && !(flag_selective_scheduling
|| flag_selective_scheduling2
));
1652 if (flag_var_tracking_assignments_toggle
)
1653 flag_var_tracking_assignments
= !flag_var_tracking_assignments
;
1655 if (flag_var_tracking_assignments
&& !flag_var_tracking
)
1656 flag_var_tracking
= flag_var_tracking_assignments
= -1;
1658 if (flag_var_tracking_assignments
1659 && (flag_selective_scheduling
|| flag_selective_scheduling2
))
1660 warning_at (UNKNOWN_LOCATION
, 0,
1661 "var-tracking-assignments changes selective scheduling");
1663 if (debug_nonbind_markers_p
== AUTODETECT_VALUE
)
1664 debug_nonbind_markers_p
1666 && debug_info_level
>= DINFO_LEVEL_NORMAL
1667 && (write_symbols
== DWARF2_DEBUG
1668 || write_symbols
== VMS_AND_DWARF2_DEBUG
)
1669 && !(flag_selective_scheduling
|| flag_selective_scheduling2
));
1671 if (dwarf2out_as_loc_support
== AUTODETECT_VALUE
)
1672 dwarf2out_as_loc_support
1673 = dwarf2out_default_as_loc_support ();
1674 if (dwarf2out_as_locview_support
== AUTODETECT_VALUE
)
1675 dwarf2out_as_locview_support
1676 = dwarf2out_default_as_locview_support ();
1678 if (debug_variable_location_views
== AUTODETECT_VALUE
)
1680 debug_variable_location_views
1681 = (flag_var_tracking
1682 && debug_info_level
>= DINFO_LEVEL_NORMAL
1683 && (write_symbols
== DWARF2_DEBUG
1684 || write_symbols
== VMS_AND_DWARF2_DEBUG
)
1686 && dwarf2out_as_loc_support
1687 && dwarf2out_as_locview_support
);
1689 else if (debug_variable_location_views
== -1 && dwarf_version
!= 5)
1691 warning_at (UNKNOWN_LOCATION
, 0,
1692 "without %<-gdwarf-5%>, "
1693 "%<-gvariable-location-views=incompat5%> "
1694 "is equivalent to %<-gvariable-location-views%>");
1695 debug_variable_location_views
= 1;
1698 if (debug_internal_reset_location_views
== 2)
1700 debug_internal_reset_location_views
1701 = (debug_variable_location_views
1702 && targetm
.reset_location_view
);
1704 else if (debug_internal_reset_location_views
1705 && !debug_variable_location_views
)
1707 warning_at (UNKNOWN_LOCATION
, 0,
1708 "%<-ginternal-reset-location-views%> is forced disabled "
1709 "without %<-gvariable-location-views%>");
1710 debug_internal_reset_location_views
= 0;
1713 if (debug_inline_points
== AUTODETECT_VALUE
)
1714 debug_inline_points
= debug_variable_location_views
;
1715 else if (debug_inline_points
&& !debug_nonbind_markers_p
)
1717 warning_at (UNKNOWN_LOCATION
, 0,
1718 "%<-ginline-points%> is forced disabled without "
1719 "%<-gstatement-frontiers%>");
1720 debug_inline_points
= 0;
1723 if (flag_tree_cselim
== AUTODETECT_VALUE
)
1725 if (HAVE_conditional_move
)
1726 flag_tree_cselim
= 1;
1728 flag_tree_cselim
= 0;
1731 /* If auxiliary info generation is desired, open the output file.
1732 This goes in the same directory as the source file--unlike
1733 all the other output files. */
1734 if (flag_gen_aux_info
)
1736 aux_info_file
= fopen (aux_info_file_name
, "w");
1737 if (aux_info_file
== 0)
1738 fatal_error (UNKNOWN_LOCATION
,
1739 "cannot open %s: %m", aux_info_file_name
);
1742 if (!targetm_common
.have_named_sections
)
1744 if (flag_function_sections
)
1746 warning_at (UNKNOWN_LOCATION
, 0,
1747 "%<-ffunction-sections%> not supported for this target");
1748 flag_function_sections
= 0;
1750 if (flag_data_sections
)
1752 warning_at (UNKNOWN_LOCATION
, 0,
1753 "%<-fdata-sections%> not supported for this target");
1754 flag_data_sections
= 0;
1758 if (flag_prefetch_loop_arrays
> 0 && !targetm
.code_for_prefetch
)
1760 warning_at (UNKNOWN_LOCATION
, 0,
1761 "%<-fprefetch-loop-arrays%> not supported for this target");
1762 flag_prefetch_loop_arrays
= 0;
1764 else if (flag_prefetch_loop_arrays
> 0 && !targetm
.have_prefetch ())
1766 warning_at (UNKNOWN_LOCATION
, 0,
1767 "%<-fprefetch-loop-arrays%> not supported for this target "
1768 "(try %<-march%> switches)");
1769 flag_prefetch_loop_arrays
= 0;
1772 /* This combination of options isn't handled for i386 targets and doesn't
1773 make much sense anyway, so don't allow it. */
1774 if (flag_prefetch_loop_arrays
> 0 && optimize_size
)
1776 warning_at (UNKNOWN_LOCATION
, 0,
1777 "%<-fprefetch-loop-arrays%> is not supported with %<-Os%>");
1778 flag_prefetch_loop_arrays
= 0;
1781 /* The presence of IEEE signaling NaNs, implies all math can trap. */
1782 if (flag_signaling_nans
)
1783 flag_trapping_math
= 1;
1785 /* We cannot reassociate if we want traps or signed zeros. */
1786 if (flag_associative_math
&& (flag_trapping_math
|| flag_signed_zeros
))
1788 warning_at (UNKNOWN_LOCATION
, 0,
1789 "%<-fassociative-math%> disabled; other options take "
1791 flag_associative_math
= 0;
1794 /* -fstack-clash-protection is not currently supported on targets
1795 where the stack grows up. */
1796 if (flag_stack_clash_protection
&& !STACK_GROWS_DOWNWARD
)
1798 warning_at (UNKNOWN_LOCATION
, 0,
1799 "%<-fstack-clash-protection%> is not supported on targets "
1800 "where the stack grows from lower to higher addresses");
1801 flag_stack_clash_protection
= 0;
1804 /* We cannot support -fstack-check= and -fstack-clash-protection at
1806 if (flag_stack_check
!= NO_STACK_CHECK
&& flag_stack_clash_protection
)
1808 warning_at (UNKNOWN_LOCATION
, 0,
1809 "%<-fstack-check=%> and %<-fstack-clash_protection%> are "
1810 "mutually exclusive; disabling %<-fstack-check=%>");
1811 flag_stack_check
= NO_STACK_CHECK
;
1814 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1815 if (flag_cx_limited_range
)
1816 flag_complex_method
= 0;
1818 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1819 if (flag_cx_fortran_rules
)
1820 flag_complex_method
= 1;
1822 /* Targets must be able to place spill slots at lower addresses. If the
1823 target already uses a soft frame pointer, the transition is trivial. */
1824 if (!FRAME_GROWS_DOWNWARD
&& flag_stack_protect
)
1826 warning_at (UNKNOWN_LOCATION
, 0,
1827 "%<-fstack-protector%> not supported for this target");
1828 flag_stack_protect
= 0;
1830 if (!flag_stack_protect
)
1831 warn_stack_protect
= 0;
1833 /* Address Sanitizer needs porting to each target architecture. */
1835 if ((flag_sanitize
& SANITIZE_ADDRESS
)
1836 && (!FRAME_GROWS_DOWNWARD
|| targetm
.asan_shadow_offset
== NULL
))
1838 warning_at (UNKNOWN_LOCATION
, 0,
1839 "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> "
1840 "are not supported for this target");
1841 flag_sanitize
&= ~SANITIZE_ADDRESS
;
1844 /* Do not use IPA optimizations for register allocation if profiler is active
1845 or patchable function entries are inserted for run-time instrumentation
1846 or port does not emit prologue and epilogue as RTL. */
1847 if (profile_flag
|| function_entry_patch_area_size
1848 || !targetm
.have_prologue () || !targetm
.have_epilogue ())
1851 /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error
1852 have not been set. */
1853 if (!global_options_set
.x_warnings_are_errors
1854 && warn_coverage_mismatch
1855 && (global_dc
->classify_diagnostic
[OPT_Wcoverage_mismatch
] ==
1857 diagnostic_classify_diagnostic (global_dc
, OPT_Wcoverage_mismatch
,
1858 DK_ERROR
, UNKNOWN_LOCATION
);
1860 /* Save the current optimization options. */
1861 optimization_default_node
= build_optimization_node (&global_options
);
1862 optimization_current_node
= optimization_default_node
;
1864 if (flag_checking
>= 2)
1865 hash_table_sanitize_eq_limit
1866 = PARAM_VALUE (PARAM_HASH_TABLE_VERIFICATION_LIMIT
);
1868 /* Please don't change global_options after this point, those changes won't
1869 be reflected in optimization_{default,current}_node. */
1872 /* This function can be called multiple times to reinitialize the compiler
1873 back end when register classes or instruction sets have changed,
1874 before each function. */
1876 backend_init_target (void)
1878 /* This depends on stack_pointer_rtx. */
1879 init_fake_stack_mems ();
1881 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1883 init_alias_target ();
1885 /* Depends on HARD_FRAME_POINTER_REGNUM. */
1889 /* Depends on the enabled attribute. */
1892 /* The following initialization functions need to generate rtl, so
1893 provide a dummy function context for them. */
1894 init_dummy_function_start ();
1896 /* rtx_cost is mode-dependent, so cached values need to be recomputed
1897 on a mode change. */
1899 init_lower_subreg ();
1902 init_expr_target ();
1905 /* We may need to recompute regno_save_code[] and regno_restore_code[]
1906 after a mode change as well. */
1907 caller_save_initialized_p
= false;
1909 expand_dummy_function_end ();
1912 /* Initialize the compiler back end. This function is called only once,
1913 when starting the compiler. */
1920 init_inline_once ();
1921 init_varasm_once ();
1922 save_register_info ();
1924 /* Middle end needs this initialization for default mem attributes
1925 used by early calls to make_decl_rtl. */
1928 /* Middle end needs this initialization for mode tables used to assign
1929 modes to vector variables. */
1933 /* Initialize things that are both lang-dependent and target-dependent.
1934 This function can be called more than once if target parameters change. */
1936 lang_dependent_init_target (void)
1938 /* This creates various _DECL nodes, so needs to be called after the
1939 front end is initialized. It also depends on the HAVE_xxx macros
1940 generated from the target machine description. */
1943 gcc_assert (!this_target_rtl
->target_specific_initialized
);
1946 /* Perform initializations that are lang-dependent or target-dependent.
1947 but matters only for late optimizations and RTL generation. */
1949 static int rtl_initialized
;
1952 initialize_rtl (void)
1954 auto_timevar
tv (g_timer
, TV_INITIALIZE_RTL
);
1956 /* Initialization done just once per compilation, but delayed
1957 till code generation. */
1958 if (!rtl_initialized
)
1960 rtl_initialized
= true;
1962 /* Target specific RTL backend initialization. */
1963 if (!this_target_rtl
->target_specific_initialized
)
1965 backend_init_target ();
1966 this_target_rtl
->target_specific_initialized
= true;
1970 /* Language-dependent initialization. Returns nonzero on success. */
1972 lang_dependent_init (const char *name
)
1974 location_t save_loc
= input_location
;
1975 if (dump_base_name
== 0)
1976 dump_base_name
= name
&& name
[0] ? name
: "gccdump";
1978 /* Other front-end initialization. */
1979 input_location
= BUILTINS_LOCATION
;
1980 if (lang_hooks
.init () == 0)
1982 input_location
= save_loc
;
1986 init_asm_output (name
);
1988 /* If stack usage information is desired, open the output file. */
1989 if (flag_stack_usage
&& !flag_generate_lto
)
1990 stack_usage_file
= open_auxiliary_file ("su");
1992 /* If call graph information is desired, open the output file. */
1993 if (flag_callgraph_info
&& !flag_generate_lto
)
1995 callgraph_info_file
= open_auxiliary_file ("ci");
1996 /* Write the file header. */
1997 fprintf (callgraph_info_file
,
1998 "graph: { title: \"%s\"\n", main_input_filename
);
1999 bitmap_obstack_initialize (NULL
);
2000 callgraph_info_external_printed
= BITMAP_ALLOC (NULL
);
2004 /* This creates various _DECL nodes, so needs to be called after the
2005 front end is initialized. */
2008 /* Do the target-specific parts of the initialization. */
2009 lang_dependent_init_target ();
2013 /* If dbx symbol table desired, initialize writing it and output the
2014 predefined types. */
2015 timevar_push (TV_SYMOUT
);
2017 /* Now we have the correct original filename, we can initialize
2019 (*debug_hooks
->init
) (name
);
2021 timevar_pop (TV_SYMOUT
);
2028 /* Reinitialize everything when target parameters, such as register usage,
2031 target_reinit (void)
2033 struct rtl_data saved_x_rtl
;
2034 rtx
*saved_regno_reg_rtx
;
2035 tree saved_optimization_current_node
;
2036 struct target_optabs
*saved_this_fn_optabs
;
2038 /* Temporarily switch to the default optimization node, so that
2039 *this_target_optabs is set to the default, not reflecting
2040 whatever a previous function used for the optimize
2042 saved_optimization_current_node
= optimization_current_node
;
2043 saved_this_fn_optabs
= this_fn_optabs
;
2044 if (saved_optimization_current_node
!= optimization_default_node
)
2046 optimization_current_node
= optimization_default_node
;
2047 cl_optimization_restore
2049 TREE_OPTIMIZATION (optimization_default_node
));
2051 this_fn_optabs
= this_target_optabs
;
2053 /* Save *crtl and regno_reg_rtx around the reinitialization
2054 to allow target_reinit being called even after prepare_function_start. */
2055 saved_regno_reg_rtx
= regno_reg_rtx
;
2056 if (saved_regno_reg_rtx
)
2058 saved_x_rtl
= *crtl
;
2059 memset (crtl
, '\0', sizeof (*crtl
));
2060 regno_reg_rtx
= NULL
;
2063 this_target_rtl
->target_specific_initialized
= false;
2065 /* This initializes hard_frame_pointer, and calls init_reg_modes_target()
2066 to initialize reg_raw_mode[]. */
2069 /* This invokes target hooks to set fixed_reg[] etc, which is
2073 /* Reinitialize lang-dependent parts. */
2074 lang_dependent_init_target ();
2076 /* Restore the original optimization node. */
2077 if (saved_optimization_current_node
!= optimization_default_node
)
2079 optimization_current_node
= saved_optimization_current_node
;
2080 cl_optimization_restore (&global_options
,
2081 TREE_OPTIMIZATION (optimization_current_node
));
2083 this_fn_optabs
= saved_this_fn_optabs
;
2085 /* Restore regno_reg_rtx at the end, as free_after_compilation from
2086 expand_dummy_function_end clears it. */
2087 if (saved_regno_reg_rtx
)
2089 *crtl
= saved_x_rtl
;
2090 regno_reg_rtx
= saved_regno_reg_rtx
;
2091 saved_regno_reg_rtx
= NULL
;
2096 dump_memory_report (const char *header
)
2098 /* Print significant header. */
2099 fputc ('\n', stderr
);
2100 for (unsigned i
= 0; i
< 80; i
++)
2101 fputc ('#', stderr
);
2102 fprintf (stderr
, "\n# %-77s#\n", header
);
2103 for (unsigned i
= 0; i
< 80; i
++)
2104 fputc ('#', stderr
);
2105 fputs ("\n\n", stderr
);
2107 dump_line_table_statistics ();
2108 ggc_print_statistics ();
2109 stringpool_statistics ();
2110 dump_tree_statistics ();
2111 dump_gimple_statistics ();
2112 dump_rtx_statistics ();
2113 dump_alloc_pool_statistics ();
2114 dump_bitmap_statistics ();
2115 dump_hash_table_loc_statistics ();
2116 dump_vec_loc_statistics ();
2117 dump_ggc_loc_statistics ();
2118 dump_alias_stats (stderr
);
2119 dump_pta_stats (stderr
);
2122 /* Clean up: close opened files, etc. */
2125 finalize (bool no_backend
)
2127 /* Close the dump files. */
2128 if (flag_gen_aux_info
)
2130 fclose (aux_info_file
);
2131 aux_info_file
= NULL
;
2133 unlink (aux_info_file_name
);
2136 /* Close non-debugging input and output files. Take special care to note
2137 whether fclose returns an error, since the pages might still be on the
2138 buffer chain while the file is open. */
2142 if (ferror (asm_out_file
) != 0)
2143 fatal_error (input_location
, "error writing to %s: %m", asm_file_name
);
2144 if (fclose (asm_out_file
) != 0)
2145 fatal_error (input_location
, "error closing %s: %m", asm_file_name
);
2146 asm_out_file
= NULL
;
2149 if (stack_usage_file
)
2151 fclose (stack_usage_file
);
2152 stack_usage_file
= NULL
;
2155 if (callgraph_info_file
)
2157 fputs ("}\n", callgraph_info_file
);
2158 fclose (callgraph_info_file
);
2159 callgraph_info_file
= NULL
;
2160 BITMAP_FREE (callgraph_info_external_printed
);
2161 bitmap_obstack_release (NULL
);
2165 coverage_remove_note_file ();
2172 g
->get_passes ()->finish_optimization_passes ();
2178 dump_memory_report ("Final");
2181 dump_profile_report ();
2183 /* Language-specific end of compilation actions. */
2184 lang_hooks
.finish ();
2188 standard_type_bitsize (int bitsize
)
2190 /* As a special exception, we always want __int128 enabled if possible. */
2193 if (bitsize
== CHAR_TYPE_SIZE
2194 || bitsize
== SHORT_TYPE_SIZE
2195 || bitsize
== INT_TYPE_SIZE
2196 || bitsize
== LONG_TYPE_SIZE
2197 || bitsize
== LONG_LONG_TYPE_SIZE
)
2202 /* Initialize the compiler, and compile the input file. */
2208 /* Don't do any more if an error has already occurred. */
2213 timevar_start (TV_PHASE_SETUP
);
2215 if (flag_save_optimization_record
)
2217 dump_context::get ().set_json_writer (new optrecord_json_writer ());
2220 /* This must be run always, because it is needed to compute the FP
2221 predefined macros, such as __LDBL_MAX__, for targets using non
2222 default FP formats. */
2223 init_adjust_machine_modes ();
2224 init_derived_machine_modes ();
2226 /* This must happen after the backend has a chance to process
2227 command line options, but before the parsers are
2229 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
2230 if (targetm
.scalar_mode_supported_p (int_n_data
[i
].m
)
2231 && ! standard_type_bitsize (int_n_data
[i
].bitsize
))
2232 int_n_enabled_p
[i
] = true;
2234 int_n_enabled_p
[i
] = false;
2236 /* Initialize mpfrs exponent range. This is important to get
2237 underflow/overflow in a reasonable timeframe. */
2241 FOR_EACH_MODE_IN_CLASS (mode
, MODE_FLOAT
)
2242 if (SCALAR_FLOAT_MODE_P (mode
))
2244 const real_format
*fmt
= REAL_MODE_FORMAT (mode
);
2247 /* fmt->emin - fmt->p + 1 should be enough but the
2248 back-and-forth dance in real_to_decimal_for_mode we
2249 do for checking fails due to rounding effects then. */
2250 if ((fmt
->emin
- fmt
->p
) < min_exp
)
2251 min_exp
= fmt
->emin
- fmt
->p
;
2252 if (fmt
->emax
> max_exp
)
2253 max_exp
= fmt
->emax
;
2256 /* E.g. mpc_norm assumes it can square a number without bothering with
2257 with range scaling, so until that is fixed, double the minimum
2258 and maximum exponents, plus add some buffer for arithmetics
2259 on the squared numbers. */
2260 if (mpfr_set_emin (2 * (min_exp
- 1))
2261 || mpfr_set_emax (2 * (max_exp
+ 1)))
2262 sorry ("mpfr not configured to handle all floating modes");
2264 /* Set up the back-end if requested. */
2268 /* Language-dependent initialization. Returns true on success. */
2269 if (lang_dependent_init (main_input_filename
))
2271 /* Initialize yet another pass. */
2273 ggc_protect_identifiers
= true;
2275 symtab
->initialize ();
2276 init_final (main_input_filename
);
2277 coverage_init (aux_base_name
);
2280 invoke_plugin_callbacks (PLUGIN_START_UNIT
, NULL
);
2282 timevar_stop (TV_PHASE_SETUP
);
2288 timevar_stop (TV_PHASE_SETUP
);
2291 timevar_start (TV_PHASE_FINALIZE
);
2293 finalize (no_backend
);
2295 timevar_stop (TV_PHASE_FINALIZE
);
2299 toplev::toplev (timer
*external_timer
,
2301 : m_use_TV_TOTAL (external_timer
== NULL
),
2302 m_init_signals (init_signals
)
2305 g_timer
= external_timer
;
2310 if (g_timer
&& m_use_TV_TOTAL
)
2312 g_timer
->stop (TV_TOTAL
);
2313 g_timer
->print (stderr
);
2319 /* Potentially call timevar_init (which will create g_timevars if it
2320 doesn't already exist). */
2323 toplev::start_timevars ()
2325 if (time_report
|| !quiet_flag
|| flag_detailed_statistics
)
2328 timevar_start (TV_TOTAL
);
2331 /* Handle -fself-test. */
2334 toplev::run_self_tests ()
2338 error_at (UNKNOWN_LOCATION
, "self-tests incompatible with %<-E%>");
2342 /* Reset some state. */
2343 input_location
= UNKNOWN_LOCATION
;
2344 bitmap_obstack_initialize (NULL
);
2346 /* Run the tests; any failures will lead to an abort of the process.
2347 Use "make selftests-gdb" to run under the debugger. */
2348 ::selftest::run_tests ();
2351 bitmap_obstack_release (NULL
);
2353 inform (UNKNOWN_LOCATION
, "self-tests are not enabled in this build");
2354 #endif /* #if CHECKING_P */
2357 /* Entry point of cc1, cc1plus, jc1, f771, etc.
2358 Exit code is FATAL_EXIT_CODE if can't open files or if there were
2359 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2361 It is not safe to call this function more than once. */
2364 toplev::main (int argc
, char **argv
)
2366 /* Parsing and gimplification sometimes need quite large stack.
2367 Increase stack size limits if possible. */
2368 stack_limit_increase (64 * 1024 * 1024);
2370 expandargv (&argc
, &argv
);
2372 /* Initialization of GCC's environment, and diagnostics. */
2373 general_init (argv
[0], m_init_signals
);
2375 /* One-off initialization of options that does not need to be
2376 repeated when options are added for particular functions. */
2377 init_options_once ();
2378 init_opts_obstack ();
2380 /* Initialize global options structures; this must be repeated for
2381 each structure used for parsing options. */
2382 init_options_struct (&global_options
, &global_options_set
);
2383 lang_hooks
.init_options_struct (&global_options
);
2385 /* Convert the options to an array. */
2386 decode_cmdline_options_to_array_default_mask (argc
,
2387 CONST_CAST2 (const char **,
2389 &save_decoded_options
,
2390 &save_decoded_options_count
);
2392 /* Perform language-specific options initialization. */
2393 lang_hooks
.init_options (save_decoded_options_count
, save_decoded_options
);
2395 /* Parse the options and do minimal processing; basically just
2396 enough to default flags appropriately. */
2397 decode_options (&global_options
, &global_options_set
,
2398 save_decoded_options
, save_decoded_options_count
,
2399 UNKNOWN_LOCATION
, global_dc
,
2400 targetm
.target_option
.override
);
2402 handle_common_deferred_options ();
2406 initialize_plugins ();
2409 print_version (stderr
, "", true);
2412 print_plugins_help (stderr
, "");
2414 /* Exit early if we can (e.g. -help). */
2415 if (!exit_after_options
)
2422 if (warningcount
|| errorcount
|| werrorcount
)
2423 print_ignored_options ();
2428 /* Invoke registered plugin callbacks if any. Some plugins could
2429 emit some diagnostics here. */
2430 invoke_plugin_callbacks (PLUGIN_FINISH
, NULL
);
2432 if (flag_diagnostics_generate_patch
)
2434 gcc_assert (global_dc
->edit_context_ptr
);
2437 pp_show_color (&pp
) = pp_show_color (global_dc
->printer
);
2438 global_dc
->edit_context_ptr
->print_diff (&pp
, true);
2442 diagnostic_finish (global_dc
);
2444 finalize_plugins ();
2446 after_memory_report
= true;
2448 if (seen_error () || werrorcount
)
2449 return (FATAL_EXIT_CODE
);
2451 return (SUCCESS_EXIT_CODE
);
2454 /* For those that want to, this function aims to clean up enough state that
2455 you can call toplev::main again. */
2457 toplev::finalize (void)
2459 rtl_initialized
= false;
2460 this_target_rtl
->target_specific_initialized
= false;
2462 /* Needs to be called before cgraph_c_finalize since it uses symtab. */
2463 ipa_reference_c_finalize ();
2464 ipa_fnsummary_c_finalize ();
2466 cgraph_c_finalize ();
2467 cgraphunit_c_finalize ();
2468 dwarf2out_c_finalize ();
2470 ipa_cp_c_finalize ();
2471 ira_costs_c_finalize ();
2472 params_c_finalize ();
2474 finalize_options_struct (&global_options
);
2475 finalize_options_struct (&global_options_set
);
2477 /* save_decoded_options uses opts_obstack, so these must
2478 be cleaned up together. */
2479 obstack_free (&opts_obstack
, NULL
);
2480 XDELETEVEC (save_decoded_options
);
2481 save_decoded_options
= NULL
;
2482 save_decoded_options_count
= 0;
2484 /* Clean up the context (and pass_manager etc). */