1/* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
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. */
24
25#include "config.h"
26#include "system.h"
27#include "coretypes.h"
28#include "backend.h"
29#include "target.h"
30#include "rtl.h"
31#include "tree.h"
32#include "gimple.h"
33#include "alloc-pool.h"
34#include "timevar.h"
35#include "tm_p.h"
36#include "optabs-libfuncs.h"
37#include "insn-config.h"
38#include "ira.h"
39#include "recog.h"
40#include "cgraph.h"
41#include "coverage.h"
42#include "diagnostic.h"
43#include "varasm.h"
44#include "tree-inline.h"
45#include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */
46#include "version.h"
47#include "flags.h"
48#include "insn-attr.h"
49#include "output.h"
50#include "toplev.h"
51#include "expr.h"
52#include "intl.h"
53#include "tree-diagnostic.h"
54#include "params.h"
55#include "reload.h"
56#include "lra.h"
57#include "dwarf2asm.h"
58#include "debug.h"
59#include "common/common-target.h"
60#include "langhooks.h"
61#include "cfgloop.h" /* for init_set_costs */
62#include "hosthooks.h"
63#include "opts.h"
64#include "opts-diagnostic.h"
65#include "asan.h"
66#include "tsan.h"
67#include "plugin.h"
68#include "context.h"
69#include "pass_manager.h"
70#include "auto-profile.h"
71#include "dwarf2out.h"
72#include "ipa-reference.h"
73#include "symbol-summary.h"
74#include "tree-vrp.h"
75#include "ipa-prop.h"
76#include "gcse.h"
77#include "tree-chkp.h"
78#include "omp-low.h"
79#include "hsa.h"
80#include "edit-context.h"
81
82#if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
83#include "dbxout.h"
84#endif
85
86#include "sdbout.h"
87
88#ifdef XCOFF_DEBUGGING_INFO
89#include "xcoffout.h" /* Needed for external data declarations. */
90#endif
91
92#include "selftest.h"
93
94static void general_init (const char *, bool);
95static void do_compile ();
96static void process_options (void);
97static void backend_init (void);
98static int lang_dependent_init (const char *);
99static void init_asm_output (const char *);
100static void finalize (bool);
101
102static void crash_signal (int) ATTRIBUTE_NORETURN;
103static void compile_file (void);
104
105/* True if we don't need a backend (e.g. preprocessing only). */
106static bool no_backend;
107
108/* Length of line when printing switch values. */
109#define MAX_LINE 75
110
111/* Decoded options, and number of such options. */
112struct cl_decoded_option *save_decoded_options;
113unsigned int save_decoded_options_count;
114
115/* Used to enable -fvar-tracking, -fweb and -frename-registers according
116 to optimize in process_options (). */
117#define AUTODETECT_VALUE 2
118
119/* Debug hooks - dependent upon command line options. */
120
121const struct gcc_debug_hooks *debug_hooks;
122
123/* The FUNCTION_DECL for the function currently being compiled,
124 or 0 if between functions. */
125tree current_function_decl;
126
127/* Set to the FUNC_BEGIN label of the current function, or NULL
128 if none. */
129const char * current_function_func_begin_label;
130
131/* A random sequence of characters, unless overridden by user. */
132static const char *flag_random_seed;
133
134/* A local time stamp derived from the time of compilation. It will be
135 zero if the system cannot provide a time. It will be -1u, if the
136 user has specified a particular random seed. */
137unsigned local_tick;
138
139/* Random number for this compilation */
140HOST_WIDE_INT random_seed;
141
142/* -f flags. */
143
144/* When non-NULL, indicates that whenever space is allocated on the
145 stack, the resulting stack pointer must not pass this
146 address---that is, for stacks that grow downward, the stack pointer
147 must always be greater than or equal to this address; for stacks
148 that grow upward, the stack pointer must be less than this address.
149 At present, the rtx may be either a REG or a SYMBOL_REF, although
150 the support provided depends on the backend. */
151rtx stack_limit_rtx;
152
153/* True if the user has tagged the function with the 'section'
154 attribute. */
155
156bool user_defined_section_attribute = false;
157
158struct target_flag_state default_target_flag_state;
159#if SWITCHABLE_TARGET
160struct target_flag_state *this_target_flag_state = &default_target_flag_state;
161#else
162#define this_target_flag_state (&default_target_flag_state)
163#endif
164
165/* The user symbol prefix after having resolved same. */
166const char *user_label_prefix;
167
168/* Output files for assembler code (real compiler output)
169 and debugging dumps. */
170
171FILE *asm_out_file;
172FILE *aux_info_file;
173FILE *stack_usage_file = NULL;
174
175/* The current working directory of a translation. It's generally the
176 directory from which compilation was initiated, but a preprocessed
177 file may specify the original directory in which it was
178 created. */
179
180static const char *src_pwd;
181
182/* Initialize src_pwd with the given string, and return true. If it
183 was already initialized, return false. As a special case, it may
184 be called with a NULL argument to test whether src_pwd has NOT been
185 initialized yet. */
186
187bool
188set_src_pwd (const char *pwd)
189{
190 if (src_pwd)
191 {
192 if (strcmp (src_pwd, pwd) == 0)
193 return true;
194 else
195 return false;
196 }
197
198 src_pwd = xstrdup (pwd);
199 return true;
200}
201
202/* Return the directory from which the translation unit was initiated,
203 in case set_src_pwd() was not called before to assign it a
204 different value. */
205
206const char *
207get_src_pwd (void)
208{
209 if (! src_pwd)
210 {
211 src_pwd = getpwd ();
212 if (!src_pwd)
213 src_pwd = ".";
214 }
215
216 return src_pwd;
217}
218
219/* Called when the start of a function definition is parsed,
220 this function prints on stderr the name of the function. */
221void
222announce_function (tree decl)
223{
224 if (!quiet_flag)
225 {
226 if (rtl_dump_and_exit)
227 fprintf (stderr, "%s ",
228 identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl))));
229 else
230 fprintf (stderr, " %s",
231 identifier_to_locale (lang_hooks.decl_printable_name (decl, 2)));
232 fflush (stderr);
233 pp_needs_newline (global_dc->printer) = true;
234 diagnostic_set_last_function (global_dc, (diagnostic_info *) NULL);
235 }
236}
237
238/* Initialize local_tick with a random number or -1 if
239 flag_random_seed is set. */
240
241static void
242init_local_tick (void)
243{
244 if (!flag_random_seed)
245 {
246 /* Try urandom first. Time of day is too likely to collide.
247 In case of any error we just use the local tick. */
248
249 int fd = open ("/dev/urandom", O_RDONLY);
250 if (fd >= 0)
251 {
252 if (read (fd, &random_seed, sizeof (random_seed))
253 != sizeof (random_seed))
254 random_seed = 0;
255 close (fd);
256 }
257
258 /* Now get the tick anyways */
259#ifdef HAVE_GETTIMEOFDAY
260 {
261 struct timeval tv;
262
263 gettimeofday (&tv, NULL);
264 local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000;
265 }
266#else
267 {
268 time_t now = time (NULL);
269
270 if (now != (time_t)-1)
271 local_tick = (unsigned) now;
272 }
273#endif
274 }
275 else
276 local_tick = -1;
277}
278
279/* Set up a default flag_random_seed and local_tick, unless the user
280 already specified one. Must be called after init_local_tick. */
281
282static void
283init_random_seed (void)
284{
285 if (!random_seed)
286 random_seed = local_tick ^ getpid (); /* Old racey fallback method */
287}
288
289/* Obtain the random_seed. Unless NOINIT, initialize it if
290 it's not provided in the command line. */
291
292HOST_WIDE_INT
293get_random_seed (bool noinit)
294{
295 if (!flag_random_seed && !noinit)
296 init_random_seed ();
297 return random_seed;
298}
299
300/* Modify the random_seed string to VAL. Return its previous
301 value. */
302
303const char *
304set_random_seed (const char *val)
305{
306 const char *old = flag_random_seed;
307 flag_random_seed = val;
308 if (flag_random_seed)
309 {
310 char *endp;
311
312 /* When the driver passed in a hex number don't crc it again */
313 random_seed = strtoul (flag_random_seed, &endp, 0);
314 if (!(endp > flag_random_seed && *endp == 0))
315 random_seed = crc32_string (0, flag_random_seed);
316 }
317 return old;
318}
319
320/* Handler for fatal signals, such as SIGSEGV. These are transformed
321 into ICE messages, which is much more user friendly. In case the
322 error printer crashes, reset the signal to prevent infinite recursion. */
323
324static void
325crash_signal (int signo)
326{
327 signal (signo, SIG_DFL);
328
329 /* If we crashed while processing an ASM statement, then be a little more
330 graceful. It's most likely the user's fault. */
331 if (this_is_asm_operands)
332 {
333 output_operand_lossage ("unrecoverable error");
334 exit (FATAL_EXIT_CODE);
335 }
336
337 internal_error ("%s", strsignal (signo));
338}
339
340/* A subroutine of wrapup_global_declarations. We've come to the end of
341 the compilation unit. All deferred variables should be undeferred,
342 and all incomplete decls should be finalized. */
343
344void
345wrapup_global_declaration_1 (tree decl)
346{
347 /* We're not deferring this any longer. Assignment is conditional to
348 avoid needlessly dirtying PCH pages. */
349 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
350 && DECL_DEFER_OUTPUT (decl) != 0)
351 DECL_DEFER_OUTPUT (decl) = 0;
352
353 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0)
354 lang_hooks.finish_incomplete_decl (decl);
355}
356
357/* A subroutine of wrapup_global_declarations. Decide whether or not DECL
358 needs to be output. Return true if it is output. */
359
360bool
361wrapup_global_declaration_2 (tree decl)
362{
363 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl)
364 || (TREE_CODE (decl) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (decl)))
365 return false;
366
367 /* Don't write out static consts, unless we still need them.
368
369 We also keep static consts if not optimizing (for debugging),
370 unless the user specified -fno-keep-static-consts.
371 ??? They might be better written into the debug information.
372 This is possible when using DWARF.
373
374 A language processor that wants static constants to be always
375 written out (even if it is not used) is responsible for
376 calling rest_of_decl_compilation itself. E.g. the C front-end
377 calls rest_of_decl_compilation from finish_decl.
378 One motivation for this is that is conventional in some
379 environments to write things like:
380 static const char rcsid[] = "... version string ...";
381 intending to force the string to be in the executable.
382
383 A language processor that would prefer to have unneeded
384 static constants "optimized away" would just defer writing
385 them out until here. E.g. C++ does this, because static
386 constants are often defined in header files.
387
388 ??? A tempting alternative (for both C and C++) would be
389 to force a constant to be written if and only if it is
390 defined in a main file, as opposed to an include file. */
391
392 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
393 {
394 varpool_node *node;
395 bool needed = true;
396 node = varpool_node::get (decl);
397
398 if (!node && flag_ltrans)
399 needed = false;
400 else if (node && node->definition)
401 needed = false;
402 else if (node && node->alias)
403 needed = false;
404 else if (!symtab->global_info_ready
405 && (TREE_USED (decl)
406 || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
407 /* needed */;
408 else if (node && node->analyzed)
409 /* needed */;
410 else if (DECL_COMDAT (decl))
411 needed = false;
412 else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
413 && (optimize || !flag_keep_static_consts
414 || DECL_ARTIFICIAL (decl)))
415 needed = false;
416
417 if (needed)
418 {
419 rest_of_decl_compilation (decl, 1, 1);
420 return true;
421 }
422 }
423
424 return false;
425}
426
427/* Do any final processing required for the declarations in VEC, of
428 which there are LEN. We write out inline functions and variables
429 that have been deferred until this point, but which are required.
430 Returns nonzero if anything was put out. */
431
432bool
433wrapup_global_declarations (tree *vec, int len)
434{
435 bool reconsider, output_something = false;
436 int i;
437
438 for (i = 0; i < len; i++)
439 wrapup_global_declaration_1 (vec[i]);
440
441 /* Now emit any global variables or functions that we have been
442 putting off. We need to loop in case one of the things emitted
443 here references another one which comes earlier in the list. */
444 do
445 {
446 reconsider = false;
447 for (i = 0; i < len; i++)
448 reconsider |= wrapup_global_declaration_2 (vec[i]);
449 if (reconsider)
450 output_something = true;
451 }
452 while (reconsider);
453
454 return output_something;
455}
456
457/* Compile an entire translation unit. Write a file of assembly
458 output and various debugging dumps. */
459
460static void
461compile_file (void)
462{
463 timevar_start (TV_PHASE_PARSING);
464 timevar_push (TV_PARSE_GLOBAL);
465
466 /* Parse entire file and generate initial debug information. */
467 lang_hooks.parse_file ();
468
469 timevar_pop (TV_PARSE_GLOBAL);
470 timevar_stop (TV_PHASE_PARSING);
471
472 if (flag_dump_locations)
473 dump_location_info (stderr);
474
475 /* Compilation is now finished except for writing
476 what's left of the symbol table output. */
477
478 if (flag_syntax_only || flag_wpa)
479 return;
480
481 /* Reset maximum_field_alignment, it can be adjusted by #pragma pack
482 and this shouldn't influence any types built by the middle-end
483 from now on (like gcov_info_type). */
484 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
485
486 ggc_protect_identifiers = false;
487
488 /* Run the actual compilation process. */
489 if (!in_lto_p)
490 {
491 timevar_start (TV_PHASE_OPT_GEN);
492 symtab->finalize_compilation_unit ();
493 timevar_stop (TV_PHASE_OPT_GEN);
494 }
495
496 /* Perform any post compilation-proper parser cleanups and
497 processing. This is currently only needed for the C++ parser,
498 which can be hopefully cleaned up so this hook is no longer
499 necessary. */
500 if (lang_hooks.decls.post_compilation_parsing_cleanups)
501 lang_hooks.decls.post_compilation_parsing_cleanups ();
502
503 if (seen_error ())
504 return;
505
506 timevar_start (TV_PHASE_LATE_ASM);
507
508 /* Compilation unit is finalized. When producing non-fat LTO object, we are
509 basically finished. */
510 if (in_lto_p || !flag_lto || flag_fat_lto_objects)
511 {
512 /* File-scope initialization for AddressSanitizer. */
513 if (flag_sanitize & SANITIZE_ADDRESS)
514 asan_finish_file ();
515
516 if (flag_sanitize & SANITIZE_THREAD)
517 tsan_finish_file ();
518
519 if (flag_check_pointer_bounds)
520 chkp_finish_file ();
521
522 omp_finish_file ();
523
524 hsa_output_brig ();
525
526 output_shared_constant_pool ();
527 output_object_blocks ();
528 finish_tm_clone_pairs ();
529
530 /* Write out any pending weak symbol declarations. */
531 weak_finish ();
532
533 /* This must be at the end before unwind and debug info.
534 Some target ports emit PIC setup thunks here. */
535 targetm.asm_out.code_end ();
536
537 /* Do dbx symbols. */
538 timevar_push (TV_SYMOUT);
539
540 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
541 if (dwarf2out_do_frame ())
542 dwarf2out_frame_finish ();
543 #endif
544
545 (*debug_hooks->finish) (main_input_filename);
546 timevar_pop (TV_SYMOUT);
547
548 /* Output some stuff at end of file if nec. */
549
550 dw2_output_indirect_constants ();
551
552 /* Flush any pending external directives. */
553 process_pending_assemble_externals ();
554 }
555
556 /* Emit LTO marker if LTO info has been previously emitted. This is
557 used by collect2 to determine whether an object file contains IL.
558 We used to emit an undefined reference here, but this produces
559 link errors if an object file with IL is stored into a shared
560 library without invoking lto1. */
561 if (flag_generate_lto || flag_generate_offload)
562 {
563#if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
564 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE,
565 "__gnu_lto_v1",
566 HOST_WIDE_INT_1U, 8);
567#elif defined ASM_OUTPUT_ALIGNED_COMMON
568 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1",
569 HOST_WIDE_INT_1U, 8);
570#else
571 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1",
572 HOST_WIDE_INT_1U,
573 HOST_WIDE_INT_1U);
574#endif
575 }
576
577 /* Let linker plugin know that this is a slim object and must be LTOed
578 even when user did not ask for it. */
579 if (flag_generate_lto && !flag_fat_lto_objects)
580 {
581#if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
582 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, "__gnu_lto_slim",
583 HOST_WIDE_INT_1U, 8);
584#elif defined ASM_OUTPUT_ALIGNED_COMMON
585 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_slim",
586 HOST_WIDE_INT_1U, 8);
587#else
588 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_slim",
589 HOST_WIDE_INT_1U,
590 HOST_WIDE_INT_1U);
591#endif
592 }
593
594 /* Attach a special .ident directive to the end of the file to identify
595 the version of GCC which compiled this code. The format of the .ident
596 string is patterned after the ones produced by native SVR4 compilers. */
597 if (!flag_no_ident)
598 {
599 const char *pkg_version = "(GNU) ";
600 char *ident_str;
601
602 if (strcmp ("(GCC) ", pkgversion_string))
603 pkg_version = pkgversion_string;
604
605 ident_str = ACONCAT (("GCC: ", pkg_version, version_string, NULL));
606 targetm.asm_out.output_ident (ident_str);
607 }
608
609 /* Auto profile finalization. */
610 if (flag_auto_profile)
611 end_auto_profile ();
612
613 /* Invoke registered plugin callbacks. */
614 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
615
616 /* This must be at the end. Some target ports emit end of file directives
617 into the assembly file here, and hence we can not output anything to the
618 assembly file after this point. */
619 targetm.asm_out.file_end ();
620
621 timevar_stop (TV_PHASE_LATE_ASM);
622}
623
624/* Print version information to FILE.
625 Each line begins with INDENT (for the case where FILE is the
626 assembler output file).
627
628 If SHOW_GLOBAL_STATE is true (for cc1 etc), we are within the compiler
629 proper and can print pertinent state (e.g. params and plugins).
630
631 If SHOW_GLOBAL_STATE is false (for use by libgccjit), we are outside the
632 compiler, and we don't hold the mutex on the compiler's global state:
633 we can't print params and plugins, since they might not be initialized,
634 or might be being manipulated by a compile running in another
635 thread. */
636
637void
638print_version (FILE *file, const char *indent, bool show_global_state)
639{
640 static const char fmt1[] =
641#ifdef __GNUC__
642 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
643#else
644 N_("%s%s%s %sversion %s (%s) compiled by CC, ")
645#endif
646 ;
647 static const char fmt2[] =
648 N_("GMP version %s, MPFR version %s, MPC version %s, isl version %s\n");
649 static const char fmt3[] =
650 N_("%s%swarning: %s header version %s differs from library version %s.\n");
651 static const char fmt4[] =
652 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
653#ifndef __VERSION__
654#define __VERSION__ "[?]"
655#endif
656 fprintf (file,
657 file == stderr ? _(fmt1) : fmt1,
658 indent, *indent != 0 ? " " : "",
659 lang_hooks.name, pkgversion_string, version_string, TARGET_NAME,
660 indent, __VERSION__);
661
662 /* We need to stringify the GMP macro values. Ugh, gmp_version has
663 two string formats, "i.j.k" and "i.j" when k is zero. As of
664 gmp-4.3.0, GMP always uses the 3 number format. */
665#define GCC_GMP_STRINGIFY_VERSION3(X) #X
666#define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X)
667#define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
668#define GCC_GMP_VERSION \
669 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
670#if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
671#define GCC_GMP_STRINGIFY_VERSION \
672 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
673 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR)
674#else
675#define GCC_GMP_STRINGIFY_VERSION \
676 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
677 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \
678 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL)
679#endif
680 fprintf (file,
681 file == stderr ? _(fmt2) : fmt2,
682 GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING,
683#ifndef HAVE_isl
684 "none"
685#elif HAVE_ISL_OPTIONS_SET_SCHEDULE_SERIALIZE_SCCS
686 "0.15"
687#else
688 "0.14 or 0.13"
689#endif
690 );
691 if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
692 fprintf (file,
693 file == stderr ? _(fmt3) : fmt3,
694 indent, *indent != 0 ? " " : "",
695 "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
696 if (strcmp (MPFR_VERSION_STRING, mpfr_get_version ()))
697 fprintf (file,
698 file == stderr ? _(fmt3) : fmt3,
699 indent, *indent != 0 ? " " : "",
700 "MPFR", MPFR_VERSION_STRING, mpfr_get_version ());
701 if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
702 fprintf (file,
703 file == stderr ? _(fmt3) : fmt3,
704 indent, *indent != 0 ? " " : "",
705 "MPC", MPC_VERSION_STRING, mpc_get_version ());
706
707 if (show_global_state)
708 {
709 fprintf (file,
710 file == stderr ? _(fmt4) : fmt4,
711 indent, *indent != 0 ? " " : "",
712 PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
713
714 print_plugins_versions (file, indent);
715 }
716}
717
718static int
719print_to_asm_out_file (print_switch_type type, const char * text)
720{
721 bool prepend_sep = true;
722
723 switch (type)
724 {
725 case SWITCH_TYPE_LINE_END:
726 putc ('\n', asm_out_file);
727 return 1;
728
729 case SWITCH_TYPE_LINE_START:
730 fputs (ASM_COMMENT_START, asm_out_file);
731 return strlen (ASM_COMMENT_START);
732
733 case SWITCH_TYPE_DESCRIPTIVE:
734 if (ASM_COMMENT_START[0] == 0)
735 prepend_sep = false;
736 /* FALLTHRU */
737 case SWITCH_TYPE_PASSED:
738 case SWITCH_TYPE_ENABLED:
739 if (prepend_sep)
740 fputc (' ', asm_out_file);
741 fputs (text, asm_out_file);
742 /* No need to return the length here as
743 print_single_switch has already done it. */
744 return 0;
745
746 default:
747 return -1;
748 }
749}
750
751static int
752print_to_stderr (print_switch_type type, const char * text)
753{
754 switch (type)
755 {
756 case SWITCH_TYPE_LINE_END:
757 putc ('\n', stderr);
758 return 1;
759
760 case SWITCH_TYPE_LINE_START:
761 return 0;
762
763 case SWITCH_TYPE_PASSED:
764 case SWITCH_TYPE_ENABLED:
765 fputc (' ', stderr);
766 /* FALLTHRU */
767
768 case SWITCH_TYPE_DESCRIPTIVE:
769 fputs (text, stderr);
770 /* No need to return the length here as
771 print_single_switch has already done it. */
772 return 0;
773
774 default:
775 return -1;
776 }
777}
778
779/* Print an option value and return the adjusted position in the line.
780 ??? print_fn doesn't handle errors, eg disk full; presumably other
781 code will catch a disk full though. */
782
783static int
784print_single_switch (print_switch_fn_type print_fn,
785 int pos,
786 print_switch_type type,
787 const char * text)
788{
789 /* The ultrix fprintf returns 0 on success, so compute the result
790 we want here since we need it for the following test. The +1
791 is for the separator character that will probably be emitted. */
792 int len = strlen (text) + 1;
793
794 if (pos != 0
795 && pos + len > MAX_LINE)
796 {
797 print_fn (SWITCH_TYPE_LINE_END, NULL);
798 pos = 0;
799 }
800
801 if (pos == 0)
802 pos += print_fn (SWITCH_TYPE_LINE_START, NULL);
803
804 print_fn (type, text);
805 return pos + len;
806}
807
808/* Print active target switches using PRINT_FN.
809 POS is the current cursor position and MAX is the size of a "line".
810 Each line begins with INDENT and ends with TERM.
811 Each switch is separated from the next by SEP. */
812
813static void
814print_switch_values (print_switch_fn_type print_fn)
815{
816 int pos = 0;
817 size_t j;
818
819 /* Fill in the -frandom-seed option, if the user didn't pass it, so
820 that it can be printed below. This helps reproducibility. */
821 if (!flag_random_seed)
822 init_random_seed ();
823
824 /* Print the options as passed. */
825 pos = print_single_switch (print_fn, pos,
826 SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
827
828 for (j = 1; j < save_decoded_options_count; j++)
829 {
830 switch (save_decoded_options[j].opt_index)
831 {
832 case OPT_o:
833 case OPT_d:
834 case OPT_dumpbase:
835 case OPT_dumpdir:
836 case OPT_auxbase:
837 case OPT_quiet:
838 case OPT_version:
839 /* Ignore these. */
840 continue;
841 }
842
843 pos = print_single_switch (print_fn, pos, SWITCH_TYPE_PASSED,
844 save_decoded_options[j].orig_option_with_args_text);
845 }
846
847 if (pos > 0)
848 print_fn (SWITCH_TYPE_LINE_END, NULL);
849
850 /* Print the -f and -m options that have been enabled.
851 We don't handle language specific options but printing argv
852 should suffice. */
853 pos = print_single_switch (print_fn, 0,
854 SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
855
856 for (j = 0; j < cl_options_count; j++)
857 if (cl_options[j].cl_report
858 && option_enabled (j, &global_options) > 0)
859 pos = print_single_switch (print_fn, pos,
860 SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
861
862 print_fn (SWITCH_TYPE_LINE_END, NULL);
863}
864
865/* Open assembly code output file. Do this even if -fsyntax-only is
866 on, because then the driver will have provided the name of a
867 temporary file or bit bucket for us. NAME is the file specified on
868 the command line, possibly NULL. */
869static void
870init_asm_output (const char *name)
871{
872 if (name == NULL && asm_file_name == 0)
873 asm_out_file = stdout;
874 else
875 {
876 if (asm_file_name == 0)
877 {
878 int len = strlen (dump_base_name);
879 char *dumpname = XNEWVEC (char, len + 6);
880
881 memcpy (dumpname, dump_base_name, len + 1);
882 strip_off_ending (dumpname, len);
883 strcat (dumpname, ".s");
884 asm_file_name = dumpname;
885 }
886 if (!strcmp (asm_file_name, "-"))
887 asm_out_file = stdout;
888 else if (!canonical_filename_eq (asm_file_name, name)
889 || !strcmp (asm_file_name, HOST_BIT_BUCKET))
890 asm_out_file = fopen (asm_file_name, "w");
891 else
892 /* Use UNKOWN_LOCATION to prevent gcc from printing the first
893 line in the current file. */
894 fatal_error (UNKNOWN_LOCATION,
895 "input file %qs is the same as output file",
896 asm_file_name);
897 if (asm_out_file == 0)
898 fatal_error (UNKNOWN_LOCATION,
899 "can%'t open %qs for writing: %m", asm_file_name);
900 }
901
902 if (!flag_syntax_only)
903 {
904 targetm.asm_out.file_start ();
905
906 if (flag_record_gcc_switches)
907 {
908 if (targetm.asm_out.record_gcc_switches)
909 {
910 /* Let the target know that we are about to start recording. */
911 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
912 NULL);
913 /* Now record the switches. */
914 print_switch_values (targetm.asm_out.record_gcc_switches);
915 /* Let the target know that the recording is over. */
916 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
917 NULL);
918 }
919 else
920 inform (UNKNOWN_LOCATION,
921 "-frecord-gcc-switches is not supported by "
922 "the current target");
923 }
924
925 if (flag_verbose_asm)
926 {
927 /* Print the list of switches in effect
928 into the assembler file as comments. */
929 print_version (asm_out_file, ASM_COMMENT_START, true);
930 print_switch_values (print_to_asm_out_file);
931 putc ('\n', asm_out_file);
932 }
933 }
934}
935
936/* A helper function; used as the reallocator function for cpp's line
937 table. */
938static void *
939realloc_for_line_map (void *ptr, size_t len)
940{
941 return ggc_realloc (ptr, len);
942}
943
944/* A helper function: used as the allocator function for
945 identifier_to_locale. */
946static void *
947alloc_for_identifier_to_locale (size_t len)
948{
949 return ggc_alloc_atomic (len);
950}
951
952/* Output stack usage information. */
953void
954output_stack_usage (void)
955{
956 static bool warning_issued = false;
957 enum stack_usage_kind_type { STATIC = 0, DYNAMIC, DYNAMIC_BOUNDED };
958 const char *stack_usage_kind_str[] = {
959 "static",
960 "dynamic",
961 "dynamic,bounded"
962 };
963 HOST_WIDE_INT stack_usage = current_function_static_stack_size;
964 enum stack_usage_kind_type stack_usage_kind;
965
966 if (stack_usage < 0)
967 {
968 if (!warning_issued)
969 {
970 warning (0, "stack usage computation not supported for this target");
971 warning_issued = true;
972 }
973 return;
974 }
975
976 stack_usage_kind = STATIC;
977
978 /* Add the maximum amount of space pushed onto the stack. */
979 if (current_function_pushed_stack_size > 0)
980 {
981 stack_usage += current_function_pushed_stack_size;
982 stack_usage_kind = DYNAMIC_BOUNDED;
983 }
984
985 /* Now on to the tricky part: dynamic stack allocation. */
986 if (current_function_allocates_dynamic_stack_space)
987 {
988 if (current_function_has_unbounded_dynamic_stack_size)
989 stack_usage_kind = DYNAMIC;
990 else
991 stack_usage_kind = DYNAMIC_BOUNDED;
992
993 /* Add the size even in the unbounded case, this can't hurt. */
994 stack_usage += current_function_dynamic_stack_size;
995 }
996
997 if (flag_stack_usage)
998 {
999 expanded_location loc
1000 = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
1001 /* We don't want to print the full qualified name because it can be long,
1002 so we strip the scope prefix, but we may need to deal with the suffix
1003 created by the compiler. */
1004 const char *suffix
1005 = strchr (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)), '.');
1006 const char *name
1007 = lang_hooks.decl_printable_name (current_function_decl, 2);
1008 if (suffix)
1009 {
1010 const char *dot = strchr (name, '.');
1011 while (dot && strcasecmp (dot, suffix) != 0)
1012 {
1013 name = dot + 1;
1014 dot = strchr (name, '.');
1015 }
1016 }
1017 else
1018 {
1019 const char *dot = strrchr (name, '.');
1020 if (dot)
1021 name = dot + 1;
1022 }
1023
1024 fprintf (stack_usage_file,
1025 "%s:%d:%d:%s\t" HOST_WIDE_INT_PRINT_DEC"\t%s\n",
1026 lbasename (loc.file),
1027 loc.line,
1028 loc.column,
1029 name,
1030 stack_usage,
1031 stack_usage_kind_str[stack_usage_kind]);
1032 }
1033
1034 if (warn_stack_usage >= 0)
1035 {
1036 const location_t loc = DECL_SOURCE_LOCATION (current_function_decl);
1037
1038 if (stack_usage_kind == DYNAMIC)
1039 warning_at (loc, OPT_Wstack_usage_, "stack usage might be unbounded");
1040 else if (stack_usage > warn_stack_usage)
1041 {
1042 if (stack_usage_kind == DYNAMIC_BOUNDED)
1043 warning_at (loc,
1044 OPT_Wstack_usage_, "stack usage might be %wd bytes",
1045 stack_usage);
1046 else
1047 warning_at (loc, OPT_Wstack_usage_, "stack usage is %wd bytes",
1048 stack_usage);
1049 }
1050 }
1051}
1052
1053/* Open an auxiliary output file. */
1054static FILE *
1055open_auxiliary_file (const char *ext)
1056{
1057 char *filename;
1058 FILE *file;
1059
1060 filename = concat (aux_base_name, ".", ext, NULL);
1061 file = fopen (filename, "w");
1062 if (!file)
1063 fatal_error (input_location, "can%'t open %s for writing: %m", filename);
1064 free (filename);
1065 return file;
1066}
1067
1068/* Initialization of the front end environment, before command line
1069 options are parsed. Signal handlers, internationalization etc.
1070 ARGV0 is main's argv[0]. */
1071static void
1072general_init (const char *argv0, bool init_signals)
1073{
1074 const char *p;
1075
1076 p = argv0 + strlen (argv0);
1077 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1078 --p;
1079 progname = p;
1080
1081 xmalloc_set_program_name (progname);
1082
1083 hex_init ();
1084
1085 /* Unlock the stdio streams. */
1086 unlock_std_streams ();
1087
1088 gcc_init_libintl ();
1089
1090 identifier_to_locale_alloc = alloc_for_identifier_to_locale;
1091 identifier_to_locale_free = ggc_free;
1092
1093 /* Initialize the diagnostics reporting machinery, so option parsing
1094 can give warnings and errors. */
1095 diagnostic_initialize (global_dc, N_OPTS);
1096 /* Set a default printer. Language specific initializations will
1097 override it later. */
1098 tree_diagnostics_defaults (global_dc);
1099
1100 global_dc->show_caret
1101 = global_options_init.x_flag_diagnostics_show_caret;
1102 global_dc->show_option_requested
1103 = global_options_init.x_flag_diagnostics_show_option;
1104 global_dc->show_column
1105 = global_options_init.x_flag_show_column;
1106 global_dc->internal_error = plugins_internal_error_function;
1107 global_dc->option_enabled = option_enabled;
1108 global_dc->option_state = &global_options;
1109 global_dc->option_name = option_name;
1110
1111 if (init_signals)
1112 {
1113 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1114#ifdef SIGSEGV
1115 signal (SIGSEGV, crash_signal);
1116#endif
1117#ifdef SIGILL
1118 signal (SIGILL, crash_signal);
1119#endif
1120#ifdef SIGBUS
1121 signal (SIGBUS, crash_signal);
1122#endif
1123#ifdef SIGABRT
1124 signal (SIGABRT, crash_signal);
1125#endif
1126#if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1127 signal (SIGIOT, crash_signal);
1128#endif
1129#ifdef SIGFPE
1130 signal (SIGFPE, crash_signal);
1131#endif
1132
1133 /* Other host-specific signal setup. */
1134 (*host_hooks.extra_signals)();
1135 }
1136
1137 /* Initialize the garbage-collector, string pools and tree type hash
1138 table. */
1139 init_ggc ();
1140 init_stringpool ();
1141 input_location = UNKNOWN_LOCATION;
1142 line_table = ggc_alloc<line_maps> ();
1143 linemap_init (line_table, BUILTINS_LOCATION);
1144 line_table->reallocator = realloc_for_line_map;
1145 line_table->round_alloc_size = ggc_round_alloc_size;
1146 line_table->default_range_bits = 5;
1147 init_ttree ();
1148
1149 /* Initialize register usage now so switches may override. */
1150 init_reg_sets ();
1151
1152 /* Register the language-independent parameters. */
1153 global_init_params ();
1154
1155 /* This must be done after global_init_params but before argument
1156 processing. */
1157 init_ggc_heuristics ();
1158
1159 /* Create the singleton holder for global state.
1160 Doing so also creates the pass manager and with it the passes. */
1161 g = new gcc::context ();
1162 symtab = new (ggc_cleared_alloc <symbol_table> ()) symbol_table ();
1163
1164 statistics_early_init ();
1165 finish_params ();
1166}
1167
1168/* Return true if the current target supports -fsection-anchors. */
1169
1170static bool
1171target_supports_section_anchors_p (void)
1172{
1173 if (targetm.min_anchor_offset == 0 && targetm.max_anchor_offset == 0)
1174 return false;
1175
1176 if (targetm.asm_out.output_anchor == NULL)
1177 return false;
1178
1179 return true;
1180}
1181
1182/* Default the align_* variables to 1 if they're still unset, and
1183 set up the align_*_log variables. */
1184static void
1185init_alignments (void)
1186{
1187 if (align_loops <= 0)
1188 align_loops = 1;
1189 if (align_loops_max_skip > align_loops)
1190 align_loops_max_skip = align_loops - 1;
1191 align_loops_log = floor_log2 (align_loops * 2 - 1);
1192 if (align_jumps <= 0)
1193 align_jumps = 1;
1194 if (align_jumps_max_skip > align_jumps)
1195 align_jumps_max_skip = align_jumps - 1;
1196 align_jumps_log = floor_log2 (align_jumps * 2 - 1);
1197 if (align_labels <= 0)
1198 align_labels = 1;
1199 align_labels_log = floor_log2 (align_labels * 2 - 1);
1200 if (align_labels_max_skip > align_labels)
1201 align_labels_max_skip = align_labels - 1;
1202 if (align_functions <= 0)
1203 align_functions = 1;
1204 align_functions_log = floor_log2 (align_functions * 2 - 1);
1205}
1206
1207/* Process the options that have been parsed. */
1208static void
1209process_options (void)
1210{
1211 /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1212 This can happen with incorrect pre-processed input. */
1213 debug_hooks = &do_nothing_debug_hooks;
1214
1215 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
1216
1217 /* Allow the front end to perform consistency checks and do further
1218 initialization based on the command line options. This hook also
1219 sets the original filename if appropriate (e.g. foo.i -> foo.c)
1220 so we can correctly initialize debug output. */
1221 no_backend = lang_hooks.post_options (&main_input_filename);
1222
1223 /* Some machines may reject certain combinations of options. */
1224 location_t saved_location = input_location;
1225 input_location = UNKNOWN_LOCATION;
1226 targetm.target_option.override ();
1227 input_location = saved_location;
1228
1229 if (flag_diagnostics_generate_patch)
1230 global_dc->edit_context_ptr = new edit_context ();
1231
1232 /* Avoid any informative notes in the second run of -fcompare-debug. */
1233 if (flag_compare_debug)
1234 diagnostic_inhibit_notes (global_dc);
1235
1236 if (flag_section_anchors && !target_supports_section_anchors_p ())
1237 {
1238 warning_at (UNKNOWN_LOCATION, OPT_fsection_anchors,
1239 "this target does not support %qs",
1240 "-fsection-anchors");
1241 flag_section_anchors = 0;
1242 }
1243
1244 if (flag_short_enums == 2)
1245 flag_short_enums = targetm.default_short_enums ();
1246
1247 /* Set aux_base_name if not already set. */
1248 if (aux_base_name)
1249 ;
1250 else if (main_input_filename)
1251 {
1252 char *name = xstrdup (lbasename (main_input_filename));
1253
1254 strip_off_ending (name, strlen (name));
1255 aux_base_name = name;
1256 }
1257 else
1258 aux_base_name = "gccaux";
1259
1260#ifndef HAVE_isl
1261 if (flag_graphite
1262 || flag_loop_nest_optimize
1263 || flag_graphite_identity
1264 || flag_loop_parallelize_all)
1265 sorry ("Graphite loop optimizations cannot be used (isl is not available)"
1266 "(-fgraphite, -fgraphite-identity, -floop-block, "
1267 "-floop-interchange, -floop-strip-mine, -floop-parallelize-all, "
1268 "-floop-unroll-and-jam, and -ftree-loop-linear)");
1269#endif
1270
1271 if (flag_check_pointer_bounds)
1272 {
1273 if (targetm.chkp_bound_mode () == VOIDmode)
1274 {
1275 error_at (UNKNOWN_LOCATION,
1276 "-fcheck-pointer-bounds is not supported for this target");
1277 flag_check_pointer_bounds = 0;
1278 }
1279
1280 if (flag_sanitize & SANITIZE_ADDRESS)
1281 {
1282 error_at (UNKNOWN_LOCATION,
1283 "-fcheck-pointer-bounds is not supported with "
1284 "Address Sanitizer");
1285 flag_check_pointer_bounds = 0;
1286 }
1287
1288 if (flag_sanitize & SANITIZE_BOUNDS)
1289 {
1290 error_at (UNKNOWN_LOCATION,
1291 "-fcheck-pointer-bounds is not supported with "
1292 "-fsanitize=bounds");
1293 flag_check_pointer_bounds = 0;
1294 }
1295
1296 }
1297
1298 /* One region RA really helps to decrease the code size. */
1299 if (flag_ira_region == IRA_REGION_AUTODETECT)
1300 flag_ira_region
1301 = optimize_size || !optimize ? IRA_REGION_ONE : IRA_REGION_MIXED;
1302
1303 if (!abi_version_at_least (2))
1304 {
1305 /* -fabi-version=1 support was removed after GCC 4.9. */
1306 error_at (UNKNOWN_LOCATION,
1307 "%<-fabi-version=1%> is no longer supported");
1308 flag_abi_version = 2;
1309 }
1310
1311 /* Unrolling all loops implies that standard loop unrolling must also
1312 be done. */
1313 if (flag_unroll_all_loops)
1314 flag_unroll_loops = 1;
1315
1316 /* web and rename-registers help when run after loop unrolling. */
1317 if (flag_web == AUTODETECT_VALUE)
1318 flag_web = flag_unroll_loops;
1319
1320 if (flag_rename_registers == AUTODETECT_VALUE)
1321 flag_rename_registers = flag_unroll_loops;
1322
1323 if (flag_non_call_exceptions)
1324 flag_asynchronous_unwind_tables = 1;
1325 if (flag_asynchronous_unwind_tables)
1326 flag_unwind_tables = 1;
1327
1328 if (flag_value_profile_transformations)
1329 flag_profile_values = 1;
1330
1331 /* Warn about options that are not supported on this machine. */
1332#ifndef INSN_SCHEDULING
1333 if (flag_schedule_insns || flag_schedule_insns_after_reload)
1334 warning_at (UNKNOWN_LOCATION, 0,
1335 "instruction scheduling not supported on this target machine");
1336#endif
1337 if (!DELAY_SLOTS && flag_delayed_branch)
1338 warning_at (UNKNOWN_LOCATION, 0,
1339 "this target machine does not have delayed branches");
1340
1341 user_label_prefix = USER_LABEL_PREFIX;
1342 if (flag_leading_underscore != -1)
1343 {
1344 /* If the default prefix is more complicated than "" or "_",
1345 issue a warning and ignore this option. */
1346 if (user_label_prefix[0] == 0 ||
1347 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1348 {
1349 user_label_prefix = flag_leading_underscore ? "_" : "";
1350 }
1351 else
1352 warning_at (UNKNOWN_LOCATION, 0,
1353 "-f%sleading-underscore not supported on this "
1354 "target machine", flag_leading_underscore ? "" : "no-");
1355 }
1356
1357 /* If we are in verbose mode, write out the version and maybe all the
1358 option flags in use. */
1359 if (version_flag)
1360 {
1361 print_version (stderr, "", true);
1362 if (! quiet_flag)
1363 print_switch_values (print_to_stderr);
1364 }
1365
1366 if (flag_syntax_only)
1367 {
1368 write_symbols = NO_DEBUG;
1369 profile_flag = 0;
1370 }
1371
1372 if (flag_gtoggle)
1373 {
1374 if (debug_info_level == DINFO_LEVEL_NONE)
1375 {
1376 debug_info_level = DINFO_LEVEL_NORMAL;
1377
1378 if (write_symbols == NO_DEBUG)
1379 write_symbols = PREFERRED_DEBUGGING_TYPE;
1380 }
1381 else
1382 debug_info_level = DINFO_LEVEL_NONE;
1383 }
1384
1385 if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1386 {
1387 FILE *final_output = fopen (flag_dump_final_insns, "w");
1388 if (!final_output)
1389 {
1390 error_at (UNKNOWN_LOCATION,
1391 "could not open final insn dump file %qs: %m",
1392 flag_dump_final_insns);
1393 flag_dump_final_insns = NULL;
1394 }
1395 else if (fclose (final_output))
1396 {
1397 error_at (UNKNOWN_LOCATION,
1398 "could not close zeroed insn dump file %qs: %m",
1399 flag_dump_final_insns);
1400 flag_dump_final_insns = NULL;
1401 }
1402 }
1403
1404 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1405 level is 0. */
1406 if (debug_info_level == DINFO_LEVEL_NONE)
1407 write_symbols = NO_DEBUG;
1408
1409 if (write_symbols == NO_DEBUG)
1410 ;
1411#if defined(DBX_DEBUGGING_INFO)
1412 else if (write_symbols == DBX_DEBUG)
1413 debug_hooks = &dbx_debug_hooks;
1414#endif
1415#if defined(XCOFF_DEBUGGING_INFO)
1416 else if (write_symbols == XCOFF_DEBUG)
1417 debug_hooks = &xcoff_debug_hooks;
1418#endif
1419 else if (SDB_DEBUGGING_INFO && write_symbols == SDB_DEBUG)
1420 debug_hooks = &sdb_debug_hooks;
1421#ifdef DWARF2_DEBUGGING_INFO
1422 else if (write_symbols == DWARF2_DEBUG)
1423 debug_hooks = &dwarf2_debug_hooks;
1424#endif
1425#ifdef VMS_DEBUGGING_INFO
1426 else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1427 debug_hooks = &vmsdbg_debug_hooks;
1428#endif
1429#ifdef DWARF2_LINENO_DEBUGGING_INFO
1430 else if (write_symbols == DWARF2_DEBUG)
1431 debug_hooks = &dwarf2_lineno_debug_hooks;
1432#endif
1433 else
1434 error_at (UNKNOWN_LOCATION,
1435 "target system does not support the %qs debug format",
1436 debug_type_names[write_symbols]);
1437
1438 /* We know which debug output will be used so we can set flag_var_tracking
1439 and flag_var_tracking_uninit if the user has not specified them. */
1440 if (debug_info_level < DINFO_LEVEL_NORMAL
1441 || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
1442 {
1443 if (flag_var_tracking == 1
1444 || flag_var_tracking_uninit == 1)
1445 {
1446 if (debug_info_level < DINFO_LEVEL_NORMAL)
1447 warning_at (UNKNOWN_LOCATION, 0,
1448 "variable tracking requested, but useless unless "
1449 "producing debug info");
1450 else
1451 warning_at (UNKNOWN_LOCATION, 0,
1452 "variable tracking requested, but not supported "
1453 "by this debug format");
1454 }
1455 flag_var_tracking = 0;
1456 flag_var_tracking_uninit = 0;
1457 }
1458
1459 /* The debug hooks are used to implement -fdump-go-spec because it
1460 gives a simple and stable API for all the information we need to
1461 dump. */
1462 if (flag_dump_go_spec != NULL)
1463 debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks);
1464
1465 /* If the user specifically requested variable tracking with tagging
1466 uninitialized variables, we need to turn on variable tracking.
1467 (We already determined above that variable tracking is feasible.) */
1468 if (flag_var_tracking_uninit == 1)
1469 flag_var_tracking = 1;
1470
1471 if (flag_var_tracking == AUTODETECT_VALUE)
1472 flag_var_tracking = optimize >= 1;
1473
1474 if (flag_var_tracking_uninit == AUTODETECT_VALUE)
1475 flag_var_tracking_uninit = flag_var_tracking;
1476
1477 if (flag_var_tracking_assignments == AUTODETECT_VALUE)
1478 flag_var_tracking_assignments = flag_var_tracking
1479 && !(flag_selective_scheduling || flag_selective_scheduling2);
1480
1481 if (flag_var_tracking_assignments_toggle)
1482 flag_var_tracking_assignments = !flag_var_tracking_assignments;
1483
1484 if (flag_var_tracking_assignments && !flag_var_tracking)
1485 flag_var_tracking = flag_var_tracking_assignments = -1;
1486
1487 if (flag_var_tracking_assignments
1488 && (flag_selective_scheduling || flag_selective_scheduling2))
1489 warning_at (UNKNOWN_LOCATION, 0,
1490 "var-tracking-assignments changes selective scheduling");
1491
1492 if (flag_tree_cselim == AUTODETECT_VALUE)
1493 {
1494 if (HAVE_conditional_move)
1495 flag_tree_cselim = 1;
1496 else
1497 flag_tree_cselim = 0;
1498 }
1499
1500 /* If auxiliary info generation is desired, open the output file.
1501 This goes in the same directory as the source file--unlike
1502 all the other output files. */
1503 if (flag_gen_aux_info)
1504 {
1505 aux_info_file = fopen (aux_info_file_name, "w");
1506 if (aux_info_file == 0)
1507 fatal_error (UNKNOWN_LOCATION,
1508 "can%'t open %s: %m", aux_info_file_name);
1509 }
1510
1511 if (!targetm_common.have_named_sections)
1512 {
1513 if (flag_function_sections)
1514 {
1515 warning_at (UNKNOWN_LOCATION, 0,
1516 "-ffunction-sections not supported for this target");
1517 flag_function_sections = 0;
1518 }
1519 if (flag_data_sections)
1520 {
1521 warning_at (UNKNOWN_LOCATION, 0,
1522 "-fdata-sections not supported for this target");
1523 flag_data_sections = 0;
1524 }
1525 }
1526
1527 if (flag_prefetch_loop_arrays > 0 && !targetm.code_for_prefetch)
1528 {
1529 warning_at (UNKNOWN_LOCATION, 0,
1530 "-fprefetch-loop-arrays not supported for this target");
1531 flag_prefetch_loop_arrays = 0;
1532 }
1533 else if (flag_prefetch_loop_arrays > 0 && !targetm.have_prefetch ())
1534 {
1535 warning_at (UNKNOWN_LOCATION, 0,
1536 "-fprefetch-loop-arrays not supported for this target "
1537 "(try -march switches)");
1538 flag_prefetch_loop_arrays = 0;
1539 }
1540
1541 /* This combination of options isn't handled for i386 targets and doesn't
1542 make much sense anyway, so don't allow it. */
1543 if (flag_prefetch_loop_arrays > 0 && optimize_size)
1544 {
1545 warning_at (UNKNOWN_LOCATION, 0,
1546 "-fprefetch-loop-arrays is not supported with -Os");
1547 flag_prefetch_loop_arrays = 0;
1548 }
1549
1550 /* The presence of IEEE signaling NaNs, implies all math can trap. */
1551 if (flag_signaling_nans)
1552 flag_trapping_math = 1;
1553
1554 /* We cannot reassociate if we want traps or signed zeros. */
1555 if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
1556 {
1557 warning_at (UNKNOWN_LOCATION, 0,
1558 "-fassociative-math disabled; other options take "
1559 "precedence");
1560 flag_associative_math = 0;
1561 }
1562
1563 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1564 if (flag_cx_limited_range)
1565 flag_complex_method = 0;
1566
1567 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1568 if (flag_cx_fortran_rules)
1569 flag_complex_method = 1;
1570
1571 /* Targets must be able to place spill slots at lower addresses. If the
1572 target already uses a soft frame pointer, the transition is trivial. */
1573 if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
1574 {
1575 warning_at (UNKNOWN_LOCATION, 0,
1576 "-fstack-protector not supported for this target");
1577 flag_stack_protect = 0;
1578 }
1579 if (!flag_stack_protect)
1580 warn_stack_protect = 0;
1581
1582 /* Address Sanitizer needs porting to each target architecture. */
1583
1584 if ((flag_sanitize & SANITIZE_ADDRESS)
1585 && !FRAME_GROWS_DOWNWARD)
1586 {
1587 warning_at (UNKNOWN_LOCATION, 0,
1588 "-fsanitize=address and -fsanitize=kernel-address "
1589 "are not supported for this target");
1590 flag_sanitize &= ~SANITIZE_ADDRESS;
1591 }
1592
1593 if ((flag_sanitize & SANITIZE_USER_ADDRESS)
1594 && targetm.asan_shadow_offset == NULL)
1595 {
1596 warning_at (UNKNOWN_LOCATION, 0,
1597 "-fsanitize=address not supported for this target");
1598 flag_sanitize &= ~SANITIZE_ADDRESS;
1599 }
1600
1601 /* Do not use IPA optimizations for register allocation if profiler is active
1602 or port does not emit prologue and epilogue as RTL. */
1603 if (profile_flag || !targetm.have_prologue () || !targetm.have_epilogue ())
1604 flag_ipa_ra = 0;
1605
1606 /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error
1607 have not been set. */
1608 if (!global_options_set.x_warnings_are_errors
1609 && warn_coverage_mismatch
1610 && (global_dc->classify_diagnostic[OPT_Wcoverage_mismatch] ==
1611 DK_UNSPECIFIED))
1612 diagnostic_classify_diagnostic (global_dc, OPT_Wcoverage_mismatch,
1613 DK_ERROR, UNKNOWN_LOCATION);
1614
1615 /* Save the current optimization options. */
1616 optimization_default_node = build_optimization_node (&global_options);
1617 optimization_current_node = optimization_default_node;
1618
1619 /* Please don't change global_options after this point, those changes won't
1620 be reflected in optimization_{default,current}_node. */
1621}
1622
1623/* This function can be called multiple times to reinitialize the compiler
1624 back end when register classes or instruction sets have changed,
1625 before each function. */
1626static void
1627backend_init_target (void)
1628{
1629 /* Initialize alignment variables. */
1630 init_alignments ();
1631
1632 /* This depends on stack_pointer_rtx. */
1633 init_fake_stack_mems ();
1634
1635 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1636 mode-dependent. */
1637 init_alias_target ();
1638
1639 /* Depends on HARD_FRAME_POINTER_REGNUM. */
1640 if (!ira_use_lra_p)
1641 init_reload ();
1642
1643 /* Depends on the enabled attribute. */
1644 recog_init ();
1645
1646 /* The following initialization functions need to generate rtl, so
1647 provide a dummy function context for them. */
1648 init_dummy_function_start ();
1649
1650 /* rtx_cost is mode-dependent, so cached values need to be recomputed
1651 on a mode change. */
1652 init_expmed ();
1653 init_lower_subreg ();
1654 init_set_costs ();
1655
1656 init_expr_target ();
1657 ira_init ();
1658
1659 /* We may need to recompute regno_save_code[] and regno_restore_code[]
1660 after a mode change as well. */
1661 caller_save_initialized_p = false;
1662
1663 expand_dummy_function_end ();
1664}
1665
1666/* Initialize the compiler back end. This function is called only once,
1667 when starting the compiler. */
1668static void
1669backend_init (void)
1670{
1671 init_emit_once ();
1672
1673 init_rtlanal ();
1674 init_inline_once ();
1675 init_varasm_once ();
1676 save_register_info ();
1677
1678 /* Middle end needs this initialization for default mem attributes
1679 used by early calls to make_decl_rtl. */
1680 init_emit_regs ();
1681
1682 /* Middle end needs this initialization for mode tables used to assign
1683 modes to vector variables. */
1684 init_regs ();
1685}
1686
1687/* Initialize excess precision settings. */
1688static void
1689init_excess_precision (void)
1690{
1691 /* Adjust excess precision handling based on the target options. If
1692 the front end cannot handle it, flag_excess_precision_cmdline
1693 will already have been set accordingly in the post_options
1694 hook. */
1695 gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
1696 flag_excess_precision = flag_excess_precision_cmdline;
1697 if (flag_unsafe_math_optimizations)
1698 flag_excess_precision = EXCESS_PRECISION_FAST;
1699 if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
1700 {
1701 int flt_eval_method = TARGET_FLT_EVAL_METHOD;
1702 switch (flt_eval_method)
1703 {
1704 case -1:
1705 case 0:
1706 /* Either the target acts unpredictably (-1) or has all the
1707 operations required not to have excess precision (0). */
1708 flag_excess_precision = EXCESS_PRECISION_FAST;
1709 break;
1710 case 1:
1711 case 2:
1712 /* In these cases, predictable excess precision makes
1713 sense. */
1714 break;
1715 default:
1716 /* Any other implementation-defined FLT_EVAL_METHOD values
1717 require the compiler to handle the associated excess
1718 precision rules in excess_precision_type. */
1719 gcc_unreachable ();
1720 }
1721 }
1722}
1723
1724/* Initialize things that are both lang-dependent and target-dependent.
1725 This function can be called more than once if target parameters change. */
1726static void
1727lang_dependent_init_target (void)
1728{
1729 /* This determines excess precision settings. */
1730 init_excess_precision ();
1731
1732 /* This creates various _DECL nodes, so needs to be called after the
1733 front end is initialized. It also depends on the HAVE_xxx macros
1734 generated from the target machine description. */
1735 init_optabs ();
1736
1737 gcc_assert (!this_target_rtl->target_specific_initialized);
1738}
1739
1740/* Perform initializations that are lang-dependent or target-dependent.
1741 but matters only for late optimizations and RTL generation. */
1742
1743static int rtl_initialized;
1744
1745void
1746initialize_rtl (void)
1747{
1748 auto_timevar tv (g_timer, TV_INITIALIZE_RTL);
1749
1750 /* Initialization done just once per compilation, but delayed
1751 till code generation. */
1752 if (!rtl_initialized)
1753 ira_init_once ();
1754 rtl_initialized = true;
1755
1756 /* Target specific RTL backend initialization. */
1757 if (!this_target_rtl->target_specific_initialized)
1758 {
1759 backend_init_target ();
1760 this_target_rtl->target_specific_initialized = true;
1761 }
1762}
1763
1764/* Language-dependent initialization. Returns nonzero on success. */
1765static int
1766lang_dependent_init (const char *name)
1767{
1768 location_t save_loc = input_location;
1769 if (dump_base_name == 0)
1770 dump_base_name = name && name[0] ? name : "gccdump";
1771
1772 /* Other front-end initialization. */
1773 input_location = BUILTINS_LOCATION;
1774 if (lang_hooks.init () == 0)
1775 return 0;
1776 input_location = save_loc;
1777
1778 if (!flag_wpa)
1779 {
1780 init_asm_output (name);
1781
1782 /* If stack usage information is desired, open the output file. */
1783 if (flag_stack_usage)
1784 stack_usage_file = open_auxiliary_file ("su");
1785 }
1786
1787 /* This creates various _DECL nodes, so needs to be called after the
1788 front end is initialized. */
1789 init_eh ();
1790
1791 /* Do the target-specific parts of the initialization. */
1792 lang_dependent_init_target ();
1793
1794 if (!flag_wpa)
1795 {
1796 /* If dbx symbol table desired, initialize writing it and output the
1797 predefined types. */
1798 timevar_push (TV_SYMOUT);
1799
1800 /* Now we have the correct original filename, we can initialize
1801 debug output. */
1802 (*debug_hooks->init) (name);
1803
1804 timevar_pop (TV_SYMOUT);
1805 }
1806
1807 return 1;
1808}
1809
1810
1811/* Reinitialize everything when target parameters, such as register usage,
1812 have changed. */
1813void
1814target_reinit (void)
1815{
1816 struct rtl_data saved_x_rtl;
1817 rtx *saved_regno_reg_rtx;
1818 tree saved_optimization_current_node;
1819 struct target_optabs *saved_this_fn_optabs;
1820
1821 /* Temporarily switch to the default optimization node, so that
1822 *this_target_optabs is set to the default, not reflecting
1823 whatever a previous function used for the optimize
1824 attribute. */
1825 saved_optimization_current_node = optimization_current_node;
1826 saved_this_fn_optabs = this_fn_optabs;
1827 if (saved_optimization_current_node != optimization_default_node)
1828 {
1829 optimization_current_node = optimization_default_node;
1830 cl_optimization_restore
1831 (&global_options,
1832 TREE_OPTIMIZATION (optimization_default_node));
1833 }
1834 this_fn_optabs = this_target_optabs;
1835
1836 /* Save *crtl and regno_reg_rtx around the reinitialization
1837 to allow target_reinit being called even after prepare_function_start. */
1838 saved_regno_reg_rtx = regno_reg_rtx;
1839 if (saved_regno_reg_rtx)
1840 {
1841 saved_x_rtl = *crtl;
1842 memset (crtl, '\0', sizeof (*crtl));
1843 regno_reg_rtx = NULL;
1844 }
1845
1846 this_target_rtl->target_specific_initialized = false;
1847
1848 /* This initializes hard_frame_pointer, and calls init_reg_modes_target()
1849 to initialize reg_raw_mode[]. */
1850 init_emit_regs ();
1851
1852 /* This invokes target hooks to set fixed_reg[] etc, which is
1853 mode-dependent. */
1854 init_regs ();
1855
1856 /* Reinitialize lang-dependent parts. */
1857 lang_dependent_init_target ();
1858
1859 /* Restore the original optimization node. */
1860 if (saved_optimization_current_node != optimization_default_node)
1861 {
1862 optimization_current_node = saved_optimization_current_node;
1863 cl_optimization_restore (&global_options,
1864 TREE_OPTIMIZATION (optimization_current_node));
1865 }
1866 this_fn_optabs = saved_this_fn_optabs;
1867
1868 /* Restore regno_reg_rtx at the end, as free_after_compilation from
1869 expand_dummy_function_end clears it. */
1870 if (saved_regno_reg_rtx)
1871 {
1872 *crtl = saved_x_rtl;
1873 regno_reg_rtx = saved_regno_reg_rtx;
1874 saved_regno_reg_rtx = NULL;
1875 }
1876}
1877
1878void
1879dump_memory_report (bool final)
1880{
1881 dump_line_table_statistics ();
1882 ggc_print_statistics ();
1883 stringpool_statistics ();
1884 dump_tree_statistics ();
1885 dump_gimple_statistics ();
1886 dump_rtx_statistics ();
1887 dump_alloc_pool_statistics ();
1888 dump_bitmap_statistics ();
1889 dump_hash_table_loc_statistics ();
1890 dump_vec_loc_statistics ();
1891 dump_ggc_loc_statistics (final);
1892 dump_alias_stats (stderr);
1893 dump_pta_stats (stderr);
1894}
1895
1896/* Clean up: close opened files, etc. */
1897
1898static void
1899finalize (bool no_backend)
1900{
1901 /* Close the dump files. */
1902 if (flag_gen_aux_info)
1903 {
1904 fclose (aux_info_file);
1905 aux_info_file = NULL;
1906 if (seen_error ())
1907 unlink (aux_info_file_name);
1908 }
1909
1910 /* Close non-debugging input and output files. Take special care to note
1911 whether fclose returns an error, since the pages might still be on the
1912 buffer chain while the file is open. */
1913
1914 if (asm_out_file)
1915 {
1916 if (ferror (asm_out_file) != 0)
1917 fatal_error (input_location, "error writing to %s: %m", asm_file_name);
1918 if (fclose (asm_out_file) != 0)
1919 fatal_error (input_location, "error closing %s: %m", asm_file_name);
1920 asm_out_file = NULL;
1921 }
1922
1923 if (stack_usage_file)
1924 {
1925 fclose (stack_usage_file);
1926 stack_usage_file = NULL;
1927 }
1928
1929 if (!no_backend)
1930 {
1931 statistics_fini ();
1932
1933 g->get_passes ()->finish_optimization_passes ();
1934
1935 lra_finish_once ();
1936 }
1937
1938 if (mem_report)
1939 dump_memory_report (true);
1940
1941 if (profile_report)
1942 dump_profile_report ();
1943
1944 /* Language-specific end of compilation actions. */
1945 lang_hooks.finish ();
1946}
1947
1948static bool
1949standard_type_bitsize (int bitsize)
1950{
1951 /* As a special exception, we always want __int128 enabled if possible. */
1952 if (bitsize == 128)
1953 return false;
1954 if (bitsize == CHAR_TYPE_SIZE
1955 || bitsize == SHORT_TYPE_SIZE
1956 || bitsize == INT_TYPE_SIZE
1957 || bitsize == LONG_TYPE_SIZE
1958 || bitsize == LONG_LONG_TYPE_SIZE)
1959 return true;
1960 return false;
1961}
1962
1963/* Initialize the compiler, and compile the input file. */
1964static void
1965do_compile ()
1966{
1967 process_options ();
1968
1969 /* Don't do any more if an error has already occurred. */
1970 if (!seen_error ())
1971 {
1972 int i;
1973
1974 timevar_start (TV_PHASE_SETUP);
1975
1976 /* This must be run always, because it is needed to compute the FP
1977 predefined macros, such as __LDBL_MAX__, for targets using non
1978 default FP formats. */
1979 init_adjust_machine_modes ();
1980 init_derived_machine_modes ();
1981
1982 /* This must happen after the backend has a chance to process
1983 command line options, but before the parsers are
1984 initialized. */
1985 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1986 if (targetm.scalar_mode_supported_p (int_n_data[i].m)
1987 && ! standard_type_bitsize (int_n_data[i].bitsize))
1988 int_n_enabled_p[i] = true;
1989 else
1990 int_n_enabled_p[i] = false;
1991
1992 /* Set up the back-end if requested. */
1993 if (!no_backend)
1994 backend_init ();
1995
1996 /* Language-dependent initialization. Returns true on success. */
1997 if (lang_dependent_init (main_input_filename))
1998 {
1999 /* Initialize yet another pass. */
2000
2001 ggc_protect_identifiers = true;
2002
2003 symtab->initialize ();
2004 init_final (main_input_filename);
2005 coverage_init (aux_base_name);
2006 statistics_init ();
2007 invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
2008
2009 timevar_stop (TV_PHASE_SETUP);
2010
2011 compile_file ();
2012 }
2013 else
2014 {
2015 timevar_stop (TV_PHASE_SETUP);
2016 }
2017
2018 timevar_start (TV_PHASE_FINALIZE);
2019
2020 finalize (no_backend);
2021
2022 timevar_stop (TV_PHASE_FINALIZE);
2023 }
2024}
2025
2026toplev::toplev (timer *external_timer,
2027 bool init_signals)
2028 : m_use_TV_TOTAL (external_timer == NULL),
2029 m_init_signals (init_signals)
2030{
2031 if (external_timer)
2032 g_timer = external_timer;
2033}
2034
2035toplev::~toplev ()
2036{
2037 if (g_timer && m_use_TV_TOTAL)
2038 {
2039 g_timer->stop (TV_TOTAL);
2040 g_timer->print (stderr);
2041 delete g_timer;
2042 g_timer = NULL;
2043 }
2044}
2045
2046/* Potentially call timevar_init (which will create g_timevars if it
2047 doesn't already exist). */
2048
2049void
2050toplev::start_timevars ()
2051{
2052 if (time_report || !quiet_flag || flag_detailed_statistics)
2053 timevar_init ();
2054
2055 timevar_start (TV_TOTAL);
2056}
2057
2058/* Handle -fself-test. */
2059
2060void
2061toplev::run_self_tests ()
2062{
2063 if (no_backend)
2064 {
2065 error_at (UNKNOWN_LOCATION, "self-tests incompatible with -E");
2066 return;
2067 }
2068#if CHECKING_P
2069 /* Reset some state. */
2070 input_location = UNKNOWN_LOCATION;
2071 bitmap_obstack_initialize (NULL);
2072
2073 /* Run the tests; any failures will lead to an abort of the process.
2074 Use "make selftests-gdb" to run under the debugger. */
2075 ::selftest::run_tests ();
2076
2077 /* Cleanup. */
2078 bitmap_obstack_release (NULL);
2079#else
2080 inform (UNKNOWN_LOCATION, "self-tests are not enabled in this build");
2081#endif /* #if CHECKING_P */
2082}
2083
2084/* Entry point of cc1, cc1plus, jc1, f771, etc.
2085 Exit code is FATAL_EXIT_CODE if can't open files or if there were
2086 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
2087
2088 It is not safe to call this function more than once. */
2089
2090int
2091toplev::main (int argc, char **argv)
2092{
2093 /* Parsing and gimplification sometimes need quite large stack.
2094 Increase stack size limits if possible. */
2095 stack_limit_increase (64 * 1024 * 1024);
2096
2097 expandargv (&argc, &argv);
2098
2099 /* Initialization of GCC's environment, and diagnostics. */
2100 general_init (argv[0], m_init_signals);
2101
2102 /* One-off initialization of options that does not need to be
2103 repeated when options are added for particular functions. */
2104 init_options_once ();
2105 init_opts_obstack ();
2106
2107 /* Initialize global options structures; this must be repeated for
2108 each structure used for parsing options. */
2109 init_options_struct (&global_options, &global_options_set);
2110 lang_hooks.init_options_struct (&global_options);
2111
2112 /* Convert the options to an array. */
2113 decode_cmdline_options_to_array_default_mask (argc,
2114 CONST_CAST2 (const char **,
2115 char **, argv),
2116 &save_decoded_options,
2117 &save_decoded_options_count);
2118
2119 /* Perform language-specific options initialization. */
2120 lang_hooks.init_options (save_decoded_options_count, save_decoded_options);
2121
2122 /* Parse the options and do minimal processing; basically just
2123 enough to default flags appropriately. */
2124 decode_options (&global_options, &global_options_set,
2125 save_decoded_options, save_decoded_options_count,
2126 UNKNOWN_LOCATION, global_dc);
2127
2128 handle_common_deferred_options ();
2129
2130 init_local_tick ();
2131
2132 initialize_plugins ();
2133
2134 if (version_flag)
2135 print_version (stderr, "", true);
2136
2137 if (help_flag)
2138 print_plugins_help (stderr, "");
2139
2140 /* Exit early if we can (e.g. -help). */
2141 if (!exit_after_options)
2142 {
2143 if (m_use_TV_TOTAL)
2144 start_timevars ();
2145 do_compile ();
2146 }
2147
2148 if (warningcount || errorcount || werrorcount)
2149 print_ignored_options ();
2150
2151 if (flag_self_test)
2152 run_self_tests ();
2153
2154 /* Invoke registered plugin callbacks if any. Some plugins could
2155 emit some diagnostics here. */
2156 invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2157
2158 if (flag_diagnostics_generate_patch)
2159 {
2160 gcc_assert (global_dc->edit_context_ptr);
2161
2162 pretty_printer (pp);
2163 pp_show_color (&pp) = pp_show_color (global_dc->printer);
2164 global_dc->edit_context_ptr->print_diff (&pp, true);
2165 pp_flush (&pp);
2166 }
2167
2168 diagnostic_finish (global_dc);
2169
2170 finalize_plugins ();
2171 location_adhoc_data_fini (line_table);
2172
2173 after_memory_report = true;
2174
2175 if (seen_error () || werrorcount)
2176 return (FATAL_EXIT_CODE);
2177
2178 return (SUCCESS_EXIT_CODE);
2179}
2180
2181/* For those that want to, this function aims to clean up enough state that
2182 you can call toplev::main again. */
2183void
2184toplev::finalize (void)
2185{
2186 rtl_initialized = false;
2187 this_target_rtl->target_specific_initialized = false;
2188
2189 /* Needs to be called before cgraph_c_finalize since it uses symtab. */
2190 ipa_reference_c_finalize ();
2191
2192 cgraph_c_finalize ();
2193 cgraphunit_c_finalize ();
2194 dwarf2out_c_finalize ();
2195 gcse_c_finalize ();
2196 ipa_cp_c_finalize ();
2197 ira_costs_c_finalize ();
2198 params_c_finalize ();
2199
2200 finalize_options_struct (&global_options);
2201 finalize_options_struct (&global_options_set);
2202
2203 /* save_decoded_options uses opts_obstack, so these must
2204 be cleaned up together. */
2205 obstack_free (&opts_obstack, NULL);
2206 XDELETEVEC (save_decoded_options);
2207 save_decoded_options = NULL;
2208 save_decoded_options_count = 0;
2209
2210 /* Clean up the context (and pass_manager etc). */
2211 delete g;
2212 g = NULL;
2213
2214}
2215