1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This is the top level of cc1/c++.
21 It parses command args, opens files, invokes the various passes
22 in the proper order, and counts the time used by each.
23 Error messages and low-level interface to malloc also handled here. */
27 #include "coretypes.h"
32 #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */
37 #include "insn-attr.h"
38 #include "insn-config.h"
39 #include "insn-flags.h"
40 #include "hard-reg-set.h"
47 #include "basic-block.h"
52 #include "diagnostic.h"
53 #include "tree-diagnostic.h"
54 #include "tree-pretty-print.h"
58 #include "dwarf2asm.h"
61 #include "common/common-target.h"
62 #include "langhooks.h"
63 #include "cfgloop.h" /* for init_set_costs */
64 #include "hosthooks.h"
67 #include "opts-diagnostic.h"
69 #include "value-prof.h"
70 #include "alloc-pool.h"
71 #include "tree-mudflap.h"
75 #include "tree-ssa-alias.h"
77 #include "diagnostic-color.h"
80 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
84 #ifdef SDB_DEBUGGING_INFO
88 #ifdef XCOFF_DEBUGGING_INFO
89 #include "xcoffout.h" /* Needed for external data
90 declarations for e.g. AIX 4.x. */
93 static void general_init (const char *);
94 static void do_compile (void);
95 static void process_options (void);
96 static void backend_init (void);
97 static int lang_dependent_init (const char *);
98 static void init_asm_output (const char *);
99 static void finalize (bool);
101 static void crash_signal (int) ATTRIBUTE_NORETURN
;
102 static void compile_file (void);
104 /* True if we don't need a backend (e.g. preprocessing only). */
105 static bool no_backend
;
107 /* Length of line when printing switch values. */
110 /* Decoded options, and number of such options. */
111 struct cl_decoded_option
*save_decoded_options
;
112 unsigned int save_decoded_options_count
;
114 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
115 to optimize in process_options (). */
116 #define AUTODETECT_VALUE 2
118 /* Debug hooks - dependent upon command line options. */
120 const struct gcc_debug_hooks
*debug_hooks
;
122 /* The FUNCTION_DECL for the function currently being compiled,
123 or 0 if between functions. */
124 tree current_function_decl
;
126 /* Set to the FUNC_BEGIN label of the current function, or NULL
128 const char * current_function_func_begin_label
;
130 /* A random sequence of characters, unless overridden by user. */
131 static const char *flag_random_seed
;
133 /* A local time stamp derived from the time of compilation. It will be
134 zero if the system cannot provide a time. It will be -1u, if the
135 user has specified a particular random seed. */
138 /* Random number for this compilation */
139 HOST_WIDE_INT random_seed
;
143 /* When non-NULL, indicates that whenever space is allocated on the
144 stack, the resulting stack pointer must not pass this
145 address---that is, for stacks that grow downward, the stack pointer
146 must always be greater than or equal to this address; for stacks
147 that grow upward, the stack pointer must be less than this address.
148 At present, the rtx may be either a REG or a SYMBOL_REF, although
149 the support provided depends on the backend. */
152 /* True if the user has tagged the function with the 'section'
155 bool user_defined_section_attribute
= false;
157 struct target_flag_state default_target_flag_state
;
158 #if SWITCHABLE_TARGET
159 struct target_flag_state
*this_target_flag_state
= &default_target_flag_state
;
161 #define this_target_flag_state (&default_target_flag_state)
164 /* The user symbol prefix after having resolved same. */
165 const char *user_label_prefix
;
167 /* Output files for assembler code (real compiler output)
168 and debugging dumps. */
172 FILE *stack_usage_file
= NULL
;
174 /* The current working directory of a translation. It's generally the
175 directory from which compilation was initiated, but a preprocessed
176 file may specify the original directory in which it was
179 static const char *src_pwd
;
181 /* Initialize src_pwd with the given string, and return true. If it
182 was already initialized, return false. As a special case, it may
183 be called with a NULL argument to test whether src_pwd has NOT been
187 set_src_pwd (const char *pwd
)
191 if (strcmp (src_pwd
, pwd
) == 0)
197 src_pwd
= xstrdup (pwd
);
201 /* Return the directory from which the translation unit was initiated,
202 in case set_src_pwd() was not called before to assign it a
218 /* Called when the start of a function definition is parsed,
219 this function prints on stderr the name of the function. */
221 announce_function (tree decl
)
225 if (rtl_dump_and_exit
)
226 fprintf (stderr
, "%s ",
227 identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
))));
229 fprintf (stderr
, " %s",
230 identifier_to_locale (lang_hooks
.decl_printable_name (decl
, 2)));
232 pp_needs_newline (global_dc
->printer
) = true;
233 diagnostic_set_last_function (global_dc
, (diagnostic_info
*) NULL
);
237 /* Initialize local_tick with a random number or -1 if
238 flag_random_seed is set. */
241 init_local_tick (void)
243 if (!flag_random_seed
)
245 /* Try urandom first. Time of day is too likely to collide.
246 In case of any error we just use the local tick. */
248 int fd
= open ("/dev/urandom", O_RDONLY
);
251 read (fd
, &random_seed
, sizeof (random_seed
));
255 /* Now get the tick anyways */
256 #ifdef HAVE_GETTIMEOFDAY
260 gettimeofday (&tv
, NULL
);
261 local_tick
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
265 time_t now
= time (NULL
);
267 if (now
!= (time_t)-1)
268 local_tick
= (unsigned) now
;
276 /* Set up a default flag_random_seed and local_tick, unless the user
277 already specified one. Must be called after init_local_tick. */
280 init_random_seed (void)
282 if (flag_random_seed
)
286 /* When the driver passed in a hex number don't crc it again */
287 random_seed
= strtoul (flag_random_seed
, &endp
, 0);
288 if (!(endp
> flag_random_seed
&& *endp
== 0))
289 random_seed
= crc32_string (0, flag_random_seed
);
291 else if (!random_seed
)
292 random_seed
= local_tick
^ getpid (); /* Old racey fallback method */
295 /* Obtain the random_seed. Unless NOINIT, initialize it if
296 it's not provided in the command line. */
299 get_random_seed (bool noinit
)
301 if (!flag_random_seed
&& !noinit
)
306 /* Modify the random_seed string to VAL. Return its previous
310 set_random_seed (const char *val
)
312 const char *old
= flag_random_seed
;
313 flag_random_seed
= val
;
317 /* Handler for fatal signals, such as SIGSEGV. These are transformed
318 into ICE messages, which is much more user friendly. In case the
319 error printer crashes, reset the signal to prevent infinite recursion. */
322 crash_signal (int signo
)
324 signal (signo
, SIG_DFL
);
326 /* If we crashed while processing an ASM statement, then be a little more
327 graceful. It's most likely the user's fault. */
328 if (this_is_asm_operands
)
330 output_operand_lossage ("unrecoverable error");
331 exit (FATAL_EXIT_CODE
);
334 internal_error ("%s", strsignal (signo
));
337 /* A subroutine of wrapup_global_declarations. We've come to the end of
338 the compilation unit. All deferred variables should be undeferred,
339 and all incomplete decls should be finalized. */
342 wrapup_global_declaration_1 (tree decl
)
344 /* We're not deferring this any longer. Assignment is conditional to
345 avoid needlessly dirtying PCH pages. */
346 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_WITH_VIS
)
347 && DECL_DEFER_OUTPUT (decl
) != 0)
348 DECL_DEFER_OUTPUT (decl
) = 0;
350 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_SIZE (decl
) == 0)
351 lang_hooks
.finish_incomplete_decl (decl
);
354 /* A subroutine of wrapup_global_declarations. Decide whether or not DECL
355 needs to be output. Return true if it is output. */
358 wrapup_global_declaration_2 (tree decl
)
360 if (TREE_ASM_WRITTEN (decl
) || DECL_EXTERNAL (decl
)
361 || (TREE_CODE (decl
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (decl
)))
364 /* Don't write out static consts, unless we still need them.
366 We also keep static consts if not optimizing (for debugging),
367 unless the user specified -fno-keep-static-consts.
368 ??? They might be better written into the debug information.
369 This is possible when using DWARF.
371 A language processor that wants static constants to be always
372 written out (even if it is not used) is responsible for
373 calling rest_of_decl_compilation itself. E.g. the C front-end
374 calls rest_of_decl_compilation from finish_decl.
375 One motivation for this is that is conventional in some
376 environments to write things like:
377 static const char rcsid[] = "... version string ...";
378 intending to force the string to be in the executable.
380 A language processor that would prefer to have unneeded
381 static constants "optimized away" would just defer writing
382 them out until here. E.g. C++ does this, because static
383 constants are often defined in header files.
385 ??? A tempting alternative (for both C and C++) would be
386 to force a constant to be written if and only if it is
387 defined in a main file, as opposed to an include file. */
389 if (TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
391 struct varpool_node
*node
;
393 node
= varpool_get_node (decl
);
395 if (!node
&& flag_ltrans
)
397 else if (node
&& node
->symbol
.definition
)
399 else if (node
&& node
->symbol
.alias
)
401 else if (!cgraph_global_info_ready
403 || TREE_USED (DECL_ASSEMBLER_NAME (decl
))))
405 else if (node
&& node
->symbol
.analyzed
)
407 else if (DECL_COMDAT (decl
))
409 else if (TREE_READONLY (decl
) && !TREE_PUBLIC (decl
)
410 && (optimize
|| !flag_keep_static_consts
411 || DECL_ARTIFICIAL (decl
)))
416 rest_of_decl_compilation (decl
, 1, 1);
424 /* Do any final processing required for the declarations in VEC, of
425 which there are LEN. We write out inline functions and variables
426 that have been deferred until this point, but which are required.
427 Returns nonzero if anything was put out. */
430 wrapup_global_declarations (tree
*vec
, int len
)
432 bool reconsider
, output_something
= false;
435 for (i
= 0; i
< len
; i
++)
436 wrapup_global_declaration_1 (vec
[i
]);
438 /* Now emit any global variables or functions that we have been
439 putting off. We need to loop in case one of the things emitted
440 here references another one which comes earlier in the list. */
444 for (i
= 0; i
< len
; i
++)
445 reconsider
|= wrapup_global_declaration_2 (vec
[i
]);
447 output_something
= true;
451 return output_something
;
454 /* A subroutine of check_global_declarations. Issue appropriate warnings
455 for the global declaration DECL. */
458 check_global_declaration_1 (tree decl
)
460 /* Warn about any function declared static but not defined. We don't
461 warn about variables, because many programs have static variables
462 that exist only to get some text into the object file. */
463 if (TREE_CODE (decl
) == FUNCTION_DECL
464 && DECL_INITIAL (decl
) == 0
465 && DECL_EXTERNAL (decl
)
466 && ! DECL_ARTIFICIAL (decl
)
467 && ! TREE_NO_WARNING (decl
)
468 && ! TREE_PUBLIC (decl
)
469 && (warn_unused_function
470 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))))
472 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
473 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
475 warning (OPT_Wunused_function
, "%q+F declared %<static%> but never defined", decl
);
476 /* This symbol is effectively an "extern" declaration now. */
477 TREE_PUBLIC (decl
) = 1;
480 /* Warn about static fns or vars defined but not used. */
481 if (((warn_unused_function
&& TREE_CODE (decl
) == FUNCTION_DECL
)
482 /* We don't warn about "static const" variables because the
483 "rcs_id" idiom uses that construction. */
484 || (warn_unused_variable
485 && TREE_CODE (decl
) == VAR_DECL
&& ! TREE_READONLY (decl
)))
486 && ! DECL_IN_SYSTEM_HEADER (decl
)
487 && ! TREE_USED (decl
)
488 /* The TREE_USED bit for file-scope decls is kept in the identifier,
489 to handle multiple external decls in different scopes. */
490 && ! (DECL_NAME (decl
) && TREE_USED (DECL_NAME (decl
)))
491 && ! DECL_EXTERNAL (decl
)
492 && ! TREE_PUBLIC (decl
)
493 /* A volatile variable might be used in some non-obvious way. */
494 && ! TREE_THIS_VOLATILE (decl
)
495 /* Global register variables must be declared to reserve them. */
496 && ! (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
497 /* Otherwise, ask the language. */
498 && lang_hooks
.decls
.warn_unused_global (decl
))
499 warning ((TREE_CODE (decl
) == FUNCTION_DECL
)
500 ? OPT_Wunused_function
501 : OPT_Wunused_variable
,
502 "%q+D defined but not used", decl
);
505 /* Issue appropriate warnings for the global declarations in V (of
506 which there are LEN). */
509 check_global_declarations (tree
*v
, int len
)
513 for (i
= 0; i
< len
; i
++)
514 check_global_declaration_1 (v
[i
]);
517 /* Emit debugging information for all global declarations in VEC. */
520 emit_debug_global_declarations (tree
*vec
, int len
)
524 /* Avoid confusing the debug information machinery when there are errors. */
528 timevar_push (TV_SYMOUT
);
529 for (i
= 0; i
< len
; i
++)
530 debug_hooks
->global_decl (vec
[i
]);
531 timevar_pop (TV_SYMOUT
);
534 /* Compile an entire translation unit. Write a file of assembly
535 output and various debugging dumps. */
540 timevar_start (TV_PHASE_PARSING
);
541 timevar_push (TV_PARSE_GLOBAL
);
543 /* Call the parser, which parses the entire file (calling
544 rest_of_compilation for each function). */
545 lang_hooks
.parse_file ();
547 timevar_pop (TV_PARSE_GLOBAL
);
548 timevar_stop (TV_PHASE_PARSING
);
550 /* Compilation is now finished except for writing
551 what's left of the symbol table output. */
553 if (flag_syntax_only
|| flag_wpa
)
556 ggc_protect_identifiers
= false;
558 /* This must also call finalize_compilation_unit. */
559 lang_hooks
.decls
.final_write_globals ();
564 timevar_start (TV_PHASE_LATE_ASM
);
566 /* Compilation unit is finalized. When producing non-fat LTO object, we are
567 basically finished. */
568 if (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
)
570 /* Likewise for mudflap static object registrations. */
572 mudflap_finish_file ();
574 /* File-scope initialization for AddressSanitizer. */
581 output_shared_constant_pool ();
582 output_object_blocks ();
583 finish_tm_clone_pairs ();
585 /* Write out any pending weak symbol declarations. */
588 /* This must be at the end before unwind and debug info.
589 Some target ports emit PIC setup thunks here. */
590 targetm
.asm_out
.code_end ();
592 /* Do dbx symbols. */
593 timevar_push (TV_SYMOUT
);
595 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
596 if (dwarf2out_do_frame ())
597 dwarf2out_frame_finish ();
600 (*debug_hooks
->finish
) (main_input_filename
);
601 timevar_pop (TV_SYMOUT
);
603 /* Output some stuff at end of file if nec. */
605 dw2_output_indirect_constants ();
607 /* Flush any pending external directives. */
608 process_pending_assemble_externals ();
611 /* Emit LTO marker if LTO info has been previously emitted. This is
612 used by collect2 to determine whether an object file contains IL.
613 We used to emit an undefined reference here, but this produces
614 link errors if an object file with IL is stored into a shared
615 library without invoking lto1. */
616 if (flag_generate_lto
)
618 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
619 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, NULL_TREE
,
621 (unsigned HOST_WIDE_INT
) 1, 8);
622 #elif defined ASM_OUTPUT_ALIGNED_COMMON
623 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, "__gnu_lto_v1",
624 (unsigned HOST_WIDE_INT
) 1, 8);
626 ASM_OUTPUT_COMMON (asm_out_file
, "__gnu_lto_v1",
627 (unsigned HOST_WIDE_INT
) 1,
628 (unsigned HOST_WIDE_INT
) 1);
630 /* Let linker plugin know that this is a slim object and must be LTOed
631 even when user did not ask for it. */
632 if (!flag_fat_lto_objects
)
634 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
635 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, NULL_TREE
,
637 (unsigned HOST_WIDE_INT
) 1, 8);
638 #elif defined ASM_OUTPUT_ALIGNED_COMMON
639 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, "__gnu_lto_slim",
640 (unsigned HOST_WIDE_INT
) 1, 8);
642 ASM_OUTPUT_COMMON (asm_out_file
, "__gnu_lto_slim",
643 (unsigned HOST_WIDE_INT
) 1,
644 (unsigned HOST_WIDE_INT
) 1);
649 /* Attach a special .ident directive to the end of the file to identify
650 the version of GCC which compiled this code. The format of the .ident
651 string is patterned after the ones produced by native SVR4 compilers. */
654 const char *pkg_version
= "(GNU) ";
657 if (strcmp ("(GCC) ", pkgversion_string
))
658 pkg_version
= pkgversion_string
;
660 ident_str
= ACONCAT (("GCC: ", pkg_version
, version_string
, NULL
));
661 targetm
.asm_out
.output_ident (ident_str
);
664 /* Invoke registered plugin callbacks. */
665 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT
, NULL
);
667 /* This must be at the end. Some target ports emit end of file directives
668 into the assembly file here, and hence we can not output anything to the
669 assembly file after this point. */
670 targetm
.asm_out
.file_end ();
672 timevar_stop (TV_PHASE_LATE_ASM
);
675 /* Print version information to FILE.
676 Each line begins with INDENT (for the case where FILE is the
677 assembler output file). */
680 print_version (FILE *file
, const char *indent
)
682 static const char fmt1
[] =
684 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
686 N_("%s%s%s %sversion %s (%s) compiled by CC, ")
689 static const char fmt2
[] =
690 N_("GMP version %s, MPFR version %s, MPC version %s\n");
691 static const char fmt3
[] =
692 N_("%s%swarning: %s header version %s differs from library version %s.\n");
693 static const char fmt4
[] =
694 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
696 #define __VERSION__ "[?]"
699 file
== stderr
? _(fmt1
) : fmt1
,
700 indent
, *indent
!= 0 ? " " : "",
701 lang_hooks
.name
, pkgversion_string
, version_string
, TARGET_NAME
,
702 indent
, __VERSION__
);
704 /* We need to stringify the GMP macro values. Ugh, gmp_version has
705 two string formats, "i.j.k" and "i.j" when k is zero. As of
706 gmp-4.3.0, GMP always uses the 3 number format. */
707 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
708 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
709 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
710 #define GCC_GMP_VERSION \
711 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
712 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
713 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
714 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
716 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
717 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
718 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
721 file
== stderr
? _(fmt2
) : fmt2
,
722 GCC_GMP_STRINGIFY_VERSION
, MPFR_VERSION_STRING
, MPC_VERSION_STRING
);
723 if (strcmp (GCC_GMP_STRINGIFY_VERSION
, gmp_version
))
725 file
== stderr
? _(fmt3
) : fmt3
,
726 indent
, *indent
!= 0 ? " " : "",
727 "GMP", GCC_GMP_STRINGIFY_VERSION
, gmp_version
);
728 if (strcmp (MPFR_VERSION_STRING
, mpfr_get_version ()))
730 file
== stderr
? _(fmt3
) : fmt3
,
731 indent
, *indent
!= 0 ? " " : "",
732 "MPFR", MPFR_VERSION_STRING
, mpfr_get_version ());
733 if (strcmp (MPC_VERSION_STRING
, mpc_get_version ()))
735 file
== stderr
? _(fmt3
) : fmt3
,
736 indent
, *indent
!= 0 ? " " : "",
737 "MPC", MPC_VERSION_STRING
, mpc_get_version ());
739 file
== stderr
? _(fmt4
) : fmt4
,
740 indent
, *indent
!= 0 ? " " : "",
741 PARAM_VALUE (GGC_MIN_EXPAND
), PARAM_VALUE (GGC_MIN_HEAPSIZE
));
743 print_plugins_versions (file
, indent
);
747 print_to_asm_out_file (print_switch_type type
, const char * text
)
749 bool prepend_sep
= true;
753 case SWITCH_TYPE_LINE_END
:
754 putc ('\n', asm_out_file
);
757 case SWITCH_TYPE_LINE_START
:
758 fputs (ASM_COMMENT_START
, asm_out_file
);
759 return strlen (ASM_COMMENT_START
);
761 case SWITCH_TYPE_DESCRIPTIVE
:
762 if (ASM_COMMENT_START
[0] == 0)
765 case SWITCH_TYPE_PASSED
:
766 case SWITCH_TYPE_ENABLED
:
768 fputc (' ', asm_out_file
);
769 fputs (text
, asm_out_file
);
770 /* No need to return the length here as
771 print_single_switch has already done it. */
780 print_to_stderr (print_switch_type type
, const char * text
)
784 case SWITCH_TYPE_LINE_END
:
788 case SWITCH_TYPE_LINE_START
:
791 case SWITCH_TYPE_PASSED
:
792 case SWITCH_TYPE_ENABLED
:
796 case SWITCH_TYPE_DESCRIPTIVE
:
797 fputs (text
, stderr
);
798 /* No need to return the length here as
799 print_single_switch has already done it. */
807 /* Print an option value and return the adjusted position in the line.
808 ??? print_fn doesn't handle errors, eg disk full; presumably other
809 code will catch a disk full though. */
812 print_single_switch (print_switch_fn_type print_fn
,
814 print_switch_type type
,
817 /* The ultrix fprintf returns 0 on success, so compute the result
818 we want here since we need it for the following test. The +1
819 is for the separator character that will probably be emitted. */
820 int len
= strlen (text
) + 1;
823 && pos
+ len
> MAX_LINE
)
825 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
830 pos
+= print_fn (SWITCH_TYPE_LINE_START
, NULL
);
832 print_fn (type
, text
);
836 /* Print active target switches using PRINT_FN.
837 POS is the current cursor position and MAX is the size of a "line".
838 Each line begins with INDENT and ends with TERM.
839 Each switch is separated from the next by SEP. */
842 print_switch_values (print_switch_fn_type print_fn
)
847 /* Fill in the -frandom-seed option, if the user didn't pass it, so
848 that it can be printed below. This helps reproducibility. */
849 if (!flag_random_seed
)
852 /* Print the options as passed. */
853 pos
= print_single_switch (print_fn
, pos
,
854 SWITCH_TYPE_DESCRIPTIVE
, _("options passed: "));
856 for (j
= 1; j
< save_decoded_options_count
; j
++)
858 switch (save_decoded_options
[j
].opt_index
)
871 pos
= print_single_switch (print_fn
, pos
, SWITCH_TYPE_PASSED
,
872 save_decoded_options
[j
].orig_option_with_args_text
);
876 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
878 /* Print the -f and -m options that have been enabled.
879 We don't handle language specific options but printing argv
881 pos
= print_single_switch (print_fn
, 0,
882 SWITCH_TYPE_DESCRIPTIVE
, _("options enabled: "));
884 for (j
= 0; j
< cl_options_count
; j
++)
885 if (cl_options
[j
].cl_report
886 && option_enabled (j
, &global_options
) > 0)
887 pos
= print_single_switch (print_fn
, pos
,
888 SWITCH_TYPE_ENABLED
, cl_options
[j
].opt_text
);
890 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
893 /* Open assembly code output file. Do this even if -fsyntax-only is
894 on, because then the driver will have provided the name of a
895 temporary file or bit bucket for us. NAME is the file specified on
896 the command line, possibly NULL. */
898 init_asm_output (const char *name
)
900 if (name
== NULL
&& asm_file_name
== 0)
901 asm_out_file
= stdout
;
904 if (asm_file_name
== 0)
906 int len
= strlen (dump_base_name
);
907 char *dumpname
= XNEWVEC (char, len
+ 6);
909 memcpy (dumpname
, dump_base_name
, len
+ 1);
910 strip_off_ending (dumpname
, len
);
911 strcat (dumpname
, ".s");
912 asm_file_name
= dumpname
;
914 if (!strcmp (asm_file_name
, "-"))
915 asm_out_file
= stdout
;
917 asm_out_file
= fopen (asm_file_name
, "w");
918 if (asm_out_file
== 0)
919 fatal_error ("can%'t open %s for writing: %m", asm_file_name
);
922 if (!flag_syntax_only
)
924 targetm
.asm_out
.file_start ();
926 if (flag_record_gcc_switches
)
928 if (targetm
.asm_out
.record_gcc_switches
)
930 /* Let the target know that we are about to start recording. */
931 targetm
.asm_out
.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE
,
933 /* Now record the switches. */
934 print_switch_values (targetm
.asm_out
.record_gcc_switches
);
935 /* Let the target know that the recording is over. */
936 targetm
.asm_out
.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE
,
940 inform (input_location
, "-frecord-gcc-switches is not supported by the current target");
943 if (flag_verbose_asm
)
945 /* Print the list of switches in effect
946 into the assembler file as comments. */
947 print_version (asm_out_file
, ASM_COMMENT_START
);
948 print_switch_values (print_to_asm_out_file
);
949 putc ('\n', asm_out_file
);
954 /* A helper function; used as the reallocator function for cpp's line
957 realloc_for_line_map (void *ptr
, size_t len
)
959 return GGC_RESIZEVAR (void, ptr
, len
);
962 /* A helper function: used as the allocator function for
963 identifier_to_locale. */
965 alloc_for_identifier_to_locale (size_t len
)
967 return ggc_alloc_atomic (len
);
970 /* Output stack usage information. */
972 output_stack_usage (void)
974 static bool warning_issued
= false;
975 enum stack_usage_kind_type
{ STATIC
= 0, DYNAMIC
, DYNAMIC_BOUNDED
};
976 const char *stack_usage_kind_str
[] = {
981 HOST_WIDE_INT stack_usage
= current_function_static_stack_size
;
982 enum stack_usage_kind_type stack_usage_kind
;
988 warning (0, "stack usage computation not supported for this target");
989 warning_issued
= true;
994 stack_usage_kind
= STATIC
;
996 /* Add the maximum amount of space pushed onto the stack. */
997 if (current_function_pushed_stack_size
> 0)
999 stack_usage
+= current_function_pushed_stack_size
;
1000 stack_usage_kind
= DYNAMIC_BOUNDED
;
1003 /* Now on to the tricky part: dynamic stack allocation. */
1004 if (current_function_allocates_dynamic_stack_space
)
1006 if (current_function_has_unbounded_dynamic_stack_size
)
1007 stack_usage_kind
= DYNAMIC
;
1009 stack_usage_kind
= DYNAMIC_BOUNDED
;
1011 /* Add the size even in the unbounded case, this can't hurt. */
1012 stack_usage
+= current_function_dynamic_stack_size
;
1015 if (flag_stack_usage
)
1017 expanded_location loc
1018 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
1019 const char *raw_id
, *id
;
1021 /* Strip the scope prefix if any. */
1022 raw_id
= lang_hooks
.decl_printable_name (current_function_decl
, 2);
1023 id
= strrchr (raw_id
, '.');
1029 fprintf (stack_usage_file
,
1030 "%s:%d:%d:%s\t"HOST_WIDE_INT_PRINT_DEC
"\t%s\n",
1031 lbasename (loc
.file
),
1036 stack_usage_kind_str
[stack_usage_kind
]);
1039 if (warn_stack_usage
>= 0)
1041 if (stack_usage_kind
== DYNAMIC
)
1042 warning (OPT_Wstack_usage_
, "stack usage might be unbounded");
1043 else if (stack_usage
> warn_stack_usage
)
1045 if (stack_usage_kind
== DYNAMIC_BOUNDED
)
1046 warning (OPT_Wstack_usage_
, "stack usage might be %wd bytes",
1049 warning (OPT_Wstack_usage_
, "stack usage is %wd bytes",
1055 /* Open an auxiliary output file. */
1057 open_auxiliary_file (const char *ext
)
1062 filename
= concat (aux_base_name
, ".", ext
, NULL
);
1063 file
= fopen (filename
, "w");
1065 fatal_error ("can%'t open %s for writing: %m", filename
);
1070 /* Initialization of the front end environment, before command line
1071 options are parsed. Signal handlers, internationalization etc.
1072 ARGV0 is main's argv[0]. */
1074 general_init (const char *argv0
)
1078 p
= argv0
+ strlen (argv0
);
1079 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
1083 xmalloc_set_program_name (progname
);
1087 /* Unlock the stdio streams. */
1088 unlock_std_streams ();
1090 gcc_init_libintl ();
1092 identifier_to_locale_alloc
= alloc_for_identifier_to_locale
;
1093 identifier_to_locale_free
= ggc_free
;
1095 /* Initialize the diagnostics reporting machinery, so option parsing
1096 can give warnings and errors. */
1097 diagnostic_initialize (global_dc
, N_OPTS
);
1098 /* Set a default printer. Language specific initializations will
1099 override it later. */
1100 tree_diagnostics_defaults (global_dc
);
1101 /* FIXME: This should probably be moved to C-family
1102 language-specific initializations. */
1103 /* By default print macro expansion contexts in the diagnostic
1104 finalizer -- for tokens resulting from macro expansion. */
1105 diagnostic_finalizer (global_dc
) = virt_loc_aware_diagnostic_finalizer
;
1107 global_dc
->show_caret
1108 = global_options_init
.x_flag_diagnostics_show_caret
;
1109 global_dc
->show_option_requested
1110 = global_options_init
.x_flag_diagnostics_show_option
;
1111 global_dc
->show_column
1112 = global_options_init
.x_flag_show_column
;
1113 global_dc
->internal_error
= plugins_internal_error_function
;
1114 global_dc
->option_enabled
= option_enabled
;
1115 global_dc
->option_state
= &global_options
;
1116 global_dc
->option_name
= option_name
;
1118 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1120 signal (SIGSEGV
, crash_signal
);
1123 signal (SIGILL
, crash_signal
);
1126 signal (SIGBUS
, crash_signal
);
1129 signal (SIGABRT
, crash_signal
);
1131 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1132 signal (SIGIOT
, crash_signal
);
1135 signal (SIGFPE
, crash_signal
);
1138 /* Other host-specific signal setup. */
1139 (*host_hooks
.extra_signals
)();
1141 /* Initialize the garbage-collector, string pools and tree type hash
1145 line_table
= ggc_alloc_line_maps ();
1146 linemap_init (line_table
);
1147 line_table
->reallocator
= realloc_for_line_map
;
1148 line_table
->round_alloc_size
= ggc_round_alloc_size
;
1151 /* Initialize register usage now so switches may override. */
1154 /* Register the language-independent parameters. */
1155 global_init_params ();
1157 /* This must be done after global_init_params but before argument
1159 init_ggc_heuristics();
1161 /* Create the singleton holder for global state.
1162 Doing so also creates the pass manager and with it the passes. */
1163 g
= new gcc::context();
1165 statistics_early_init ();
1169 /* Return true if the current target supports -fsection-anchors. */
1172 target_supports_section_anchors_p (void)
1174 if (targetm
.min_anchor_offset
== 0 && targetm
.max_anchor_offset
== 0)
1177 if (targetm
.asm_out
.output_anchor
== NULL
)
1183 /* Default the align_* variables to 1 if they're still unset, and
1184 set up the align_*_log variables. */
1186 init_alignments (void)
1188 if (align_loops
<= 0)
1190 if (align_loops_max_skip
> align_loops
)
1191 align_loops_max_skip
= align_loops
- 1;
1192 align_loops_log
= floor_log2 (align_loops
* 2 - 1);
1193 if (align_jumps
<= 0)
1195 if (align_jumps_max_skip
> align_jumps
)
1196 align_jumps_max_skip
= align_jumps
- 1;
1197 align_jumps_log
= floor_log2 (align_jumps
* 2 - 1);
1198 if (align_labels
<= 0)
1200 align_labels_log
= floor_log2 (align_labels
* 2 - 1);
1201 if (align_labels_max_skip
> align_labels
)
1202 align_labels_max_skip
= align_labels
- 1;
1203 if (align_functions
<= 0)
1204 align_functions
= 1;
1205 align_functions_log
= floor_log2 (align_functions
* 2 - 1);
1208 /* Process the options that have been parsed. */
1210 process_options (void)
1212 /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1213 This can happen with incorrect pre-processed input. */
1214 debug_hooks
= &do_nothing_debug_hooks
;
1216 maximum_field_alignment
= initial_max_fld_align
* BITS_PER_UNIT
;
1218 /* Default to -fdiagnostics-color=auto if GCC_COLORS is in the environment,
1219 otherwise default to -fdiagnostics-color=never. */
1220 if (!global_options_set
.x_flag_diagnostics_show_color
1221 && getenv ("GCC_COLORS"))
1222 pp_show_color (global_dc
->printer
)
1223 = colorize_init (DIAGNOSTICS_COLOR_AUTO
);
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
);
1231 /* Some machines may reject certain combinations of options. */
1232 targetm
.target_option
.override ();
1234 /* Avoid any informative notes in the second run of -fcompare-debug. */
1235 if (flag_compare_debug
)
1236 diagnostic_inhibit_notes (global_dc
);
1238 if (flag_section_anchors
&& !target_supports_section_anchors_p ())
1240 warning (OPT_fsection_anchors
,
1241 "this target does not support %qs", "-fsection-anchors");
1242 flag_section_anchors
= 0;
1245 if (flag_short_enums
== 2)
1246 flag_short_enums
= targetm
.default_short_enums ();
1248 /* Set aux_base_name if not already set. */
1251 else if (main_input_filename
)
1253 char *name
= xstrdup (lbasename (main_input_filename
));
1255 strip_off_ending (name
, strlen (name
));
1256 aux_base_name
= name
;
1259 aux_base_name
= "gccaux";
1263 || flag_graphite_identity
1265 || flag_loop_interchange
1266 || flag_loop_strip_mine
1267 || flag_loop_parallelize_all
)
1268 sorry ("Graphite loop optimizations cannot be used (-fgraphite, "
1269 "-fgraphite-identity, -floop-block, "
1270 "-floop-interchange, -floop-strip-mine, -floop-parallelize-all, "
1271 "and -ftree-loop-linear)");
1274 if (flag_mudflap
&& flag_lto
)
1275 sorry ("mudflap cannot be used together with link-time optimization");
1277 /* One region RA really helps to decrease the code size. */
1278 if (flag_ira_region
== IRA_REGION_AUTODETECT
)
1280 = optimize_size
|| !optimize
? IRA_REGION_ONE
: IRA_REGION_MIXED
;
1282 if (flag_strict_volatile_bitfields
> 0 && !abi_version_at_least (2))
1284 warning (0, "-fstrict-volatile-bitfields disabled; "
1285 "it is incompatible with ABI versions < 2");
1286 flag_strict_volatile_bitfields
= 0;
1289 /* Unrolling all loops implies that standard loop unrolling must also
1291 if (flag_unroll_all_loops
)
1292 flag_unroll_loops
= 1;
1294 /* web and rename-registers help when run after loop unrolling. */
1295 if (flag_web
== AUTODETECT_VALUE
)
1296 flag_web
= flag_unroll_loops
|| flag_peel_loops
;
1298 if (flag_rename_registers
== AUTODETECT_VALUE
)
1299 flag_rename_registers
= flag_unroll_loops
|| flag_peel_loops
;
1301 if (flag_non_call_exceptions
)
1302 flag_asynchronous_unwind_tables
= 1;
1303 if (flag_asynchronous_unwind_tables
)
1304 flag_unwind_tables
= 1;
1306 if (flag_value_profile_transformations
)
1307 flag_profile_values
= 1;
1309 /* Warn about options that are not supported on this machine. */
1310 #ifndef INSN_SCHEDULING
1311 if (flag_schedule_insns
|| flag_schedule_insns_after_reload
)
1312 warning (0, "instruction scheduling not supported on this target machine");
1315 if (flag_delayed_branch
)
1316 warning (0, "this target machine does not have delayed branches");
1319 user_label_prefix
= USER_LABEL_PREFIX
;
1320 if (flag_leading_underscore
!= -1)
1322 /* If the default prefix is more complicated than "" or "_",
1323 issue a warning and ignore this option. */
1324 if (user_label_prefix
[0] == 0 ||
1325 (user_label_prefix
[0] == '_' && user_label_prefix
[1] == 0))
1327 user_label_prefix
= flag_leading_underscore
? "_" : "";
1330 warning (0, "-f%sleading-underscore not supported on this target machine",
1331 flag_leading_underscore
? "" : "no-");
1334 /* If we are in verbose mode, write out the version and maybe all the
1335 option flags in use. */
1338 print_version (stderr
, "");
1340 print_switch_values (print_to_stderr
);
1343 if (flag_syntax_only
)
1345 write_symbols
= NO_DEBUG
;
1351 if (debug_info_level
== DINFO_LEVEL_NONE
)
1353 debug_info_level
= DINFO_LEVEL_NORMAL
;
1355 if (write_symbols
== NO_DEBUG
)
1356 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1359 debug_info_level
= DINFO_LEVEL_NONE
;
1362 if (flag_dump_final_insns
&& !flag_syntax_only
&& !no_backend
)
1364 FILE *final_output
= fopen (flag_dump_final_insns
, "w");
1367 error ("could not open final insn dump file %qs: %m",
1368 flag_dump_final_insns
);
1369 flag_dump_final_insns
= NULL
;
1371 else if (fclose (final_output
))
1373 error ("could not close zeroed insn dump file %qs: %m",
1374 flag_dump_final_insns
);
1375 flag_dump_final_insns
= NULL
;
1379 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1381 if (debug_info_level
== DINFO_LEVEL_NONE
)
1382 write_symbols
= NO_DEBUG
;
1384 if (write_symbols
== NO_DEBUG
)
1386 #if defined(DBX_DEBUGGING_INFO)
1387 else if (write_symbols
== DBX_DEBUG
)
1388 debug_hooks
= &dbx_debug_hooks
;
1390 #if defined(XCOFF_DEBUGGING_INFO)
1391 else if (write_symbols
== XCOFF_DEBUG
)
1392 debug_hooks
= &xcoff_debug_hooks
;
1394 #ifdef SDB_DEBUGGING_INFO
1395 else if (write_symbols
== SDB_DEBUG
)
1396 debug_hooks
= &sdb_debug_hooks
;
1398 #ifdef DWARF2_DEBUGGING_INFO
1399 else if (write_symbols
== DWARF2_DEBUG
)
1400 debug_hooks
= &dwarf2_debug_hooks
;
1402 #ifdef VMS_DEBUGGING_INFO
1403 else if (write_symbols
== VMS_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
1404 debug_hooks
= &vmsdbg_debug_hooks
;
1407 error ("target system does not support the \"%s\" debug format",
1408 debug_type_names
[write_symbols
]);
1410 /* We know which debug output will be used so we can set flag_var_tracking
1411 and flag_var_tracking_uninit if the user has not specified them. */
1412 if (debug_info_level
< DINFO_LEVEL_NORMAL
1413 || debug_hooks
->var_location
== do_nothing_debug_hooks
.var_location
)
1415 if (flag_var_tracking
== 1
1416 || flag_var_tracking_uninit
== 1)
1418 if (debug_info_level
< DINFO_LEVEL_NORMAL
)
1419 warning (0, "variable tracking requested, but useless unless "
1420 "producing debug info");
1422 warning (0, "variable tracking requested, but not supported "
1423 "by this debug format");
1425 flag_var_tracking
= 0;
1426 flag_var_tracking_uninit
= 0;
1429 /* The debug hooks are used to implement -fdump-go-spec because it
1430 gives a simple and stable API for all the information we need to
1432 if (flag_dump_go_spec
!= NULL
)
1433 debug_hooks
= dump_go_spec_init (flag_dump_go_spec
, debug_hooks
);
1435 /* If the user specifically requested variable tracking with tagging
1436 uninitialized variables, we need to turn on variable tracking.
1437 (We already determined above that variable tracking is feasible.) */
1438 if (flag_var_tracking_uninit
== 1)
1439 flag_var_tracking
= 1;
1441 if (flag_var_tracking
== AUTODETECT_VALUE
)
1442 flag_var_tracking
= optimize
>= 1;
1444 if (flag_var_tracking_uninit
== AUTODETECT_VALUE
)
1445 flag_var_tracking_uninit
= flag_var_tracking
;
1447 if (flag_var_tracking_assignments
== AUTODETECT_VALUE
)
1448 flag_var_tracking_assignments
= flag_var_tracking
1449 && !(flag_selective_scheduling
|| flag_selective_scheduling2
);
1451 if (flag_var_tracking_assignments_toggle
)
1452 flag_var_tracking_assignments
= !flag_var_tracking_assignments
;
1454 if (flag_var_tracking_assignments
&& !flag_var_tracking
)
1455 flag_var_tracking
= flag_var_tracking_assignments
= -1;
1457 if (flag_var_tracking_assignments
1458 && (flag_selective_scheduling
|| flag_selective_scheduling2
))
1459 warning (0, "var-tracking-assignments changes selective scheduling");
1461 if (flag_tree_cselim
== AUTODETECT_VALUE
)
1462 #ifdef HAVE_conditional_move
1463 flag_tree_cselim
= 1;
1465 flag_tree_cselim
= 0;
1468 /* If auxiliary info generation is desired, open the output file.
1469 This goes in the same directory as the source file--unlike
1470 all the other output files. */
1471 if (flag_gen_aux_info
)
1473 aux_info_file
= fopen (aux_info_file_name
, "w");
1474 if (aux_info_file
== 0)
1475 fatal_error ("can%'t open %s: %m", aux_info_file_name
);
1478 if (!targetm_common
.have_named_sections
)
1480 if (flag_function_sections
)
1482 warning (0, "-ffunction-sections not supported for this target");
1483 flag_function_sections
= 0;
1485 if (flag_data_sections
)
1487 warning (0, "-fdata-sections not supported for this target");
1488 flag_data_sections
= 0;
1492 #ifndef HAVE_prefetch
1493 if (flag_prefetch_loop_arrays
> 0)
1495 warning (0, "-fprefetch-loop-arrays not supported for this target");
1496 flag_prefetch_loop_arrays
= 0;
1499 if (flag_prefetch_loop_arrays
> 0 && !HAVE_prefetch
)
1501 warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
1502 flag_prefetch_loop_arrays
= 0;
1506 /* This combination of options isn't handled for i386 targets and doesn't
1507 make much sense anyway, so don't allow it. */
1508 if (flag_prefetch_loop_arrays
> 0 && optimize_size
)
1510 warning (0, "-fprefetch-loop-arrays is not supported with -Os");
1511 flag_prefetch_loop_arrays
= 0;
1514 /* The presence of IEEE signaling NaNs, implies all math can trap. */
1515 if (flag_signaling_nans
)
1516 flag_trapping_math
= 1;
1518 /* We cannot reassociate if we want traps or signed zeros. */
1519 if (flag_associative_math
&& (flag_trapping_math
|| flag_signed_zeros
))
1521 warning (0, "-fassociative-math disabled; other options take precedence");
1522 flag_associative_math
= 0;
1525 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1526 if (flag_cx_limited_range
)
1527 flag_complex_method
= 0;
1529 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1530 if (flag_cx_fortran_rules
)
1531 flag_complex_method
= 1;
1533 /* Targets must be able to place spill slots at lower addresses. If the
1534 target already uses a soft frame pointer, the transition is trivial. */
1535 if (!FRAME_GROWS_DOWNWARD
&& flag_stack_protect
)
1537 warning (0, "-fstack-protector not supported for this target");
1538 flag_stack_protect
= 0;
1540 if (!flag_stack_protect
)
1541 warn_stack_protect
= 0;
1543 /* Address Sanitizer needs porting to each target architecture. */
1545 && (targetm
.asan_shadow_offset
== NULL
1546 || !FRAME_GROWS_DOWNWARD
))
1548 warning (0, "-fsanitize=address not supported for this target");
1552 /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error
1553 have not been set. */
1554 if (!global_options_set
.x_warnings_are_errors
1555 && warn_coverage_mismatch
1556 && (global_dc
->classify_diagnostic
[OPT_Wcoverage_mismatch
] ==
1558 diagnostic_classify_diagnostic (global_dc
, OPT_Wcoverage_mismatch
,
1559 DK_ERROR
, UNKNOWN_LOCATION
);
1561 /* Save the current optimization options. */
1562 optimization_default_node
= build_optimization_node ();
1563 optimization_current_node
= optimization_default_node
;
1566 /* This function can be called multiple times to reinitialize the compiler
1567 back end when register classes or instruction sets have changed,
1568 before each function. */
1570 backend_init_target (void)
1572 /* Initialize alignment variables. */
1575 /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
1576 to initialize reg_raw_mode[]. */
1579 /* This invokes target hooks to set fixed_reg[] etc, which is
1583 /* This depends on stack_pointer_rtx. */
1584 init_fake_stack_mems ();
1586 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1588 init_alias_target ();
1590 /* Depends on HARD_FRAME_POINTER_REGNUM. */
1593 /* The following initialization functions need to generate rtl, so
1594 provide a dummy function context for them. */
1595 init_dummy_function_start ();
1597 /* rtx_cost is mode-dependent, so cached values need to be recomputed
1598 on a mode change. */
1600 init_lower_subreg ();
1602 /* We may need to recompute regno_save_code[] and regno_restore_code[]
1603 after a mode change as well. */
1604 caller_save_initialized_p
= false;
1606 expand_dummy_function_end ();
1609 /* Initialize the compiler back end. This function is called only once,
1610 when starting the compiler. */
1617 init_inline_once ();
1618 init_varasm_once ();
1619 save_register_info ();
1621 /* Initialize the target-specific back end pieces. */
1623 backend_init_target ();
1626 /* Initialize excess precision settings. */
1628 init_excess_precision (void)
1630 /* Adjust excess precision handling based on the target options. If
1631 the front end cannot handle it, flag_excess_precision_cmdline
1632 will already have been set accordingly in the post_options
1634 gcc_assert (flag_excess_precision_cmdline
!= EXCESS_PRECISION_DEFAULT
);
1635 flag_excess_precision
= flag_excess_precision_cmdline
;
1636 if (flag_unsafe_math_optimizations
)
1637 flag_excess_precision
= EXCESS_PRECISION_FAST
;
1638 if (flag_excess_precision
== EXCESS_PRECISION_STANDARD
)
1640 int flt_eval_method
= TARGET_FLT_EVAL_METHOD
;
1641 switch (flt_eval_method
)
1645 /* Either the target acts unpredictably (-1) or has all the
1646 operations required not to have excess precision (0). */
1647 flag_excess_precision
= EXCESS_PRECISION_FAST
;
1651 /* In these cases, predictable excess precision makes
1655 /* Any other implementation-defined FLT_EVAL_METHOD values
1656 require the compiler to handle the associated excess
1657 precision rules in excess_precision_type. */
1663 /* Initialize things that are both lang-dependent and target-dependent.
1664 This function can be called more than once if target parameters change. */
1666 lang_dependent_init_target (void)
1668 /* This determines excess precision settings. */
1669 init_excess_precision ();
1671 /* This creates various _DECL nodes, so needs to be called after the
1672 front end is initialized. It also depends on the HAVE_xxx macros
1673 generated from the target machine description. */
1676 /* The following initialization functions need to generate rtl, so
1677 provide a dummy function context for them. */
1678 init_dummy_function_start ();
1680 /* Do the target-specific parts of expr initialization. */
1681 init_expr_target ();
1683 /* Although the actions of these functions are language-independent,
1684 they use optabs, so we cannot call them from backend_init. */
1688 expand_dummy_function_end ();
1691 /* Language-dependent initialization. Returns nonzero on success. */
1693 lang_dependent_init (const char *name
)
1695 location_t save_loc
= input_location
;
1696 if (dump_base_name
== 0)
1697 dump_base_name
= name
&& name
[0] ? name
: "gccdump";
1699 /* Other front-end initialization. */
1700 input_location
= BUILTINS_LOCATION
;
1701 if (lang_hooks
.init () == 0)
1703 input_location
= save_loc
;
1707 init_asm_output (name
);
1709 /* If stack usage information is desired, open the output file. */
1710 if (flag_stack_usage
)
1711 stack_usage_file
= open_auxiliary_file ("su");
1714 /* This creates various _DECL nodes, so needs to be called after the
1715 front end is initialized. */
1718 /* Do the target-specific parts of the initialization. */
1719 lang_dependent_init_target ();
1723 /* If dbx symbol table desired, initialize writing it and output the
1724 predefined types. */
1725 timevar_push (TV_SYMOUT
);
1727 /* Now we have the correct original filename, we can initialize
1729 (*debug_hooks
->init
) (name
);
1731 timevar_pop (TV_SYMOUT
);
1738 /* Reinitialize everything when target parameters, such as register usage,
1741 target_reinit (void)
1743 struct rtl_data saved_x_rtl
;
1744 rtx
*saved_regno_reg_rtx
;
1746 /* Save *crtl and regno_reg_rtx around the reinitialization
1747 to allow target_reinit being called even after prepare_function_start. */
1748 saved_regno_reg_rtx
= regno_reg_rtx
;
1749 if (saved_regno_reg_rtx
)
1751 saved_x_rtl
= *crtl
;
1752 memset (crtl
, '\0', sizeof (*crtl
));
1753 regno_reg_rtx
= NULL
;
1756 /* Reinitialize RTL backend. */
1757 backend_init_target ();
1759 /* Reinitialize lang-dependent parts. */
1760 lang_dependent_init_target ();
1762 /* And restore it at the end, as free_after_compilation from
1763 expand_dummy_function_end clears it. */
1764 if (saved_regno_reg_rtx
)
1766 *crtl
= saved_x_rtl
;
1767 regno_reg_rtx
= saved_regno_reg_rtx
;
1768 saved_regno_reg_rtx
= NULL
;
1773 dump_memory_report (bool final
)
1775 dump_line_table_statistics ();
1776 ggc_print_statistics ();
1777 stringpool_statistics ();
1778 dump_tree_statistics ();
1779 dump_gimple_statistics ();
1780 dump_rtx_statistics ();
1781 dump_alloc_pool_statistics ();
1782 dump_bitmap_statistics ();
1783 dump_vec_loc_statistics ();
1784 dump_ggc_loc_statistics (final
);
1785 dump_alias_stats (stderr
);
1786 dump_pta_stats (stderr
);
1789 /* Clean up: close opened files, etc. */
1792 finalize (bool no_backend
)
1794 /* Close the dump files. */
1795 if (flag_gen_aux_info
)
1797 fclose (aux_info_file
);
1799 unlink (aux_info_file_name
);
1802 /* Close non-debugging input and output files. Take special care to note
1803 whether fclose returns an error, since the pages might still be on the
1804 buffer chain while the file is open. */
1808 if (ferror (asm_out_file
) != 0)
1809 fatal_error ("error writing to %s: %m", asm_file_name
);
1810 if (fclose (asm_out_file
) != 0)
1811 fatal_error ("error closing %s: %m", asm_file_name
);
1814 if (stack_usage_file
)
1815 fclose (stack_usage_file
);
1821 finish_optimization_passes ();
1827 dump_memory_report (true);
1830 dump_profile_report ();
1832 /* Language-specific end of compilation actions. */
1833 lang_hooks
.finish ();
1836 /* Initialize the compiler, and compile the input file. */
1840 /* Initialize timing first. The C front ends read the main file in
1841 the post_options hook, and C++ does file timings. */
1842 if (time_report
|| !quiet_flag
|| flag_detailed_statistics
)
1844 timevar_start (TV_TOTAL
);
1848 /* Don't do any more if an error has already occurred. */
1851 timevar_start (TV_PHASE_SETUP
);
1853 /* This must be run always, because it is needed to compute the FP
1854 predefined macros, such as __LDBL_MAX__, for targets using non
1855 default FP formats. */
1856 init_adjust_machine_modes ();
1858 /* Set up the back-end if requested. */
1862 /* Language-dependent initialization. Returns true on success. */
1863 if (lang_dependent_init (main_input_filename
))
1865 /* Initialize yet another pass. */
1867 ggc_protect_identifiers
= true;
1870 init_final (main_input_filename
);
1871 coverage_init (aux_base_name
);
1873 invoke_plugin_callbacks (PLUGIN_START_UNIT
, NULL
);
1875 timevar_stop (TV_PHASE_SETUP
);
1881 timevar_stop (TV_PHASE_SETUP
);
1884 timevar_start (TV_PHASE_FINALIZE
);
1886 finalize (no_backend
);
1888 timevar_stop (TV_PHASE_FINALIZE
);
1891 /* Stop timing and print the times. */
1892 timevar_stop (TV_TOTAL
);
1893 timevar_print (stderr
);
1896 /* Entry point of cc1, cc1plus, jc1, f771, etc.
1897 Exit code is FATAL_EXIT_CODE if can't open files or if there were
1898 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
1900 It is not safe to call this function more than once. */
1903 toplev_main (int argc
, char **argv
)
1905 /* Parsing and gimplification sometimes need quite large stack.
1906 Increase stack size limits if possible. */
1907 stack_limit_increase (64 * 1024 * 1024);
1909 expandargv (&argc
, &argv
);
1911 /* Initialization of GCC's environment, and diagnostics. */
1912 general_init (argv
[0]);
1914 /* One-off initialization of options that does not need to be
1915 repeated when options are added for particular functions. */
1916 init_options_once ();
1918 /* Initialize global options structures; this must be repeated for
1919 each structure used for parsing options. */
1920 init_options_struct (&global_options
, &global_options_set
);
1921 lang_hooks
.init_options_struct (&global_options
);
1923 /* Convert the options to an array. */
1924 decode_cmdline_options_to_array_default_mask (argc
,
1925 CONST_CAST2 (const char **,
1927 &save_decoded_options
,
1928 &save_decoded_options_count
);
1930 /* Perform language-specific options initialization. */
1931 lang_hooks
.init_options (save_decoded_options_count
, save_decoded_options
);
1933 /* Parse the options and do minimal processing; basically just
1934 enough to default flags appropriately. */
1935 decode_options (&global_options
, &global_options_set
,
1936 save_decoded_options
, save_decoded_options_count
,
1937 UNKNOWN_LOCATION
, global_dc
);
1939 handle_common_deferred_options ();
1943 initialize_plugins ();
1946 print_version (stderr
, "");
1949 print_plugins_help (stderr
, "");
1951 /* Exit early if we can (e.g. -help). */
1952 if (!exit_after_options
)
1955 if (warningcount
|| errorcount
|| werrorcount
)
1956 print_ignored_options ();
1957 diagnostic_finish (global_dc
);
1959 /* Invoke registered plugin callbacks if any. */
1960 invoke_plugin_callbacks (PLUGIN_FINISH
, NULL
);
1962 finalize_plugins ();
1963 location_adhoc_data_fini (line_table
);
1964 if (seen_error () || werrorcount
)
1965 return (FATAL_EXIT_CODE
);
1967 return (SUCCESS_EXIT_CODE
);