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