1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* This is the top level of cc1/c++.
23 It parses command args, opens files, invokes the various passes
24 in the proper order, and counts the time used by each.
25 Error messages and low-level interface to malloc also handled here. */
29 #include "coretypes.h"
34 #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */
39 #include "insn-attr.h"
40 #include "insn-config.h"
41 #include "insn-flags.h"
42 #include "hard-reg-set.h"
49 #include "basic-block.h"
55 #include "diagnostic.h"
56 #include "tree-diagnostic.h"
57 #include "tree-pretty-print.h"
61 #include "dwarf2asm.h"
62 #include "integrate.h"
65 #include "common/common-target.h"
66 #include "langhooks.h"
67 #include "cfglayout.h"
69 #include "hosthooks.h"
72 #include "opts-diagnostic.h"
74 #include "value-prof.h"
75 #include "alloc-pool.h"
76 #include "tree-mudflap.h"
78 #include "tree-ssa-alias.h"
81 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
82 #include "dwarf2out.h"
85 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
89 #ifdef SDB_DEBUGGING_INFO
93 #ifdef XCOFF_DEBUGGING_INFO
94 #include "xcoffout.h" /* Needed for external data
95 declarations for e.g. AIX 4.x. */
98 static void general_init (const char *);
99 static void do_compile (void);
100 static void process_options (void);
101 static void backend_init (void);
102 static int lang_dependent_init (const char *);
103 static void init_asm_output (const char *);
104 static void finalize (bool);
106 static void crash_signal (int) ATTRIBUTE_NORETURN
;
107 static void compile_file (void);
109 /* True if we don't need a backend (e.g. preprocessing only). */
110 static bool no_backend
;
112 /* Length of line when printing switch values. */
115 /* Decoded options, and number of such options. */
116 struct cl_decoded_option
*save_decoded_options
;
117 unsigned int save_decoded_options_count
;
119 /* Used to enable -fvar-tracking, -fweb and -frename-registers according
120 to optimize in process_options (). */
121 #define AUTODETECT_VALUE 2
123 /* Debug hooks - dependent upon command line options. */
125 const struct gcc_debug_hooks
*debug_hooks
;
127 /* The FUNCTION_DECL for the function currently being compiled,
128 or 0 if between functions. */
129 tree current_function_decl
;
131 /* Set to the FUNC_BEGIN label of the current function, or NULL
133 const char * current_function_func_begin_label
;
135 /* A random sequence of characters, unless overridden by user. */
136 static const char *flag_random_seed
;
138 /* A local time stamp derived from the time of compilation. It will be
139 zero if the system cannot provide a time. It will be -1u, if the
140 user has specified a particular random seed. */
143 /* Random number for this compilation */
144 HOST_WIDE_INT random_seed
;
148 /* Nonzero means make permerror produce warnings instead of errors. */
150 int flag_permissive
= 0;
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. */
161 /* True if the user has tagged the function with the 'section'
164 bool user_defined_section_attribute
= false;
166 struct target_flag_state default_target_flag_state
;
167 #if SWITCHABLE_TARGET
168 struct target_flag_state
*this_target_flag_state
= &default_target_flag_state
;
170 #define this_target_flag_state (&default_target_flag_state)
173 /* The user symbol prefix after having resolved same. */
174 const char *user_label_prefix
;
176 /* Output files for assembler code (real compiler output)
177 and debugging dumps. */
181 FILE *stack_usage_file
= NULL
;
182 FILE *dump_file
= NULL
;
183 const char *dump_file_name
;
185 /* The current working directory of a translation. It's generally the
186 directory from which compilation was initiated, but a preprocessed
187 file may specify the original directory in which it was
190 static const char *src_pwd
;
192 /* Initialize src_pwd with the given string, and return true. If it
193 was already initialized, return false. As a special case, it may
194 be called with a NULL argument to test whether src_pwd has NOT been
198 set_src_pwd (const char *pwd
)
202 if (strcmp (src_pwd
, pwd
) == 0)
208 src_pwd
= xstrdup (pwd
);
212 /* Return the directory from which the translation unit was initiated,
213 in case set_src_pwd() was not called before to assign it a
229 /* Called when the start of a function definition is parsed,
230 this function prints on stderr the name of the function. */
232 announce_function (tree decl
)
236 if (rtl_dump_and_exit
)
237 fprintf (stderr
, "%s ",
238 identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl
))));
240 fprintf (stderr
, " %s",
241 identifier_to_locale (lang_hooks
.decl_printable_name (decl
, 2)));
243 pp_needs_newline (global_dc
->printer
) = true;
244 diagnostic_set_last_function (global_dc
, (diagnostic_info
*) NULL
);
248 /* Initialize local_tick with a random number or -1 if
249 flag_random_seed is set. */
252 init_local_tick (void)
254 if (!flag_random_seed
)
256 /* Try urandom first. Time of day is too likely to collide.
257 In case of any error we just use the local tick. */
259 int fd
= open ("/dev/urandom", O_RDONLY
);
262 read (fd
, &random_seed
, sizeof (random_seed
));
266 /* Now get the tick anyways */
267 #ifdef HAVE_GETTIMEOFDAY
271 gettimeofday (&tv
, NULL
);
272 local_tick
= tv
.tv_sec
* 1000 + tv
.tv_usec
/ 1000;
276 time_t now
= time (NULL
);
278 if (now
!= (time_t)-1)
279 local_tick
= (unsigned) now
;
287 /* Set up a default flag_random_seed and local_tick, unless the user
288 already specified one. Must be called after init_local_tick. */
291 init_random_seed (void)
293 if (flag_random_seed
)
297 /* When the driver passed in a hex number don't crc it again */
298 random_seed
= strtoul (flag_random_seed
, &endp
, 0);
299 if (!(endp
> flag_random_seed
&& *endp
== 0))
300 random_seed
= crc32_string (0, flag_random_seed
);
302 else if (!random_seed
)
303 random_seed
= local_tick
^ getpid (); /* Old racey fallback method */
306 /* Obtain the random_seed. Unless NOINIT, initialize it if
307 it's not provided in the command line. */
310 get_random_seed (bool noinit
)
312 if (!flag_random_seed
&& !noinit
)
317 /* Modify the random_seed string to VAL. Return its previous
321 set_random_seed (const char *val
)
323 const char *old
= flag_random_seed
;
324 flag_random_seed
= val
;
328 /* Handler for fatal signals, such as SIGSEGV. These are transformed
329 into ICE messages, which is much more user friendly. In case the
330 error printer crashes, reset the signal to prevent infinite recursion. */
333 crash_signal (int signo
)
335 signal (signo
, SIG_DFL
);
337 /* If we crashed while processing an ASM statement, then be a little more
338 graceful. It's most likely the user's fault. */
339 if (this_is_asm_operands
)
341 output_operand_lossage ("unrecoverable error");
342 exit (FATAL_EXIT_CODE
);
345 internal_error ("%s", strsignal (signo
));
348 /* A subroutine of wrapup_global_declarations. We've come to the end of
349 the compilation unit. All deferred variables should be undeferred,
350 and all incomplete decls should be finalized. */
353 wrapup_global_declaration_1 (tree decl
)
355 /* We're not deferring this any longer. Assignment is conditional to
356 avoid needlessly dirtying PCH pages. */
357 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_WITH_VIS
)
358 && DECL_DEFER_OUTPUT (decl
) != 0)
359 DECL_DEFER_OUTPUT (decl
) = 0;
361 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_SIZE (decl
) == 0)
362 lang_hooks
.finish_incomplete_decl (decl
);
365 /* A subroutine of wrapup_global_declarations. Decide whether or not DECL
366 needs to be output. Return true if it is output. */
369 wrapup_global_declaration_2 (tree decl
)
371 if (TREE_ASM_WRITTEN (decl
) || DECL_EXTERNAL (decl
))
374 /* Don't write out static consts, unless we still need them.
376 We also keep static consts if not optimizing (for debugging),
377 unless the user specified -fno-keep-static-consts.
378 ??? They might be better written into the debug information.
379 This is possible when using DWARF.
381 A language processor that wants static constants to be always
382 written out (even if it is not used) is responsible for
383 calling rest_of_decl_compilation itself. E.g. the C front-end
384 calls rest_of_decl_compilation from finish_decl.
385 One motivation for this is that is conventional in some
386 environments to write things like:
387 static const char rcsid[] = "... version string ...";
388 intending to force the string to be in the executable.
390 A language processor that would prefer to have unneeded
391 static constants "optimized away" would just defer writing
392 them out until here. E.g. C++ does this, because static
393 constants are often defined in header files.
395 ??? A tempting alternative (for both C and C++) would be
396 to force a constant to be written if and only if it is
397 defined in a main file, as opposed to an include file. */
399 if (TREE_CODE (decl
) == VAR_DECL
&& TREE_STATIC (decl
))
401 struct varpool_node
*node
;
403 node
= varpool_get_node (decl
);
405 if (!node
&& flag_ltrans
)
407 else if (node
&& node
->finalized
)
409 else if (node
&& node
->alias
)
411 else if (!cgraph_global_info_ready
413 || TREE_USED (DECL_ASSEMBLER_NAME (decl
))))
415 else if (node
&& node
->analyzed
)
417 else if (DECL_COMDAT (decl
))
419 else if (TREE_READONLY (decl
) && !TREE_PUBLIC (decl
)
420 && (optimize
|| !flag_keep_static_consts
421 || DECL_ARTIFICIAL (decl
)))
426 rest_of_decl_compilation (decl
, 1, 1);
434 /* Do any final processing required for the declarations in VEC, of
435 which there are LEN. We write out inline functions and variables
436 that have been deferred until this point, but which are required.
437 Returns nonzero if anything was put out. */
440 wrapup_global_declarations (tree
*vec
, int len
)
442 bool reconsider
, output_something
= false;
445 for (i
= 0; i
< len
; i
++)
446 wrapup_global_declaration_1 (vec
[i
]);
448 /* Now emit any global variables or functions that we have been
449 putting off. We need to loop in case one of the things emitted
450 here references another one which comes earlier in the list. */
454 for (i
= 0; i
< len
; i
++)
455 reconsider
|= wrapup_global_declaration_2 (vec
[i
]);
457 output_something
= true;
461 return output_something
;
464 /* A subroutine of check_global_declarations. Issue appropriate warnings
465 for the global declaration DECL. */
468 check_global_declaration_1 (tree decl
)
470 /* Warn about any function declared static but not defined. We don't
471 warn about variables, because many programs have static variables
472 that exist only to get some text into the object file. */
473 if (TREE_CODE (decl
) == FUNCTION_DECL
474 && DECL_INITIAL (decl
) == 0
475 && DECL_EXTERNAL (decl
)
476 && ! DECL_ARTIFICIAL (decl
)
477 && ! TREE_NO_WARNING (decl
)
478 && ! TREE_PUBLIC (decl
)
479 && (warn_unused_function
480 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
))))
482 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl
)))
483 pedwarn (input_location
, 0, "%q+F used but never defined", decl
);
485 warning (OPT_Wunused_function
, "%q+F declared %<static%> but never defined", decl
);
486 /* This symbol is effectively an "extern" declaration now. */
487 TREE_PUBLIC (decl
) = 1;
490 /* Warn about static fns or vars defined but not used. */
491 if (((warn_unused_function
&& TREE_CODE (decl
) == FUNCTION_DECL
)
492 /* We don't warn about "static const" variables because the
493 "rcs_id" idiom uses that construction. */
494 || (warn_unused_variable
495 && TREE_CODE (decl
) == VAR_DECL
&& ! TREE_READONLY (decl
)))
496 && ! DECL_IN_SYSTEM_HEADER (decl
)
497 && ! TREE_USED (decl
)
498 /* The TREE_USED bit for file-scope decls is kept in the identifier,
499 to handle multiple external decls in different scopes. */
500 && ! (DECL_NAME (decl
) && TREE_USED (DECL_NAME (decl
)))
501 && ! DECL_EXTERNAL (decl
)
502 && ! TREE_PUBLIC (decl
)
503 /* A volatile variable might be used in some non-obvious way. */
504 && ! TREE_THIS_VOLATILE (decl
)
505 /* Global register variables must be declared to reserve them. */
506 && ! (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
507 /* Otherwise, ask the language. */
508 && lang_hooks
.decls
.warn_unused_global (decl
))
509 warning ((TREE_CODE (decl
) == FUNCTION_DECL
)
510 ? OPT_Wunused_function
511 : OPT_Wunused_variable
,
512 "%q+D defined but not used", decl
);
515 /* Issue appropriate warnings for the global declarations in VEC (of
516 which there are LEN). */
519 check_global_declarations (tree
*vec
, int len
)
523 for (i
= 0; i
< len
; i
++)
524 check_global_declaration_1 (vec
[i
]);
527 /* Emit debugging information for all global declarations in VEC. */
530 emit_debug_global_declarations (tree
*vec
, int len
)
534 /* Avoid confusing the debug information machinery when there are errors. */
538 timevar_push (TV_SYMOUT
);
539 for (i
= 0; i
< len
; i
++)
540 debug_hooks
->global_decl (vec
[i
]);
541 timevar_pop (TV_SYMOUT
);
544 /* Compile an entire translation unit. Write a file of assembly
545 output and various debugging dumps. */
550 timevar_start (TV_PHASE_PARSING
);
551 timevar_push (TV_PARSE_GLOBAL
);
553 /* Call the parser, which parses the entire file (calling
554 rest_of_compilation for each function). */
555 lang_hooks
.parse_file ();
557 timevar_pop (TV_PARSE_GLOBAL
);
558 timevar_stop (TV_PHASE_PARSING
);
560 /* Compilation is now finished except for writing
561 what's left of the symbol table output. */
563 if (flag_syntax_only
|| flag_wpa
)
566 timevar_start (TV_PHASE_GENERATE
);
568 ggc_protect_identifiers
= false;
570 /* This must also call finalize_compilation_unit. */
571 lang_hooks
.decls
.final_write_globals ();
575 timevar_stop (TV_PHASE_GENERATE
);
579 /* Compilation unit is finalized. When producing non-fat LTO object, we are
580 basically finished. */
581 if (in_lto_p
|| !flag_lto
|| flag_fat_lto_objects
)
583 varpool_output_variables ();
586 /* Likewise for mudflap static object registrations. */
588 mudflap_finish_file ();
590 output_shared_constant_pool ();
591 output_object_blocks ();
592 finish_tm_clone_pairs ();
594 /* Write out any pending weak symbol declarations. */
597 /* This must be at the end before unwind and debug info.
598 Some target ports emit PIC setup thunks here. */
599 targetm
.asm_out
.code_end ();
601 /* Do dbx symbols. */
602 timevar_push (TV_SYMOUT
);
604 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
605 if (dwarf2out_do_frame ())
606 dwarf2out_frame_finish ();
609 (*debug_hooks
->finish
) (main_input_filename
);
610 timevar_pop (TV_SYMOUT
);
612 /* Output some stuff at end of file if nec. */
614 dw2_output_indirect_constants ();
616 /* Flush any pending external directives. */
617 process_pending_assemble_externals ();
620 /* Emit LTO marker if LTO info has been previously emitted. This is
621 used by collect2 to determine whether an object file contains IL.
622 We used to emit an undefined reference here, but this produces
623 link errors if an object file with IL is stored into a shared
624 library without invoking lto1. */
625 if (flag_generate_lto
)
627 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
628 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, NULL_TREE
,
630 (unsigned HOST_WIDE_INT
) 1, 8);
631 #elif defined ASM_OUTPUT_ALIGNED_COMMON
632 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, "__gnu_lto_v1",
633 (unsigned HOST_WIDE_INT
) 1, 8);
635 ASM_OUTPUT_COMMON (asm_out_file
, "__gnu_lto_v1",
636 (unsigned HOST_WIDE_INT
) 1,
637 (unsigned HOST_WIDE_INT
) 1);
639 /* Let linker plugin know that this is a slim object and must be LTOed
640 even when user did not ask for it. */
641 if (!flag_fat_lto_objects
)
643 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
644 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file
, NULL_TREE
,
646 (unsigned HOST_WIDE_INT
) 1, 8);
647 #elif defined ASM_OUTPUT_ALIGNED_COMMON
648 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file
, "__gnu_lto_slim",
649 (unsigned HOST_WIDE_INT
) 1, 8);
651 ASM_OUTPUT_COMMON (asm_out_file
, "__gnu_lto_slim",
652 (unsigned HOST_WIDE_INT
) 1,
653 (unsigned HOST_WIDE_INT
) 1);
658 /* Attach a special .ident directive to the end of the file to identify
659 the version of GCC which compiled this code. The format of the .ident
660 string is patterned after the ones produced by native SVR4 compilers. */
664 const char *pkg_version
= "(GNU) ";
666 if (strcmp ("(GCC) ", pkgversion_string
))
667 pkg_version
= pkgversion_string
;
668 fprintf (asm_out_file
, "%s\"GCC: %s%s\"\n",
669 IDENT_ASM_OP
, pkg_version
, version_string
);
673 /* Invoke registered plugin callbacks. */
674 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT
, NULL
);
676 /* This must be at the end. Some target ports emit end of file directives
677 into the assembly file here, and hence we can not output anything to the
678 assembly file after this point. */
679 targetm
.asm_out
.file_end ();
681 timevar_stop (TV_PHASE_GENERATE
);
684 /* Print version information to FILE.
685 Each line begins with INDENT (for the case where FILE is the
686 assembler output file). */
689 print_version (FILE *file
, const char *indent
)
691 static const char fmt1
[] =
693 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
695 N_("%s%s%s %sversion %s (%s) compiled by CC, ")
698 static const char fmt2
[] =
699 N_("GMP version %s, MPFR version %s, MPC version %s\n");
700 static const char fmt3
[] =
701 N_("%s%swarning: %s header version %s differs from library version %s.\n");
702 static const char fmt4
[] =
703 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
705 #define __VERSION__ "[?]"
708 file
== stderr
? _(fmt1
) : fmt1
,
709 indent
, *indent
!= 0 ? " " : "",
710 lang_hooks
.name
, pkgversion_string
, version_string
, TARGET_NAME
,
711 indent
, __VERSION__
);
713 /* We need to stringify the GMP macro values. Ugh, gmp_version has
714 two string formats, "i.j.k" and "i.j" when k is zero. As of
715 gmp-4.3.0, GMP always uses the 3 number format. */
716 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
717 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
718 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
719 #define GCC_GMP_VERSION \
720 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
721 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
722 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
723 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
725 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
726 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
727 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
730 file
== stderr
? _(fmt2
) : fmt2
,
731 GCC_GMP_STRINGIFY_VERSION
, MPFR_VERSION_STRING
, MPC_VERSION_STRING
);
732 if (strcmp (GCC_GMP_STRINGIFY_VERSION
, gmp_version
))
734 file
== stderr
? _(fmt3
) : fmt3
,
735 indent
, *indent
!= 0 ? " " : "",
736 "GMP", GCC_GMP_STRINGIFY_VERSION
, gmp_version
);
737 if (strcmp (MPFR_VERSION_STRING
, mpfr_get_version ()))
739 file
== stderr
? _(fmt3
) : fmt3
,
740 indent
, *indent
!= 0 ? " " : "",
741 "MPFR", MPFR_VERSION_STRING
, mpfr_get_version ());
742 if (strcmp (MPC_VERSION_STRING
, mpc_get_version ()))
744 file
== stderr
? _(fmt3
) : fmt3
,
745 indent
, *indent
!= 0 ? " " : "",
746 "MPC", MPC_VERSION_STRING
, mpc_get_version ());
748 file
== stderr
? _(fmt4
) : fmt4
,
749 indent
, *indent
!= 0 ? " " : "",
750 PARAM_VALUE (GGC_MIN_EXPAND
), PARAM_VALUE (GGC_MIN_HEAPSIZE
));
752 print_plugins_versions (file
, indent
);
756 print_to_asm_out_file (print_switch_type type
, const char * text
)
758 bool prepend_sep
= true;
762 case SWITCH_TYPE_LINE_END
:
763 putc ('\n', asm_out_file
);
766 case SWITCH_TYPE_LINE_START
:
767 fputs (ASM_COMMENT_START
, asm_out_file
);
768 return strlen (ASM_COMMENT_START
);
770 case SWITCH_TYPE_DESCRIPTIVE
:
771 if (ASM_COMMENT_START
[0] == 0)
774 case SWITCH_TYPE_PASSED
:
775 case SWITCH_TYPE_ENABLED
:
777 fputc (' ', asm_out_file
);
778 fputs (text
, asm_out_file
);
779 /* No need to return the length here as
780 print_single_switch has already done it. */
789 print_to_stderr (print_switch_type type
, const char * text
)
793 case SWITCH_TYPE_LINE_END
:
797 case SWITCH_TYPE_LINE_START
:
800 case SWITCH_TYPE_PASSED
:
801 case SWITCH_TYPE_ENABLED
:
805 case SWITCH_TYPE_DESCRIPTIVE
:
806 fputs (text
, stderr
);
807 /* No need to return the length here as
808 print_single_switch has already done it. */
816 /* Print an option value and return the adjusted position in the line.
817 ??? print_fn doesn't handle errors, eg disk full; presumably other
818 code will catch a disk full though. */
821 print_single_switch (print_switch_fn_type print_fn
,
823 print_switch_type type
,
826 /* The ultrix fprintf returns 0 on success, so compute the result
827 we want here since we need it for the following test. The +1
828 is for the separator character that will probably be emitted. */
829 int len
= strlen (text
) + 1;
832 && pos
+ len
> MAX_LINE
)
834 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
839 pos
+= print_fn (SWITCH_TYPE_LINE_START
, NULL
);
841 print_fn (type
, text
);
845 /* Print active target switches using PRINT_FN.
846 POS is the current cursor position and MAX is the size of a "line".
847 Each line begins with INDENT and ends with TERM.
848 Each switch is separated from the next by SEP. */
851 print_switch_values (print_switch_fn_type print_fn
)
856 /* Fill in the -frandom-seed option, if the user didn't pass it, so
857 that it can be printed below. This helps reproducibility. */
858 if (!flag_random_seed
)
861 /* Print the options as passed. */
862 pos
= print_single_switch (print_fn
, pos
,
863 SWITCH_TYPE_DESCRIPTIVE
, _("options passed: "));
865 for (j
= 1; j
< save_decoded_options_count
; j
++)
867 switch (save_decoded_options
[j
].opt_index
)
880 pos
= print_single_switch (print_fn
, pos
, SWITCH_TYPE_PASSED
,
881 save_decoded_options
[j
].orig_option_with_args_text
);
885 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
887 /* Print the -f and -m options that have been enabled.
888 We don't handle language specific options but printing argv
890 pos
= print_single_switch (print_fn
, 0,
891 SWITCH_TYPE_DESCRIPTIVE
, _("options enabled: "));
893 for (j
= 0; j
< cl_options_count
; j
++)
894 if (cl_options
[j
].cl_report
895 && option_enabled (j
, &global_options
) > 0)
896 pos
= print_single_switch (print_fn
, pos
,
897 SWITCH_TYPE_ENABLED
, cl_options
[j
].opt_text
);
899 print_fn (SWITCH_TYPE_LINE_END
, NULL
);
902 /* Open assembly code output file. Do this even if -fsyntax-only is
903 on, because then the driver will have provided the name of a
904 temporary file or bit bucket for us. NAME is the file specified on
905 the command line, possibly NULL. */
907 init_asm_output (const char *name
)
909 if (name
== NULL
&& asm_file_name
== 0)
910 asm_out_file
= stdout
;
913 if (asm_file_name
== 0)
915 int len
= strlen (dump_base_name
);
916 char *dumpname
= XNEWVEC (char, len
+ 6);
918 memcpy (dumpname
, dump_base_name
, len
+ 1);
919 strip_off_ending (dumpname
, len
);
920 strcat (dumpname
, ".s");
921 asm_file_name
= dumpname
;
923 if (!strcmp (asm_file_name
, "-"))
924 asm_out_file
= stdout
;
926 asm_out_file
= fopen (asm_file_name
, "w+b");
927 if (asm_out_file
== 0)
928 fatal_error ("can%'t open %s for writing: %m", asm_file_name
);
931 if (!flag_syntax_only
)
933 targetm
.asm_out
.file_start ();
935 if (flag_record_gcc_switches
)
937 if (targetm
.asm_out
.record_gcc_switches
)
939 /* Let the target know that we are about to start recording. */
940 targetm
.asm_out
.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE
,
942 /* Now record the switches. */
943 print_switch_values (targetm
.asm_out
.record_gcc_switches
);
944 /* Let the target know that the recording is over. */
945 targetm
.asm_out
.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE
,
949 inform (input_location
, "-frecord-gcc-switches is not supported by the current target");
952 if (flag_verbose_asm
)
954 /* Print the list of switches in effect
955 into the assembler file as comments. */
956 print_version (asm_out_file
, ASM_COMMENT_START
);
957 print_switch_values (print_to_asm_out_file
);
958 putc ('\n', asm_out_file
);
963 /* A helper function; used as the reallocator function for cpp's line
966 realloc_for_line_map (void *ptr
, size_t len
)
968 return GGC_RESIZEVAR (void, ptr
, len
);
971 /* A helper function: used as the allocator function for
972 identifier_to_locale. */
974 alloc_for_identifier_to_locale (size_t len
)
976 return ggc_alloc_atomic (len
);
979 /* Output stack usage information. */
981 output_stack_usage (void)
983 static bool warning_issued
= false;
984 enum stack_usage_kind_type
{ STATIC
= 0, DYNAMIC
, DYNAMIC_BOUNDED
};
985 const char *stack_usage_kind_str
[] = {
990 HOST_WIDE_INT stack_usage
= current_function_static_stack_size
;
991 enum stack_usage_kind_type stack_usage_kind
;
997 warning (0, "stack usage computation not supported for this target");
998 warning_issued
= true;
1003 stack_usage_kind
= STATIC
;
1005 /* Add the maximum amount of space pushed onto the stack. */
1006 if (current_function_pushed_stack_size
> 0)
1008 stack_usage
+= current_function_pushed_stack_size
;
1009 stack_usage_kind
= DYNAMIC_BOUNDED
;
1012 /* Now on to the tricky part: dynamic stack allocation. */
1013 if (current_function_allocates_dynamic_stack_space
)
1015 if (current_function_has_unbounded_dynamic_stack_size
)
1016 stack_usage_kind
= DYNAMIC
;
1018 stack_usage_kind
= DYNAMIC_BOUNDED
;
1020 /* Add the size even in the unbounded case, this can't hurt. */
1021 stack_usage
+= current_function_dynamic_stack_size
;
1024 if (flag_stack_usage
)
1026 expanded_location loc
1027 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
1028 const char *raw_id
, *id
;
1030 /* Strip the scope prefix if any. */
1031 raw_id
= lang_hooks
.decl_printable_name (current_function_decl
, 2);
1032 id
= strrchr (raw_id
, '.');
1038 fprintf (stack_usage_file
,
1039 "%s:%d:%d:%s\t"HOST_WIDE_INT_PRINT_DEC
"\t%s\n",
1040 lbasename (loc
.file
),
1045 stack_usage_kind_str
[stack_usage_kind
]);
1048 if (warn_stack_usage
>= 0)
1050 if (stack_usage_kind
== DYNAMIC
)
1051 warning (OPT_Wstack_usage_
, "stack usage might be unbounded");
1052 else if (stack_usage
> warn_stack_usage
)
1054 if (stack_usage_kind
== DYNAMIC_BOUNDED
)
1055 warning (OPT_Wstack_usage_
, "stack usage might be %wd bytes",
1058 warning (OPT_Wstack_usage_
, "stack usage is %wd bytes",
1064 /* Open an auxiliary output file. */
1066 open_auxiliary_file (const char *ext
)
1071 filename
= concat (aux_base_name
, ".", ext
, NULL
);
1072 file
= fopen (filename
, "w");
1074 fatal_error ("can%'t open %s for writing: %m", filename
);
1079 /* Initialization of the front end environment, before command line
1080 options are parsed. Signal handlers, internationalization etc.
1081 ARGV0 is main's argv[0]. */
1083 general_init (const char *argv0
)
1087 p
= argv0
+ strlen (argv0
);
1088 while (p
!= argv0
&& !IS_DIR_SEPARATOR (p
[-1]))
1092 xmalloc_set_program_name (progname
);
1096 /* Unlock the stdio streams. */
1097 unlock_std_streams ();
1099 gcc_init_libintl ();
1101 identifier_to_locale_alloc
= alloc_for_identifier_to_locale
;
1102 identifier_to_locale_free
= ggc_free
;
1104 /* Initialize the diagnostics reporting machinery, so option parsing
1105 can give warnings and errors. */
1106 diagnostic_initialize (global_dc
, N_OPTS
);
1107 /* Set a default printer. Language specific initializations will
1108 override it later. */
1109 tree_diagnostics_defaults (global_dc
);
1110 /* FIXME: This should probably be moved to C-family
1111 language-specific initializations. */
1112 /* By default print macro expansion contexts in the diagnostic
1113 finalizer -- for tokens resulting from macro expansion. */
1114 diagnostic_finalizer (global_dc
) = virt_loc_aware_diagnostic_finalizer
;
1116 global_dc
->show_caret
1117 = global_options_init
.x_flag_diagnostics_show_caret
;
1118 global_dc
->show_option_requested
1119 = global_options_init
.x_flag_diagnostics_show_option
;
1120 global_dc
->show_column
1121 = global_options_init
.x_flag_show_column
;
1122 global_dc
->internal_error
= plugins_internal_error_function
;
1123 global_dc
->option_enabled
= option_enabled
;
1124 global_dc
->option_state
= &global_options
;
1125 global_dc
->option_name
= option_name
;
1127 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1129 signal (SIGSEGV
, crash_signal
);
1132 signal (SIGILL
, crash_signal
);
1135 signal (SIGBUS
, crash_signal
);
1138 signal (SIGABRT
, crash_signal
);
1140 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1141 signal (SIGIOT
, crash_signal
);
1144 signal (SIGFPE
, crash_signal
);
1147 /* Other host-specific signal setup. */
1148 (*host_hooks
.extra_signals
)();
1150 /* Initialize the garbage-collector, string pools and tree type hash
1154 line_table
= ggc_alloc_line_maps ();
1155 linemap_init (line_table
);
1156 line_table
->reallocator
= realloc_for_line_map
;
1157 line_table
->round_alloc_size
= ggc_round_alloc_size
;
1160 /* Initialize register usage now so switches may override. */
1163 /* Register the language-independent parameters. */
1164 global_init_params ();
1166 /* This must be done after global_init_params but before argument
1168 init_ggc_heuristics();
1169 init_optimization_passes ();
1170 statistics_early_init ();
1174 /* Return true if the current target supports -fsection-anchors. */
1177 target_supports_section_anchors_p (void)
1179 if (targetm
.min_anchor_offset
== 0 && targetm
.max_anchor_offset
== 0)
1182 if (targetm
.asm_out
.output_anchor
== NULL
)
1188 /* Default the align_* variables to 1 if they're still unset, and
1189 set up the align_*_log variables. */
1191 init_alignments (void)
1193 if (align_loops
<= 0)
1195 if (align_loops_max_skip
> align_loops
)
1196 align_loops_max_skip
= align_loops
- 1;
1197 align_loops_log
= floor_log2 (align_loops
* 2 - 1);
1198 if (align_jumps
<= 0)
1200 if (align_jumps_max_skip
> align_jumps
)
1201 align_jumps_max_skip
= align_jumps
- 1;
1202 align_jumps_log
= floor_log2 (align_jumps
* 2 - 1);
1203 if (align_labels
<= 0)
1205 align_labels_log
= floor_log2 (align_labels
* 2 - 1);
1206 if (align_labels_max_skip
> align_labels
)
1207 align_labels_max_skip
= align_labels
- 1;
1208 if (align_functions
<= 0)
1209 align_functions
= 1;
1210 align_functions_log
= floor_log2 (align_functions
* 2 - 1);
1213 /* Process the options that have been parsed. */
1215 process_options (void)
1217 /* Just in case lang_hooks.post_options ends up calling a debug_hook.
1218 This can happen with incorrect pre-processed input. */
1219 debug_hooks
= &do_nothing_debug_hooks
;
1221 maximum_field_alignment
= initial_max_fld_align
* BITS_PER_UNIT
;
1223 /* Allow the front end to perform consistency checks and do further
1224 initialization based on the command line options. This hook also
1225 sets the original filename if appropriate (e.g. foo.i -> foo.c)
1226 so we can correctly initialize debug output. */
1227 no_backend
= lang_hooks
.post_options (&main_input_filename
);
1229 /* Some machines may reject certain combinations of options. */
1230 targetm
.target_option
.override ();
1232 /* Avoid any informative notes in the second run of -fcompare-debug. */
1233 if (flag_compare_debug
)
1234 diagnostic_inhibit_notes (global_dc
);
1236 if (flag_section_anchors
&& !target_supports_section_anchors_p ())
1238 warning (OPT_fsection_anchors
,
1239 "this target does not support %qs", "-fsection-anchors");
1240 flag_section_anchors
= 0;
1243 if (flag_short_enums
== 2)
1244 flag_short_enums
= targetm
.default_short_enums ();
1246 /* Set aux_base_name if not already set. */
1249 else if (main_input_filename
)
1251 char *name
= xstrdup (lbasename (main_input_filename
));
1253 strip_off_ending (name
, strlen (name
));
1254 aux_base_name
= name
;
1257 aux_base_name
= "gccaux";
1261 || flag_graphite_identity
1263 || flag_loop_interchange
1264 || flag_loop_strip_mine
1265 || flag_loop_parallelize_all
)
1266 sorry ("Graphite loop optimizations cannot be used (-fgraphite, "
1267 "-fgraphite-identity, -floop-block, "
1268 "-floop-interchange, -floop-strip-mine, -floop-parallelize-all, "
1269 "and -ftree-loop-linear)");
1272 if (flag_mudflap
&& flag_lto
)
1273 sorry ("mudflap cannot be used together with link-time optimization");
1275 /* One region RA really helps to decrease the code size. */
1276 if (flag_ira_region
== IRA_REGION_AUTODETECT
)
1278 = optimize_size
|| !optimize
? IRA_REGION_ONE
: IRA_REGION_MIXED
;
1280 if (flag_strict_volatile_bitfields
> 0 && !abi_version_at_least (2))
1282 warning (0, "-fstrict-volatile-bitfields disabled; "
1283 "it is incompatible with ABI versions < 2");
1284 flag_strict_volatile_bitfields
= 0;
1287 /* Unrolling all loops implies that standard loop unrolling must also
1289 if (flag_unroll_all_loops
)
1290 flag_unroll_loops
= 1;
1292 /* web and rename-registers help when run after loop unrolling. */
1293 if (flag_web
== AUTODETECT_VALUE
)
1294 flag_web
= flag_unroll_loops
|| flag_peel_loops
;
1296 if (flag_rename_registers
== AUTODETECT_VALUE
)
1297 flag_rename_registers
= flag_unroll_loops
|| flag_peel_loops
;
1299 if (flag_non_call_exceptions
)
1300 flag_asynchronous_unwind_tables
= 1;
1301 if (flag_asynchronous_unwind_tables
)
1302 flag_unwind_tables
= 1;
1304 if (flag_value_profile_transformations
)
1305 flag_profile_values
= 1;
1307 /* Warn about options that are not supported on this machine. */
1308 #ifndef INSN_SCHEDULING
1309 if (flag_schedule_insns
|| flag_schedule_insns_after_reload
)
1310 warning (0, "instruction scheduling not supported on this target machine");
1313 if (flag_delayed_branch
)
1314 warning (0, "this target machine does not have delayed branches");
1317 user_label_prefix
= USER_LABEL_PREFIX
;
1318 if (flag_leading_underscore
!= -1)
1320 /* If the default prefix is more complicated than "" or "_",
1321 issue a warning and ignore this option. */
1322 if (user_label_prefix
[0] == 0 ||
1323 (user_label_prefix
[0] == '_' && user_label_prefix
[1] == 0))
1325 user_label_prefix
= flag_leading_underscore
? "_" : "";
1328 warning (0, "-f%sleading-underscore not supported on this target machine",
1329 flag_leading_underscore
? "" : "no-");
1332 /* If we are in verbose mode, write out the version and maybe all the
1333 option flags in use. */
1336 print_version (stderr
, "");
1338 print_switch_values (print_to_stderr
);
1341 if (flag_syntax_only
)
1343 write_symbols
= NO_DEBUG
;
1349 if (debug_info_level
== DINFO_LEVEL_NONE
)
1351 debug_info_level
= DINFO_LEVEL_NORMAL
;
1353 if (write_symbols
== NO_DEBUG
)
1354 write_symbols
= PREFERRED_DEBUGGING_TYPE
;
1357 debug_info_level
= DINFO_LEVEL_NONE
;
1360 if (flag_dump_final_insns
&& !flag_syntax_only
&& !no_backend
)
1362 FILE *final_output
= fopen (flag_dump_final_insns
, "w");
1365 error ("could not open final insn dump file %qs: %m",
1366 flag_dump_final_insns
);
1367 flag_dump_final_insns
= NULL
;
1369 else if (fclose (final_output
))
1371 error ("could not close zeroed insn dump file %qs: %m",
1372 flag_dump_final_insns
);
1373 flag_dump_final_insns
= NULL
;
1377 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1379 if (debug_info_level
== DINFO_LEVEL_NONE
)
1380 write_symbols
= NO_DEBUG
;
1382 if (write_symbols
== NO_DEBUG
)
1384 #if defined(DBX_DEBUGGING_INFO)
1385 else if (write_symbols
== DBX_DEBUG
)
1386 debug_hooks
= &dbx_debug_hooks
;
1388 #if defined(XCOFF_DEBUGGING_INFO)
1389 else if (write_symbols
== XCOFF_DEBUG
)
1390 debug_hooks
= &xcoff_debug_hooks
;
1392 #ifdef SDB_DEBUGGING_INFO
1393 else if (write_symbols
== SDB_DEBUG
)
1394 debug_hooks
= &sdb_debug_hooks
;
1396 #ifdef DWARF2_DEBUGGING_INFO
1397 else if (write_symbols
== DWARF2_DEBUG
)
1398 debug_hooks
= &dwarf2_debug_hooks
;
1400 #ifdef VMS_DEBUGGING_INFO
1401 else if (write_symbols
== VMS_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
1402 debug_hooks
= &vmsdbg_debug_hooks
;
1405 error ("target system does not support the \"%s\" debug format",
1406 debug_type_names
[write_symbols
]);
1408 /* We know which debug output will be used so we can set flag_var_tracking
1409 and flag_var_tracking_uninit if the user has not specified them. */
1410 if (debug_info_level
< DINFO_LEVEL_NORMAL
1411 || debug_hooks
->var_location
== do_nothing_debug_hooks
.var_location
)
1413 if (flag_var_tracking
== 1
1414 || flag_var_tracking_uninit
== 1)
1416 if (debug_info_level
< DINFO_LEVEL_NORMAL
)
1417 warning (0, "variable tracking requested, but useless unless "
1418 "producing debug info");
1420 warning (0, "variable tracking requested, but not supported "
1421 "by this debug format");
1423 flag_var_tracking
= 0;
1424 flag_var_tracking_uninit
= 0;
1427 /* The debug hooks are used to implement -fdump-go-spec because it
1428 gives a simple and stable API for all the information we need to
1430 if (flag_dump_go_spec
!= NULL
)
1431 debug_hooks
= dump_go_spec_init (flag_dump_go_spec
, debug_hooks
);
1433 /* If the user specifically requested variable tracking with tagging
1434 uninitialized variables, we need to turn on variable tracking.
1435 (We already determined above that variable tracking is feasible.) */
1436 if (flag_var_tracking_uninit
)
1437 flag_var_tracking
= 1;
1439 if (flag_var_tracking
== AUTODETECT_VALUE
)
1440 flag_var_tracking
= optimize
>= 1;
1442 if (flag_var_tracking_assignments
== AUTODETECT_VALUE
)
1443 flag_var_tracking_assignments
= flag_var_tracking
1444 && !(flag_selective_scheduling
|| flag_selective_scheduling2
);
1446 if (flag_var_tracking_assignments_toggle
)
1447 flag_var_tracking_assignments
= !flag_var_tracking_assignments
;
1449 if (flag_var_tracking_assignments
&& !flag_var_tracking
)
1450 flag_var_tracking
= flag_var_tracking_assignments
= -1;
1452 if (flag_var_tracking_assignments
1453 && (flag_selective_scheduling
|| flag_selective_scheduling2
))
1454 warning (0, "var-tracking-assignments changes selective scheduling");
1456 if (flag_tree_cselim
== AUTODETECT_VALUE
)
1457 #ifdef HAVE_conditional_move
1458 flag_tree_cselim
= 1;
1460 flag_tree_cselim
= 0;
1463 /* If auxiliary info generation is desired, open the output file.
1464 This goes in the same directory as the source file--unlike
1465 all the other output files. */
1466 if (flag_gen_aux_info
)
1468 aux_info_file
= fopen (aux_info_file_name
, "w");
1469 if (aux_info_file
== 0)
1470 fatal_error ("can%'t open %s: %m", aux_info_file_name
);
1473 if (!targetm_common
.have_named_sections
)
1475 if (flag_function_sections
)
1477 warning (0, "-ffunction-sections not supported for this target");
1478 flag_function_sections
= 0;
1480 if (flag_data_sections
)
1482 warning (0, "-fdata-sections not supported for this target");
1483 flag_data_sections
= 0;
1487 if (flag_function_sections
&& profile_flag
)
1489 warning (0, "-ffunction-sections disabled; it makes profiling impossible");
1490 flag_function_sections
= 0;
1493 #ifndef HAVE_prefetch
1494 if (flag_prefetch_loop_arrays
> 0)
1496 warning (0, "-fprefetch-loop-arrays not supported for this target");
1497 flag_prefetch_loop_arrays
= 0;
1500 if (flag_prefetch_loop_arrays
> 0 && !HAVE_prefetch
)
1502 warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)");
1503 flag_prefetch_loop_arrays
= 0;
1507 /* This combination of options isn't handled for i386 targets and doesn't
1508 make much sense anyway, so don't allow it. */
1509 if (flag_prefetch_loop_arrays
> 0 && optimize_size
)
1511 warning (0, "-fprefetch-loop-arrays is not supported with -Os");
1512 flag_prefetch_loop_arrays
= 0;
1515 /* The presence of IEEE signaling NaNs, implies all math can trap. */
1516 if (flag_signaling_nans
)
1517 flag_trapping_math
= 1;
1519 /* We cannot reassociate if we want traps or signed zeros. */
1520 if (flag_associative_math
&& (flag_trapping_math
|| flag_signed_zeros
))
1522 warning (0, "-fassociative-math disabled; other options take precedence");
1523 flag_associative_math
= 0;
1526 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1527 if (flag_cx_limited_range
)
1528 flag_complex_method
= 0;
1530 /* With -fcx-fortran-rules, we do something in-between cheap and C99. */
1531 if (flag_cx_fortran_rules
)
1532 flag_complex_method
= 1;
1534 /* Targets must be able to place spill slots at lower addresses. If the
1535 target already uses a soft frame pointer, the transition is trivial. */
1536 if (!FRAME_GROWS_DOWNWARD
&& flag_stack_protect
)
1538 warning (0, "-fstack-protector not supported for this target");
1539 flag_stack_protect
= 0;
1541 if (!flag_stack_protect
)
1542 warn_stack_protect
= 0;
1544 /* ??? Unwind info is not correct around the CFG unless either a frame
1545 pointer is present or A_O_A is set. Fixing this requires rewriting
1546 unwind info generation to be aware of the CFG and propagating states
1548 if (flag_unwind_tables
&& !ACCUMULATE_OUTGOING_ARGS
1549 && flag_omit_frame_pointer
)
1551 warning (0, "unwind tables currently require a frame pointer "
1553 flag_omit_frame_pointer
= 0;
1556 /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error
1557 have not been set. */
1558 if (!global_options_set
.x_warnings_are_errors
1559 && warn_coverage_mismatch
1560 && (global_dc
->classify_diagnostic
[OPT_Wcoverage_mismatch
] ==
1562 diagnostic_classify_diagnostic (global_dc
, OPT_Wcoverage_mismatch
,
1563 DK_ERROR
, UNKNOWN_LOCATION
);
1565 /* Save the current optimization options. */
1566 optimization_default_node
= build_optimization_node ();
1567 optimization_current_node
= optimization_default_node
;
1570 /* This function can be called multiple times to reinitialize the compiler
1571 back end when register classes or instruction sets have changed,
1572 before each function. */
1574 backend_init_target (void)
1576 /* Initialize alignment variables. */
1579 /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
1580 to initialize reg_raw_mode[]. */
1583 /* This invokes target hooks to set fixed_reg[] etc, which is
1587 /* This depends on stack_pointer_rtx. */
1588 init_fake_stack_mems ();
1590 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1592 init_alias_target ();
1594 /* Depends on HARD_FRAME_POINTER_REGNUM. */
1597 /* The following initialization functions need to generate rtl, so
1598 provide a dummy function context for them. */
1599 init_dummy_function_start ();
1601 /* rtx_cost is mode-dependent, so cached values need to be recomputed
1602 on a mode change. */
1604 init_lower_subreg ();
1606 /* We may need to recompute regno_save_code[] and regno_restore_code[]
1607 after a mode change as well. */
1608 caller_save_initialized_p
= false;
1610 expand_dummy_function_end ();
1613 /* Initialize the compiler back end. This function is called only once,
1614 when starting the compiler. */
1621 init_inline_once ();
1622 init_varasm_once ();
1623 save_register_info ();
1625 /* Initialize the target-specific back end pieces. */
1627 backend_init_target ();
1630 /* Initialize excess precision settings. */
1632 init_excess_precision (void)
1634 /* Adjust excess precision handling based on the target options. If
1635 the front end cannot handle it, flag_excess_precision_cmdline
1636 will already have been set accordingly in the post_options
1638 gcc_assert (flag_excess_precision_cmdline
!= EXCESS_PRECISION_DEFAULT
);
1639 flag_excess_precision
= flag_excess_precision_cmdline
;
1640 if (flag_unsafe_math_optimizations
)
1641 flag_excess_precision
= EXCESS_PRECISION_FAST
;
1642 if (flag_excess_precision
== EXCESS_PRECISION_STANDARD
)
1644 int flt_eval_method
= TARGET_FLT_EVAL_METHOD
;
1645 switch (flt_eval_method
)
1649 /* Either the target acts unpredictably (-1) or has all the
1650 operations required not to have excess precision (0). */
1651 flag_excess_precision
= EXCESS_PRECISION_FAST
;
1655 /* In these cases, predictable excess precision makes
1659 /* Any other implementation-defined FLT_EVAL_METHOD values
1660 require the compiler to handle the associated excess
1661 precision rules in excess_precision_type. */
1667 /* Initialize things that are both lang-dependent and target-dependent.
1668 This function can be called more than once if target parameters change. */
1670 lang_dependent_init_target (void)
1672 /* This determines excess precision settings. */
1673 init_excess_precision ();
1675 /* This creates various _DECL nodes, so needs to be called after the
1676 front end is initialized. It also depends on the HAVE_xxx macros
1677 generated from the target machine description. */
1680 /* The following initialization functions need to generate rtl, so
1681 provide a dummy function context for them. */
1682 init_dummy_function_start ();
1684 /* Do the target-specific parts of expr initialization. */
1685 init_expr_target ();
1687 /* Although the actions of these functions are language-independent,
1688 they use optabs, so we cannot call them from backend_init. */
1692 expand_dummy_function_end ();
1695 /* Language-dependent initialization. Returns nonzero on success. */
1697 lang_dependent_init (const char *name
)
1699 location_t save_loc
= input_location
;
1700 if (dump_base_name
== 0)
1701 dump_base_name
= name
&& name
[0] ? name
: "gccdump";
1703 /* Other front-end initialization. */
1704 input_location
= BUILTINS_LOCATION
;
1705 if (lang_hooks
.init () == 0)
1707 input_location
= save_loc
;
1711 init_asm_output (name
);
1713 /* If stack usage information is desired, open the output file. */
1714 if (flag_stack_usage
)
1715 stack_usage_file
= open_auxiliary_file ("su");
1718 /* This creates various _DECL nodes, so needs to be called after the
1719 front end is initialized. */
1722 /* Do the target-specific parts of the initialization. */
1723 lang_dependent_init_target ();
1727 /* If dbx symbol table desired, initialize writing it and output the
1728 predefined types. */
1729 timevar_push (TV_SYMOUT
);
1731 /* Now we have the correct original filename, we can initialize
1733 (*debug_hooks
->init
) (name
);
1735 timevar_pop (TV_SYMOUT
);
1742 /* Reinitialize everything when target parameters, such as register usage,
1745 target_reinit (void)
1747 struct rtl_data saved_x_rtl
;
1748 rtx
*saved_regno_reg_rtx
;
1750 /* Save *crtl and regno_reg_rtx around the reinitialization
1751 to allow target_reinit being called even after prepare_function_start. */
1752 saved_regno_reg_rtx
= regno_reg_rtx
;
1753 if (saved_regno_reg_rtx
)
1755 saved_x_rtl
= *crtl
;
1756 memset (crtl
, '\0', sizeof (*crtl
));
1757 regno_reg_rtx
= NULL
;
1760 /* Reinitialize RTL backend. */
1761 backend_init_target ();
1763 /* Reinitialize lang-dependent parts. */
1764 lang_dependent_init_target ();
1766 /* And restore it at the end, as free_after_compilation from
1767 expand_dummy_function_end clears it. */
1768 if (saved_regno_reg_rtx
)
1770 *crtl
= saved_x_rtl
;
1771 regno_reg_rtx
= saved_regno_reg_rtx
;
1772 saved_regno_reg_rtx
= NULL
;
1777 dump_memory_report (bool final
)
1779 dump_line_table_statistics ();
1780 ggc_print_statistics ();
1781 stringpool_statistics ();
1782 dump_tree_statistics ();
1783 dump_gimple_statistics ();
1784 dump_rtx_statistics ();
1785 dump_alloc_pool_statistics ();
1786 dump_bitmap_statistics ();
1787 dump_vec_loc_statistics ();
1788 dump_ggc_loc_statistics (final
);
1789 dump_alias_stats (stderr
);
1790 dump_pta_stats (stderr
);
1793 /* Clean up: close opened files, etc. */
1796 finalize (bool no_backend
)
1798 /* Close the dump files. */
1799 if (flag_gen_aux_info
)
1801 fclose (aux_info_file
);
1803 unlink (aux_info_file_name
);
1806 /* Close non-debugging input and output files. Take special care to note
1807 whether fclose returns an error, since the pages might still be on the
1808 buffer chain while the file is open. */
1812 if (ferror (asm_out_file
) != 0)
1813 fatal_error ("error writing to %s: %m", asm_file_name
);
1814 if (fclose (asm_out_file
) != 0)
1815 fatal_error ("error closing %s: %m", asm_file_name
);
1818 if (stack_usage_file
)
1819 fclose (stack_usage_file
);
1825 finish_optimization_passes ();
1831 dump_memory_report (true);
1833 /* Language-specific end of compilation actions. */
1834 lang_hooks
.finish ();
1837 /* Initialize the compiler, and compile the input file. */
1841 /* Initialize timing first. The C front ends read the main file in
1842 the post_options hook, and C++ does file timings. */
1843 if (time_report
|| !quiet_flag
|| flag_detailed_statistics
)
1845 timevar_start (TV_TOTAL
);
1849 /* Don't do any more if an error has already occurred. */
1852 timevar_start (TV_PHASE_SETUP
);
1854 /* This must be run always, because it is needed to compute the FP
1855 predefined macros, such as __LDBL_MAX__, for targets using non
1856 default FP formats. */
1857 init_adjust_machine_modes ();
1859 /* Set up the back-end if requested. */
1863 /* Language-dependent initialization. Returns true on success. */
1864 if (lang_dependent_init (main_input_filename
))
1866 /* Initialize yet another pass. */
1868 ggc_protect_identifiers
= true;
1871 init_final (main_input_filename
);
1872 coverage_init (aux_base_name
);
1874 invoke_plugin_callbacks (PLUGIN_START_UNIT
, NULL
);
1876 timevar_stop (TV_PHASE_SETUP
);
1882 timevar_stop (TV_PHASE_SETUP
);
1885 timevar_start (TV_PHASE_FINALIZE
);
1887 finalize (no_backend
);
1889 timevar_stop (TV_PHASE_FINALIZE
);
1892 /* Stop timing and print the times. */
1893 timevar_stop (TV_TOTAL
);
1894 timevar_print (stderr
);
1897 /* Entry point of cc1, cc1plus, jc1, f771, etc.
1898 Exit code is FATAL_EXIT_CODE if can't open files or if there were
1899 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
1901 It is not safe to call this function more than once. */
1904 toplev_main (int argc
, char **argv
)
1906 /* Parsing and gimplification sometimes need quite large stack.
1907 Increase stack size limits if possible. */
1908 stack_limit_increase (64 * 1024 * 1024);
1910 expandargv (&argc
, &argv
);
1912 /* Initialization of GCC's environment, and diagnostics. */
1913 general_init (argv
[0]);
1915 /* One-off initialization of options that does not need to be
1916 repeated when options are added for particular functions. */
1917 init_options_once ();
1919 /* Initialize global options structures; this must be repeated for
1920 each structure used for parsing options. */
1921 init_options_struct (&global_options
, &global_options_set
);
1922 lang_hooks
.init_options_struct (&global_options
);
1924 /* Convert the options to an array. */
1925 decode_cmdline_options_to_array_default_mask (argc
,
1926 CONST_CAST2 (const char **,
1928 &save_decoded_options
,
1929 &save_decoded_options_count
);
1931 /* Perform language-specific options initialization. */
1932 lang_hooks
.init_options (save_decoded_options_count
, save_decoded_options
);
1934 /* Parse the options and do minimal processing; basically just
1935 enough to default flags appropriately. */
1936 decode_options (&global_options
, &global_options_set
,
1937 save_decoded_options
, save_decoded_options_count
,
1938 UNKNOWN_LOCATION
, global_dc
);
1940 handle_common_deferred_options ();
1944 initialize_plugins ();
1947 print_version (stderr
, "");
1950 print_plugins_help (stderr
, "");
1952 /* Exit early if we can (e.g. -help). */
1953 if (!exit_after_options
)
1956 if (warningcount
|| errorcount
)
1957 print_ignored_options ();
1958 diagnostic_finish (global_dc
);
1960 /* Invoke registered plugin callbacks if any. */
1961 invoke_plugin_callbacks (PLUGIN_FINISH
, NULL
);
1963 finalize_plugins ();
1965 return (FATAL_EXIT_CODE
);
1967 return (SUCCESS_EXIT_CODE
);